GCNode_PtrS11n.hpp

Go to the documentation of this file.

/*CXXR $Id: GCNode_PtrS11n.hpp 1391 2013-06-19 10:27:40Z 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 Lesser 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 Lesser General Public License
 *  along with this program; if not, a copy is available at
 *  http://www.r-project.org/Licenses/
 */

#ifndef GCNODE_PTRS11N_HPP
#define GCNODE_PTRS11N_HPP 1

#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>

#include "CXXR/GCNode.hpp"
#include "CXXR/S11nScope.hpp"

namespace CXXR {
    class GCNode::PtrS11n {
    private:
        friend class GCNode;

        template <class Ptr>
        struct Payload {
            typedef typename Ptr::type type;
        };

        template <class T>
        struct Payload<T*> {
            typedef T type;
        };

        template<class Archive>
        struct Loader {
            template <typename Ptr>
            static void invoke(Archive& ar, Ptr& ptr, const char* name)
            {
                GCNode* target;
                ar >> boost::serialization::make_nvp(name, target);
                if (target) {
                    GCNode* reloc = S11nScope::relocate(target);
                    if (reloc)
                        target = reloc;
                    // Note that the target may already have been
                    // exposed, e.g. as a result of deserialising
                    // another pointer pointing to it.
                    else if (!target->isExposed())
                        target->expose();
                }
                ptr = static_cast<typename Payload<Ptr>::type*>(target);
            }
        };

        template<class Archive>
        struct Saver {
            template <typename Ptr>
            static void invoke(Archive& ar, const Ptr& ptr, const char* name)
            {
                const GCNode* target
                    = static_cast<typename Payload<Ptr>::type*>(ptr);
                ar << boost::serialization::make_nvp(name, target);
            }
        };
    public:
        template<class Archive, typename Ptr>
        static void invoke(Archive& ar, Ptr& ptr, const char* name)
        {
            using namespace boost::mpl;
            typedef typename eval_if<typename Archive::is_saving,
                identity<Saver<Archive> >,
                identity<Loader<Archive> > >::type typex;
            typex::invoke(ar, ptr, name);
        }
    };

} // namespace CXXR

#define GCNPTR_SERIALIZE(ar, name) \
        GCNode::PtrS11n::invoke(ar, name, #name )

#endif  // GCNODE_PTRS11N_HPP