NAAugment.hpp

Go to the documentation of this file.

/*CXXR $Id: NAAugment.hpp 1351 2013-03-08 15:12:28Z 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 */

#ifndef NAAUGMENT_HPP
#define NAAUGMENT_HPP 1

#include "CXXR/ElementTraits.hpp"

namespace CXXR {
    template <typename T> class NAAugment {
    public:
        NAAugment()
            : m_na(true)
        {}

        template <typename U>
        explicit NAAugment(const U& value)
            : m_value(value), m_na(false)
        {}

        template <typename U>
        NAAugment<T>& operator=(const U& value)
        {
            m_value = value;
            m_na = false;
            return *this;
        }

        operator T&()
        {
            return m_value;
        }

        operator const T&() const
        {
            return m_value;
        }

        bool isNA() const
        {
            return m_na;
        }

        static const NAAugment<T>& NA()
        {
            static NAAugment<T> na;
            return na;
        }

        template <class Archive>
        void serialize(Archive& ar, const unsigned int file_version);

        T& value()
        {
            return m_value;
        }

        const T& value() const
        {
            return m_value;
        }
    private:
        T m_value;
        bool m_na;
    };

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

    template <class T>
    template <class Archive>
    void CXXR::NAAugment<T>::serialize(Archive& ar,
                                       const unsigned int file_version)
    {
        ar & BOOST_SERIALIZATION_NVP(m_value);
        ar & BOOST_SERIALIZATION_NVP(m_na);
    }

    // ***** Template specializations *****
    namespace ElementTraits {
        template <class T>
        struct Data<NAAugment<T> > {
            typedef T type;

            static const type& get(const NAAugment<T>& t)
            {
                return t.value();
            }
        };

        template <class T>
        struct MustConstruct<NAAugment<T> > : boost::mpl::true_ 
        {};

        template <class T>
        struct MustDestruct<NAAugment<T> >  : boost::mpl::true_
        {};

        template <class T>
        struct NAFunc<NAAugment<T> > {
            const NAAugment<T>& operator()() const
            {
                return NAAugment<T>::NA();
            }
        };

        template <class T>
        struct IsNA<NAAugment<T> > {
            bool operator()(const NAAugment<T>& t) const
            {
                return t.isNA();
            }
        };
    }  // namespace ElementTraits
}  // namespace CXXR

#endif  // NAAUGMENT_HPP