VectorBase.h

Go to the documentation of this file.

/*CXXR $Id: VectorBase.h 1351 2013-03-08 15:12:28Z 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.
 *  Andrew Runnalls (C) 2008
 *
 *  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 VECTORBASE_H
#define VECTORBASE_H

#include "CXXR/RObject.h"

/* type for length of vectors etc */
typedef int R_len_t; /* will be long later, LONG64 or ssize_t on Win64 */

#define R_LEN_T_MAX INT_MAX

#ifdef __cplusplus

#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/nvp.hpp>

#include "CXXR/ElementTraits.hpp"
#include "CXXR/GCStackRoot.hpp"
#include "CXXR/SEXP_downcast.hpp"

namespace CXXR {
    class String;
    template <typename, SEXPTYPE,
              typename Initializer = RObject::DoNothing> class FixedVector;
    typedef FixedVector<int, INTSXP> IntVector;
    typedef FixedVector<RHandle<>, VECSXP> ListVector;
    typedef FixedVector<RHandle<String>, STRSXP> StringVector;

    class VectorBase : public RObject {
    public:
        VectorBase(SEXPTYPE stype, std::size_t sz)
            : RObject(stype), m_truelength(sz), m_size(sz)
        {}

        VectorBase(const VectorBase& pattern)
            : RObject(pattern), m_truelength(pattern.m_truelength),
              m_size(pattern.m_size)
        {}

        const ListVector* dimensionNames() const;

        const StringVector* dimensionNames(unsigned int d) const;

        const IntVector* dimensions() const;

        const StringVector* names() const;

        template <class V>
        static V* resize(const V* pattern, std::size_t new_size);

        static PairList* resizeAttributes(const PairList* attributes,
                                          std::size_t new_size);

        void setDimensionNames(ListVector* names);

        void setDimensionNames(unsigned int d, StringVector* names);

        void setDimensions(IntVector* dims);

        void setNames(StringVector* names);

        virtual void setSize(std::size_t new_size);

        std::size_t size() const
        {
            return m_size;
        }

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

        // Virtual function of RObject, redeclared for covariant
        // return type:
        VectorBase* clone() const
        {
            return 0;
        }

        // Make private in due course (or get rid altogether):
        R_len_t m_truelength;
    protected:
        ~VectorBase() {}

        void adjustSize(std::size_t new_size)
        {
            m_size = new_size;
            setAttributes(resizeAttributes(attributes(), new_size));
        }

    private:
        friend class boost::serialization::access;

        size_t m_size;

        // m_size will always be passed in by the constructor, and so
        // is not serialised.
        template<class Archive>
        void serialize(Archive & ar, const unsigned int version)
        {
            ar & BOOST_SERIALIZATION_BASE_OBJECT_NVP(RObject);
            ar & BOOST_SERIALIZATION_NVP(m_truelength);
        }
    };

    template <class V>
    V* VectorBase::resize(const V* pattern, std::size_t new_size)
    {
        GCStackRoot<V> ans(CXXR_NEW(V(new_size)));
        std::size_t copysz = std::min(pattern->size(), new_size);
        typename V::const_iterator patb = pattern->begin();
        typename V::iterator ansit
            = std::copy(patb, patb + copysz, ans->begin());
        std::fill(ansit, ans->end(), NA<typename V::value_type>());
        ans->setAttributes(resizeAttributes(pattern->attributes(), new_size));
        ans->setS4Object(pattern->isS4Object());
        return ans;
    }
}  // namespace CXXR

extern "C" {

#endif /* __cplusplus */

    /* Accessor functions */

    /* Vector Access Functions */

#ifndef __cplusplus
    int LENGTH(SEXP x);
#else
    inline int LENGTH(SEXP x)
    {
        using namespace CXXR;
        if (!x) return 0;
        VectorBase& vb = *SEXP_downcast<VectorBase*>(x);
        return vb.size();
    }
#endif

#ifndef __cplusplus
    int TRUELENGTH(SEXP x);
#else
    inline int TRUELENGTH(SEXP x)
    {
        using namespace CXXR;
        VectorBase& vb = *SEXP_downcast<VectorBase*>(x);
        return vb.m_truelength;
    }
#endif

    void SETLENGTH(SEXP x, int v);

#ifndef __cplusplus
    void SET_TRUELENGTH(SEXP x, int v);
#else
    inline void SET_TRUELENGTH(SEXP x, int v)
    {
        using namespace CXXR;
        VectorBase& vb = *SEXP_downcast<VectorBase*>(x);
        vb.m_truelength = v;
    }
#endif

    SEXP Rf_allocVector(SEXPTYPE stype, R_len_t length);

    Rboolean Rf_isVector(SEXP s);

#ifdef __cplusplus
}
#endif

#endif /* VECTORBASE_H */