value.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 "../arrays.hpp"
#include "value_holder.hpp"
#include "utils.hpp"
#include "../types/traits.hpp"

namespace pni{
namespace core{


    //forward declaration
    class value_ref;

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

            template<typename T>
            using enable_primitive = std::enable_if<is_primitive_type<T>::value>;
            
            //----------------------------------------------------------------
            template<
                     typename T,
                     typename S 
                    > 
            T _get() const
            {
                return get_value<T,S>(get_holder_ptr<S>(_ptr));
            }

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

            pointer_type _ptr;
        public:
            //================constructors and destructor======================
            value();
          
            //-----------------------------------------------------------------
            template<
                     typename T,
                     typename = typename enable_primitive<T>::type 
                    > 
            explicit value(T v):_ptr(new value_holder<T>(v)){}

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

            //-----------------------------------------------------------------
            value(value &&o);

            //==================assignment operators===========================
            template<typename VT> value &operator=(const VT &v);

            //-----------------------------------------------------------------
            value &operator=(const value &o);

            //-----------------------------------------------------------------
            value &operator=(value &&o);

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

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

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

    //=====================implementation of template member functions=========
    template<typename T> T value::as() const
    {
        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::STRING:     return _get<T,string>();
            case type_id_t::BINARY:     return _get<T,binary>();
            case type_id_t::BOOL:       return _get<T,bool_t>();
            default:
                throw type_error(EXCEPTION_RECORD,"Uknown type!");
        }

    }

    //-------------------------------------------------------------------------
    template<typename VT> value &value::operator=(const VT &v)
    {
        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::BOOL:       _set<bool_t>(v);     break;
            case type_id_t::STRING:     _set<string>(v);     break;
            default:
                throw type_error(EXCEPTION_RECORD,
                        "Value is of unkonw type!");
        }

        return *this;
    }

    //-------------------------------------------------------------------------
    type_id_t type_id(const value &rv);

    //------------------------------------------------------------------------
    template<typename T> value make_value()
    {
        return value(T{});
    }

    //------------------------------------------------------------------------
    value make_value(type_id_t tid);

//end of namespace
}
}