RObject.h

Go to the documentation of this file.

// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*-
//
// RObject.h: Rcpp R/C++ interface class library -- general R object wrapper
//
// Copyright (C) 2009 - 2012    Dirk Eddelbuettel and Romain Francois
//
// This file is part of Rcpp.
//
// Rcpp 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 of the License, or
// (at your option) any later version.
//
// Rcpp 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Rcpp.  If not, see <http://www.gnu.org/licenses/>.

#ifndef Rcpp_RObject_h
#define Rcpp_RObject_h

#define R_NO_REMAP
#include <R.h>
#include <Rcpp/macros/macros.h>
#include <Rinternals.h>
#include <vector>
#include <string>

namespace Rcpp{ 

    class RObject {
    public:
        
        RObject() ; 

        RObject(SEXP x) ;

        RObject( const RObject& other ) ;

        RObject& operator=( const RObject& other ) ;

        RObject& operator=( SEXP other ) ;

        virtual ~RObject() ;

        inline operator SEXP() const { return m_sexp ; }

        inline bool inherits(const char* clazz) const { return ::Rf_inherits( m_sexp, clazz) ; }
    
        /* attributes */

        std::vector<std::string> attributeNames() const ;

        bool hasAttribute( const std::string& attr) const ; 

        class AttributeProxy {
        public:
                
            AttributeProxy( const RObject& v, const std::string& attr_name) ;

            AttributeProxy& operator=(const AttributeProxy& rhs) ;
                
            template <typename T> AttributeProxy& operator=(const T& rhs) ; 
                
            template <typename T> operator T() const ;
            
            inline operator SEXP() const { return get() ; }
            
        private:
            const RObject& parent; 
            std::string attr_name ;
                
            SEXP get() const ;
            void set(SEXP x) const ;
        } ;
        
        class SlotProxy {
        public:
            SlotProxy( const RObject& v, const std::string& name) ;

            SlotProxy& operator=(const SlotProxy& rhs) ;
                  
            template <typename T> SlotProxy& operator=(const T& rhs) ;
                
            template <typename T> operator T() const ;
            inline operator SEXP() const { return get() ; }
            
        private:
            const RObject& parent; 
            std::string slot_name ;
                
            SEXP get() const ;
            void set(SEXP x ) const;
        } ;
        friend class SlotProxy ;    
        
        AttributeProxy attr( const std::string& name) const  ;
    
        inline bool isNULL() const{ return Rf_isNull(m_sexp) ; }

        inline int sexp_type() const { return TYPEOF(m_sexp) ; }

        inline SEXP asSexp() const { return m_sexp ; }

        inline bool isObject() const { return ::Rf_isObject(m_sexp) ;}

        inline bool isS4() const { return ::Rf_isS4(m_sexp) ; }

        bool hasSlot(const std::string& name) const ;

        SlotProxy slot(const std::string& name) const ;
    
    protected:                                  

        void setSEXP(SEXP x) ;

        SEXP m_sexp ;
    
    };

} // namespace Rcpp

#endif