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 - 2011    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

#include <RcppCommon.h>

namespace Rcpp{ 

    namespace internal{
     
        class SEXPstack {
        public:
            SEXPstack() ;
            void preserve( SEXP ) ;
            void release( SEXP ) ;
        private:
            SEXP stack ;
            SEXP* data ;
            int len, top ;
            
            void grow( ) ;
        } ;
    
    }
    
    
    
    class RObject {
    public:
        
        RObject() : m_sexp(R_NilValue) {} ; 

        RObject(SEXP x) : m_sexp(R_NilValue) { setSEXP(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){
                set( wrap(rhs) ) ;
                return *this ;
            }
                
            template <typename T> operator T() const {
                return as<T>(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){
                set( wrap(rhs) ) ;
                return *this ;
            }
                
            template <typename T> operator T() const {
                return as<T>(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 ;
    
    private:

        //    static internal::SEXPstack PPstack ;
        //    void preserve(){ if( m_sexp != R_NilValue ) PPstack.preserve(m_sexp) ; } 
        //    void release() { if( m_sexp != R_NilValue ) PPstack.release(m_sexp) ; }

        void preserve(){ if( m_sexp != R_NilValue ) R_PreserveObject(m_sexp) ; }
        void release() { if( m_sexp != R_NilValue ) R_ReleaseObject(m_sexp) ; } 
    
        virtual void update() {
            RCPP_DEBUG_1( "RObject::update(SEXP = <%p> )", m_sexp ) ; 
        } ;
    
    };

} // namespace Rcpp

#endif