value_ref.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<iostream>
#include<memory>

#include "../error/exceptions.hpp"
#include "../types/types.hpp"
#include "value_holder.hpp"
#include "utils.hpp"

namespace pni{
namespace core{

    class value;

    class value_ref
    {
        private:
            typedef std::unique_ptr<value_holder_interface> pointer_type;

            //----------------------------------------------------------------
            void _check_pointer(const exception_record &r) const;

            //----------------------------------------------------------------
            void _check_type(type_id_t tid,const exception_record &r) const;

            //----------------------------------------------------------------
            template<
                     typename T,
                     typename S 
                    > 
            T _get() const
            {
                return get_value<T,S>(get_holder_ptr<ref_type<S>>(_ptr));
            }

            //----------------------------------------------------------------
            template<
                     typename S,
                     typename T
                    > 
            void _set(const T& v) const
            {
                return set_value<S,T>(get_holder_ptr<ref_type<S>>(_ptr),v);
            }

            pointer_type _ptr;
        public:
            //================constructors and destructor======================
            value_ref();
          
            //-----------------------------------------------------------------

            template<typename T>
            explicit value_ref(std::reference_wrapper<T> v):
                _ptr(new value_holder<std::reference_wrapper<T> >(v))
            {}

            //-----------------------------------------------------------------
            value_ref(const value_ref &o);

            //==================assignment operators===========================
            template<typename T> value_ref &operator=(const T &v);

            //----------------------------------------------------------------
            value_ref &operator=(const value &v);

            //-----------------------------------------------------------------
            // we should remove this - makes not really sense. We can 
            // always destroy the reference and create a new one (could we?)
            value_ref &operator=(const value_ref &o);

            //-----------------------------------------------------------------
            operator value () const;

            //-----------------------------------------------------------------
            template<typename T> T as() const;

            //-----------------------------------------------------------------
            type_id_t type_id() const;

    };

    //======================implementation of template members=================
    template<typename T> T value_ref::as() const
    {
        //check if the reference points to something
        _check_pointer(EXCEPTION_RECORD);

        type_id_t tid = type_id();
        switch(tid)
        {
            case type_id_t::UINT8:      return _get<T,uint8>();
            case type_id_t::INT8:       return _get<T,int8>();
            case type_id_t::UINT16:     return _get<T,uint16>();
            case type_id_t::INT16:      return _get<T,int16>();
            case type_id_t::UINT32:     return _get<T,uint32>();
            case type_id_t::INT32:      return _get<T,int32>();
            case type_id_t::UINT64:     return _get<T,uint64>();
            case type_id_t::INT64:      return _get<T,int64>();
            case type_id_t::FLOAT32:    return _get<T,float32>();
            case type_id_t::FLOAT64:    return _get<T,float64>();
            case type_id_t::FLOAT128:   return _get<T,float128>();
            case type_id_t::COMPLEX32:  return _get<T,complex32>();
            case type_id_t::COMPLEX64:  return _get<T,complex64>();
            case type_id_t::COMPLEX128: return _get<T,complex128>();
            case type_id_t::BINARY:     return _get<T,binary>();
            case type_id_t::STRING:     return _get<T,string>();
            case type_id_t::BOOL:       return _get<T,bool_t>();
            default:
                throw type_error(EXCEPTION_RECORD,
                        "The reference points to an object of unkown type!");
        }
        
    }
           
    //-------------------------------------------------------------------------
    template<typename T> value_ref &value_ref::operator=(const T &v)
    {
        _check_pointer(EXCEPTION_RECORD);
        
        type_id_t tid = type_id();

        switch(tid)
        {
            case type_id_t::UINT8:      _set<uint8>(v);      break;
            case type_id_t::INT8:       _set<int8>(v);       break;
            case type_id_t::UINT16:     _set<uint16>(v);     break;
            case type_id_t::INT16:      _set<int16>(v);      break;
            case type_id_t::UINT32:     _set<uint32>(v);     break;
            case type_id_t::INT32:      _set<int32>(v);      break;
            case type_id_t::UINT64:     _set<uint64>(v);     break;
            case type_id_t::INT64:      _set<int64>(v);      break;
            case type_id_t::FLOAT32:    _set<float32>(v);    break;
            case type_id_t::FLOAT64:    _set<float64>(v);    break;
            case type_id_t::FLOAT128:   _set<float128>(v);   break;
            case type_id_t::COMPLEX32:  _set<complex32>(v);  break;
            case type_id_t::COMPLEX64:  _set<complex64>(v);  break;
            case type_id_t::COMPLEX128: _set<complex128>(v); break;
            case type_id_t::BINARY:     _set<binary>(v);     break;
            case type_id_t::STRING:     _set<string>(v);     break;
            case type_id_t::BOOL:       _set<bool_t>(v);     break;
            default:
                throw type_error(EXCEPTION_RECORD,
                        "The reference points to an object of unknown type!");
        }

        return *this;
    }

    //------------------------------------------------------------------------
    value to_value(const value_ref &v);

//end of namespace
}
}