Environment.h

Go to the documentation of this file.

// -*- mode: C++; c-indent-level: 4; c-basic-offset: 4; indent-tabs-mode: nil; -*-
//
// Environment.h: Rcpp R/C++ interface class library -- access R environments
//
// 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_Environment_h
#define Rcpp_Environment_h

#include <RcppCommon.h>
#include <Rcpp/exceptions.h>
#include <Rcpp/Evaluator.h>
#include <Rcpp/Symbol.h>
#include <Rcpp/Language.h>

#include <Rcpp/RObject.h>

namespace Rcpp{ 

    class Environment: public RObject{
    public:
    
        class Binding {
        public:
            Binding( Environment& env, const std::string& name) ;
            
            bool active() const ;
            
            bool locked() const ;
            
            bool exists() const ;
            
            void lock( ) ;
            
            void unlock() ;
            
            /* lvalue uses */
            
            Binding& operator=(const Binding& rhs) ;
            
            Binding& operator=(SEXP rhs) ;
            
            template <typename WRAPPABLE>
            Binding& operator=(const WRAPPABLE& rhs){
                env.assign( name, rhs ) ;
                return *this ;
            }
            
            /* rvalue */
            template <typename T> 
            operator T() const{
                SEXP x = env.get(name) ;
                return as<T>(x) ;
            }
            
            
        private:
            Environment& env ;
            
            std::string name ;
        } ;
    
        const Binding operator[]( const std::string& name) const ;
    
        Binding operator[](const std::string& name) ;
    
        friend class Binding ;
    
        Environment() ;
    
        Environment(SEXP x);
    
        Environment(const Environment& other);
    
        Environment& operator=(const Environment& other); 
    
        Environment( const std::string& name );
    
        Environment( int pos );
    
        ~Environment() ;
        
        SEXP ls(bool all) const ;
    
        SEXP get(const std::string& name) const ;
    
        SEXP find( const std::string& name) const;
    
        bool exists( const std::string& name ) const ;
    
        bool assign( const std::string& name, SEXP x ) const;
    
        template <typename WRAPPABLE>
        bool assign( const std::string& name, const WRAPPABLE& x) const {
            return assign( name, wrap( x ) ) ;
        }
    
        bool isLocked() const ;
    
        bool remove( const std::string& name );
    
        void lock(bool bindings) ;
    
        void lockBinding(const std::string& name);
    
        void unlockBinding(const std::string& name);
    
        bool bindingIsLocked(const std::string& name) const;
    
        bool bindingIsActive(const std::string& name) const;
    
        bool is_user_database() const ;
    
        static Environment global_env();
    
        static Environment empty_env();
    
        static Environment base_env();
    
        static Environment base_namespace();
    
        static Environment Rcpp_namespace();
    
        static Environment namespace_env(const std::string& );
    
        Environment parent() const;
    
        Environment new_child(bool hashed) ; 
        
    };

} // namespace Rcpp

#endif