Provenance.hpp

Go to the documentation of this file.

/*CXXR $Id: Provenance.hpp 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 */

/* This file incorporates material Copyright (C) Chris A. Silles 2009-12.
 */

/*
 *  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 PROVENANCE_HPP
#define PROVENANCE_HPP 1

#include <sys/time.h>
#include <ctime>
#include <set>
#include <boost/serialization/access.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/split_member.hpp>

#include "CXXR/CommandChronicle.hpp"
#include "CXXR/Expression.h"
#include "CXXR/GCEdge.hpp"
#include "CXXR/GCStackRoot.hpp"
#include "CXXR/RObject.h"
#include "CXXR/StringVector.h"
#include "CXXR/Symbol.h"

namespace CXXR {
    class Provenance : public GCNode {
    public:
        class CompTime {
        public:
            bool operator()(const Provenance* lhs, const Provenance* rhs) const
            {
                return (lhs->m_timestamp.tv_sec == rhs->m_timestamp.tv_sec) ?
                    (lhs->m_timestamp.tv_usec < rhs->m_timestamp.tv_usec) :
                    (lhs->m_timestamp.tv_sec < rhs->m_timestamp.tv_sec);
            }
        };

        typedef std::set<const Provenance*, Provenance::CompTime> Set;

        Provenance(const Symbol* sym, const CommandChronicle* chron);

        ~Provenance()
        {
            announceDeath(); // Necessary house-keeping
        }

        static Set* ancestors(const Set& roots);

        const Set& children() const
        {
            return m_children;
        }

        const CommandChronicle* chronicle() const
        {
            return m_chronicle;
        }

        const RObject* command() const
        {
            return m_chronicle->command();
        }

        static Set* descendants(const Set& roots);

        const String* getTime() const;

        std::pair<CommandChronicle::ParentVector::const_iterator,
                  CommandChronicle::ParentVector::const_iterator>
        parents() const;

        const Symbol* symbol() const
        {
            return m_symbol;
        }

        const RObject* value() const
        {
            return m_value;
        }

        bool isXenogenous() const
        {
            return m_xenogenous;
        }

        unsigned int serialNumber() const
        {
            return m_serial;
        }

        void setXenogenous(const RObject* value);

        double timestamp() const;

        // Virtual functions of GCNode:
        void detachReferents();
        void visitReferents(const_visitor*) const;
    private:
        friend class boost::serialization::access;

        static unsigned int s_next_serial;

        mutable Set m_children;
        struct timeval m_timestamp;

        unsigned int m_serial;  // Within a session each Provenance
          // object is given a unique serial number.  This serial
          // number is not preserved during serialisation.

        unsigned int m_num_parents;
        GCEdge<const Symbol> m_symbol;
        GCEdge<const CommandChronicle> m_chronicle;
        GCEdge<const RObject> m_value;
        bool m_xenogenous;

        // Do away with compiler-generated copy constructor
        Provenance(const Provenance&);

        void announceBirth();

        void announceDeath();

        void deregisterChild(const Provenance* child) const
        {
            m_children.erase(child);
        }

        void registerChild(const Provenance* child) const
        {
            m_children.insert(child);
        }

        template <class Archive>
        void load(Archive& ar, const unsigned int version);
                
        template <class Archive>
        void save(Archive& ar, const unsigned int version) const;

        template <class Archive>
        void serialize(Archive & ar, const unsigned int version) {
            boost::serialization::split_member(ar, *this, version);
        }
    };
} // namespace CXXR

BOOST_CLASS_EXPORT_KEY(CXXR::Provenance)

namespace boost {
    namespace serialization {
        template<class Archive>
        void load_construct_data(Archive& ar, CXXR::Provenance* prov,
                                 const unsigned int version)
        {
            using namespace CXXR;
            GCStackRoot<const Symbol> symbol;
            GCNPTR_SERIALIZE(ar, symbol);
            GCStackRoot<const CommandChronicle> chronicle;
            GCNPTR_SERIALIZE(ar, chronicle);
            new (prov) Provenance(symbol, chronicle);
        }

        template<class Archive>
        void save_construct_data(Archive& ar, const CXXR::Provenance* prov,
                                 const unsigned int version)
        {
            using namespace CXXR;
            const Symbol* symbol = prov->symbol();
            GCNPTR_SERIALIZE(ar, symbol);
            const CommandChronicle* chronicle = prov->chronicle();
            GCNPTR_SERIALIZE(ar, chronicle);
        }
    }  // namespace serialization
}  // namespace boost

// ***** Implementation of non-inlined templated members *****

template <class Archive>
void CXXR::Provenance::load(Archive& ar, const unsigned int version)
{
    ar >> BOOST_SERIALIZATION_BASE_OBJECT_NVP(GCNode);
    ar >> boost::serialization::make_nvp("sec", m_timestamp.tv_sec);
    ar >> boost::serialization::make_nvp("usec", m_timestamp.tv_usec);
    ar >> BOOST_SERIALIZATION_NVP(m_num_parents);
    GCNPTR_SERIALIZE(ar, m_value);
    ar >> BOOST_SERIALIZATION_NVP(m_xenogenous);

    announceBirth();
}
                
template <class Archive>
void CXXR::Provenance::save(Archive& ar, const unsigned int version) const
{
    ar << BOOST_SERIALIZATION_BASE_OBJECT_NVP(GCNode);
    ar << boost::serialization::make_nvp("sec", m_timestamp.tv_sec);
    ar << boost::serialization::make_nvp("usec", m_timestamp.tv_usec);
    ar << BOOST_SERIALIZATION_NVP(m_num_parents);
    GCNPTR_SERIALIZE(ar, m_value);
    ar << BOOST_SERIALIZATION_NVP(m_xenogenous);
}

#endif