value_holder.hpp

//
// (c) Copyright 2013 DESY, Eugen Wintersberger <eugen.wintersberger@desy.de>
//
// This file is part of libpnicore.
//
// libpnicore 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.
//
// libpnicore 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 libpnicore.  If not, see <http://www.gnu.org/licenses/>.
//
// ============================================================================
//
// Created on: Jan 11, 2013
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//
#pragma once

#include "../types/type_id_map.hpp"
#include "value_holder_interface.hpp"

namespace pni{
namespace core{

    template<typename T> 
    T& get_ref(T &v) noexcept
    { 
        return v;
    } 

    //------------------------------------------------------------------------
    template<typename T> 
    const T& get_const_ref(const T &v) noexcept
    { 
        return v; 
    }

    //------------------------------------------------------------------------
    template<typename T> 
    T& get_ref(std::reference_wrapper<T> &v) noexcept
    {
        return v.get();
    }

    //------------------------------------------------------------------------
    template<typename T> 
    const T& get_const_ref(const std::reference_wrapper<T> &v) noexcept
    {
        return v.get();
    }


    //-------------------------------------------------------------------------
    template<typename T> struct is_reference_holder
    {
        static const bool value = false;
    };

    //-------------------------------------------------------------------------
    template<typename T> struct is_reference_holder<std::reference_wrapper<T> >
    {
        static const bool value = true;
    };

    //-------------------------------------------------------------------------
    template<typename T> struct get_reference_type
    {
        typedef T value_type;
        typedef T &reference_type;
        typedef const T &const_reference_type;
    };

    //-------------------------------------------------------------------------
    template<typename T> struct get_reference_type<std::reference_wrapper<T> >
    {
        typedef T value_type;
        typedef T &reference_type;
        typedef const  T &const_reference_type;
    };

    //-------------------------------------------------------------------------
    template<typename T> 
    class value_holder : public value_holder_interface
    {
        private:
            T _value; 

        public:
            //----------------------------------------------------------------
            value_holder():_value(T(0)) {}

            //----------------------------------------------------------------
            value_holder(T v):_value(v) {}


            //====================public inerface implementation==============
            virtual type_id_t type_id() const noexcept
            {
                typedef typename get_reference_type<T>::value_type value_type;
                return type_id_map<value_type >::type_id;
            }

            //----------------------------------------------------------------
            virtual value_holder_interface *clone() const
            {
                return new value_holder<T>(_value);
            }

            //----------------------------------------------------------------
            typename get_reference_type<T>::value_type as() const 
            { 
                return get_const_ref(_value);
            } 

            //----------------------------------------------------------------
            typename get_reference_type<T>::reference_type as()
            {
                return get_ref(_value);
            }

            //----------------------------------------------------------------
            virtual bool holds_reference() const
            {
                return is_reference_holder<T>::value;
            }
    };


//end of namespace
}
}