CachedString.h

Go to the documentation of this file.

/*CXXR $Id: CachedString.h 1275 2012-03-17 14:01:29Z arr $
 *CXXR
 *CXXR This file is part of CXXR, a project to refactor the R interpreter
 *CXXR into C++.  It may consist in whole or in part of program code and
 *CXXR documentation taken from the R project itself, incorporated into
 *CXXR CXXR (and possibly MODIFIED) under the terms of the GNU General Public
 *CXXR Licence.
 *CXXR 
 *CXXR CXXR is Copyright (C) 2008-12 Andrew R. Runnalls, subject to such other
 *CXXR copyrights and copyright restrictions as may be stated below.
 *CXXR 
 *CXXR CXXR is not part of the R project, and bugs and other issues should
 *CXXR not be reported via r-bugs or other R project channels; instead refer
 *CXXR to the CXXR website.
 *CXXR */

/*
 *  R : A Computer Language for Statistical Data Analysis
 *  Copyright (C) 1995, 1996  Robert Gentleman and Ross Ihaka
 *  Copyright (C) 1999-2006   The R Development Core Team.
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2.1 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, a copy is available at
 *  http://www.r-project.org/Licenses/
 */

#ifndef CACHEDSTRING_H
#define CACHEDSTRING_H

#include "CXXR/String.h"

#ifdef __cplusplus

#include <tr1/unordered_map>
#include <string>

#include "CXXR/Allocator.hpp"
#include "CXXR/SchwarzCounter.hpp"

namespace CXXR {
    class CachedString : public String {
    public:
        static CachedString* blank()
        {
            return s_blank;
        }

        static CachedString* obtain(const std::string& str,
                                    cetype_t encoding = CE_NATIVE);

        static const char* staticTypeName()
        {
            return "char (cached)";
        }

        const std::string& stdstring() const
        {
            return m_key_val_pr->first.first;
        }

        // Virtual function of RObject:
        const char* typeName() const;
    private:
        // The first element of the key is the text, the second
        // element the encoding:
        typedef std::pair<std::string, cetype_t> key;

        // Hashing is based simply on the text of the key, not on its
        // encoding:
        class Hasher : public std::unary_function<key, std::size_t> {
        public:
            std::size_t operator()(const key& k) const
            {
                return s_string_hasher(k.first);
            }
        private:
            static std::tr1::hash<std::string> s_string_hasher;
        };

        // The cache is implemented as a mapping from keys to pointers
        // to CachedString objects.  Each CachedString simply contains
        // a pointer locating its entry within the cache.
        typedef
        std::tr1::unordered_map<key, CachedString*, Hasher,
                                std::equal_to<key>,
                                CXXR::Allocator<std::pair<const key,
                                                          CachedString*> >
                                > map;

        static map* s_cache;
        static CachedString* s_blank;

        map::value_type* m_key_val_pr;
        mutable Symbol* m_symbol;  // Pointer to the Symbol object identified
          // by this CachedString, or a null pointer if none.

        explicit CachedString(map::value_type* key_val_pr)
            : String(key_val_pr->first.first.size(), key_val_pr->first.second),
            m_key_val_pr(key_val_pr), m_symbol(0)
        {
            setCString(key_val_pr->first.first.c_str());
        }

        // Not implemented.  Declared to prevent
        // compiler-generated versions:
        CachedString(const CachedString&);
        CachedString& operator=(const CachedString&);

        // Declared private to ensure that CachedString objects are
        // allocated only using 'new'.
        ~CachedString();

        static void cleanup();

        // Initialize the static data members:
        static void initialize();

        friend class SchwarzCounter<CachedString>;
        friend class Symbol;
    };
}  // namespace CXXR

namespace {
    CXXR::SchwarzCounter<CXXR::CachedString> cachedstring_schwarz_ctr;
}

extern "C" {

#endif /* __cplusplus */

#ifndef __cplusplus
    int IS_CACHED(SEXP x);
#else
    inline int IS_CACHED(SEXP x)
    {
        // Use explicit namespace qualification to avoid ambiguities:
        const CXXR::String* str = CXXR::SEXP_downcast<const CXXR::String*>(x);
        return (dynamic_cast<const CXXR::CachedString*>(str) != 0);
    }
#endif

#ifndef __cplusplus
    SEXP Rf_mkChar(const char * str);
#else
    inline SEXP Rf_mkChar(const char * str)
    {
        return CXXR::CachedString::obtain(str);
    }
#endif
    
#ifndef __cplusplus
    SEXP Rf_mkCharCE(const char * str, cetype_t encoding);
#else
    inline SEXP Rf_mkCharCE(const char * str, cetype_t encoding)
    {
        return CXXR::CachedString::obtain(str, encoding);
    }
#endif

    SEXP Rf_mkCharLenCE(const char* text, int length, cetype_t encoding);

#ifndef __cplusplus
    SEXP Rf_mkCharLen(const char* text, int length);
#else
    inline SEXP Rf_mkCharLen(const char* text, int length)
    {
        return Rf_mkCharLenCE(text, length, CE_NATIVE);
    }
#endif

#ifdef __cplusplus
}  // extern "C"
#endif

#endif /* CACHEDSTRING_H */