String.h

Go to the documentation of this file.

/*CXXR $Id: String.h 1390 2013-06-11 14:41:41Z 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-13 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 CXXR_STRING_H
#define CXXR_STRING_H

#include "CXXR/GCRoot.h"
#include "CXXR/VectorBase.h"

typedef enum {
    CE_NATIVE = 0,
    CE_UTF8   = 1,
    CE_LATIN1 = 2,
    CE_BYTES  = 3,
    CE_SYMBOL = 5,
    CE_ANY    =99
} cetype_t;

#ifdef __cplusplus

#include <boost/serialization/nvp.hpp>
#include <tr1/unordered_map>
#include <string>

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

namespace CXXR {
    class String : public VectorBase {
    public:
        class Comparator {
        public:
            explicit Comparator(bool na_last = true)
                : m_na_last(na_last)
            {}

            bool operator()(const String* l, const String* r) const;
        private:
            bool m_na_last;
        };

        char operator[](unsigned int index) const
        {
            return m_string->c_str()[index];
        }

        static String* blank()
        {
            return s_blank;
        }

        const char* c_str() const
        {
            return m_string->c_str();
        }

        cetype_t encoding() const
        {
            return m_encoding;
        }

        static cetype_t GPBits2Encoding(unsigned int gpbits);

        bool isASCII() const
        {
            return m_ascii;
        }

        bool isNA() const
        {
            return this == s_na;
        }

        static String* NA()
        {
            return s_na;
        }

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

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

        const std::string& stdstring() const
        {
            return *m_string;
        }

        // Virtual functions of RObject:
        unsigned int packGPBits() const;
        const char* typeName() const;
    private:
        friend class boost::serialization::access;
        friend class SchwarzCounter<String>;
        friend class Symbol;

        // 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 String objects.  Each String simply contains a pointer
        // locating its entry within the cache.
        typedef
        std::tr1::unordered_map<key, String*, Hasher, std::equal_to<key>,
                                CXXR::Allocator<std::pair<const key,
                                                          String*> >
                                > map;

        static map* s_cache;
        static std::string* s_na_string;
        static String* s_na;
        static String* s_blank;

        map::value_type* m_key_val_pr;
        const std::string* m_string;
        cetype_t m_encoding;
        mutable Symbol* m_symbol;  // Pointer to the Symbol object identified
          // by this String, or a null pointer if none.
        bool m_ascii;

        // A null value of key_val_pr is used to designate the NA string:
        explicit String(map::value_type* key_val_pr = 0);

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

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

        static void cleanup();

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

        template<class Archive>
        void load(Archive & ar, const unsigned int version);

        template<class Archive>
        void save(Archive & ar, const unsigned int version) const;

        // Fields not serialised here are set up by the constructor:
        template <class Archive>
        void serialize(Archive& ar, const unsigned int version) {
            boost::serialization::split_member(ar, *this, version);
        }
    };

    bool isASCII(const std::string& str);
}  // namespace CXXR

BOOST_CLASS_EXPORT_KEY(CXXR::String)

namespace {
    CXXR::SchwarzCounter<CXXR::String> string_schwarz_ctr;
}
    
// ***** Implementation of non-inlined templated members *****

template<class Archive>
void CXXR::String::load(Archive& ar, const unsigned int version)
{
    // This will only ever be applied to a 'temporary' String
    // created by the default constructor.
    ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(RObject);
    bool isna;
    ar >> BOOST_SERIALIZATION_NVP(isna);
    if (isna)
        S11nScope::defineRelocation(this, NA());
    else {
        std::string str;
        ar >> boost::serialization::make_nvp("string", str);
        ar >> BOOST_SERIALIZATION_NVP(m_encoding);
        S11nScope::defineRelocation(this, obtain(str, m_encoding));
    }
}

template<class Archive>
void CXXR::String::save(Archive& ar, const unsigned int version) const
{
    ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(RObject);
    bool isna = (this == NA());
    ar << BOOST_SERIALIZATION_NVP(isna);
    if (!isna) {
        std::string str = stdstring();
        ar << boost::serialization::make_nvp("string", str);
        ar << BOOST_SERIALIZATION_NVP(m_encoding);
    }
}

extern "C" {

#endif /* __cplusplus */

    extern SEXP R_NaString;
    extern SEXP R_BlankString;

#ifndef __cplusplus
    int ENC_KNOWN(SEXP x);
#else
    inline int ENC_KNOWN(SEXP x)
    {
        // Use explicit namespace qualification to prevent ambiguities:
        const CXXR::String& str = *CXXR::SEXP_downcast<const CXXR::String*>(x);
        cetype_t enc = str.encoding();
        return enc == CE_LATIN1 || enc == CE_UTF8;
    }
#endif

#ifndef __cplusplus
    int IS_ASCII(SEXP x);
#else
    inline int IS_ASCII(SEXP x)
    {
        // Use explicit namespace qualification to prevent ambiguities:
        const CXXR::String& str = *CXXR::SEXP_downcast<const CXXR::String*>(x);
        return Rboolean(str.isASCII());
    }
#endif

#ifndef __cplusplus
    int IS_BYTES(SEXP x);
#else
    inline int IS_BYTES(SEXP x)
    {
        // Use explicit namespace qualification to prevent ambiguities:
        const CXXR::String& str = *CXXR::SEXP_downcast<const CXXR::String*>(x);
        return Rboolean(str.encoding() == CE_BYTES);
    }
#endif

#ifndef __cplusplus
    Rboolean IS_LATIN1(SEXP x);
#else
    inline Rboolean IS_LATIN1(SEXP x)
    {
        // Use explicit namespace qualification to prevent ambiguities:
        const CXXR::String& str = *CXXR::SEXP_downcast<const CXXR::String*>(x);
        return Rboolean(str.encoding() == CE_LATIN1);
    }
#endif

#ifndef __cplusplus
    Rboolean IS_UTF8(SEXP x);
#else
    inline Rboolean IS_UTF8(SEXP x)
    {
        // Use explicit namespace qualification to prevent ambiguities:
        const CXXR::String& str = *CXXR::SEXP_downcast<const CXXR::String*>(x);
        return Rboolean(str.encoding() == CE_UTF8);
    }
#endif

#ifndef __cplusplus
    const char *R_CHAR(SEXP x);
#else
    inline const char *R_CHAR(SEXP x)
    {
        using namespace CXXR;
        return SEXP_downcast<String*>(x, false)->stdstring().c_str();
    }
#endif

#ifndef __cplusplus
    SEXP Rf_mkChar(const char* str);
#else
    inline SEXP Rf_mkChar(const char* str)
    {
        return CXXR::String::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::String::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

    const char* Rf_translateCharUTF8(SEXP x);

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

#endif /* CXXR_STRING_H */