GCRoot.h

Go to the documentation of this file.

/*CXXR $Id: GCRoot.h 1353 2013-03-18 16:59:38Z 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
 *
 *  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 GCROOT_H
#define GCROOT_H 1

#include "CXXR/RObject.h"

#ifdef __cplusplus

#include <list>
#include <tr1/unordered_map>
#include "CXXR/GCNode.hpp"

namespace CXXR {
    class RObject;

    class GCRootBase {
    public:
        static void visitRoots(GCNode::const_visitor* v);
    protected:
        GCRootBase(const GCNode* node);

        GCRootBase(const GCRootBase& source)
            : m_it(s_roots->insert(s_roots->end(), *source.m_it))
        {
            GCNode::incRefCount(*m_it);
        }

        ~GCRootBase()
        {
            const GCNode* node = *m_it;
            GCNode::decRefCount(node);
            s_roots->erase(m_it);
        }

        GCRootBase& operator=(const GCRootBase& source)
        {
            const GCNode* newnode = *source.m_it;
            GCNode::incRefCount(newnode);
            const GCNode* oldnode = *m_it;
            GCNode::decRefCount(oldnode);
            *m_it = newnode;
            return *this;
        }

        void redirect(const GCNode* node)
        {
            GCNode::maybeCheckExposed(node);
            GCNode::incRefCount(node);
            const GCNode* oldnode = *m_it;
            GCNode::decRefCount(oldnode);
            *m_it = node;
        }

        const GCNode* ptr() const
        {
            return *m_it;
        }
    private:
        friend class GCNode;

        typedef std::list<const GCNode*, Allocator<const GCNode*> > List;
        static List* s_roots;

        List::iterator m_it;

        // Clean up static data at end of run (called by
        // GCNode::SchwarzCtr destructor:
        static void cleanup() {}

        // Initialize static data (called by GCNode::SchwarzCtr
        // constructor):
        static void initialize();
    };

    template <class T = RObject>
    class GCRoot : public GCRootBase {
    public:
    explicit GCRoot(T* node = 0)
    : GCRootBase(node) {}

        GCRoot(const GCRoot& source) : GCRootBase(source) {}

        GCRoot& operator=(const GCRoot& source)
        {
            GCRootBase::operator=(source);
            return *this;
        }

        GCRoot& operator=(T* node)
        {
            GCRootBase::redirect(node);
            return *this;
        }

        T* operator->() const
        {
            return get();
        }

        T& operator*() const
        {
            return *get();
        }

        operator T*() const
        {
            return get();
        }

        T* get() const
        {
            return static_cast<T*>(const_cast<GCNode*>(ptr()));
        }
    };
}  // namespace CXXR

// For hashing, simply hash the encapsulated pointer:
namespace std {
    namespace tr1 {
        template <class T>
        struct hash<CXXR::GCRoot<T> > {
            std::size_t operator()(const CXXR::GCRoot<T>& gcrt) const
            {
                std::tr1::hash<T*> make_hash;
                return make_hash(gcrt);
            }
        };
    }
}

extern "C" {
#endif /* __cplusplus */

    /* ***** C interface ***** */

    void R_PreserveObject(SEXP object);

    void R_ReleaseObject(SEXP object);

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

#endif  // GCROOT_H