binary.hpp

//
// (c) Copyright 2011 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: Feb 8, 2012
//     Author: Eugen Wintersberger <eugen.wintersberger@desy.de>
//

#pragma once
#include <iostream>


namespace pni{
namespace core{

    template<typename NTYPE> class binary_t
    {
        public:
            //=================public data types===============================
            typedef NTYPE storage_type;
        private:
            storage_type _value; 

            const binary_t<storage_type> & 
                operator+=(const binary_t<storage_type> &b) = delete;
            const binary_t<storage_type> & 
                operator-=(const binary_t<storage_type> &b) = delete;
            const binary_t<storage_type> & 
                operator*=(const binary_t<storage_type> &b) = delete;
            const binary_t<storage_type> & 
                operator/=(const binary_t<storage_type> &b) = delete;
        public:

            //=============constructors and destructor=========================
            explicit binary_t():_value(storage_type(0)) {}

            //-----------------------------------------------------------------
            binary_t(const storage_type &value):_value(value) {}

            //-----------------------------------------------------------------
            binary_t(const binary_t<storage_type> &o):
                _value(o._value)
            {}

            //-----------------------------------------------------------------
            operator NTYPE() const
            {
                return _value;
            }

    };


    template<typename NTYPE> binary_t<NTYPE> 
        operator+(const binary_t<NTYPE> &a,const binary_t<NTYPE> &b)
        = delete;

    template<typename NTYPE> binary_t<NTYPE>
        operator-(const binary_t<NTYPE> &a,const binary_t<NTYPE> &b)
        =delete;

    template<typename NTYPE> binary_t<NTYPE>
        operator*(const binary_t<NTYPE> &a,const binary_t<NTYPE> &b)
        =delete;

    template<typename NTYPE> binary_t<NTYPE>
        operator/(const binary_t<NTYPE> &a,const binary_t<NTYPE> &b)
        =delete;

    
    //-------------------------------------------------------------------------
    template<typename NTYPE>
    std::ostream &operator<<(std::ostream &os,const binary_t<NTYPE> &o)
    {
        NTYPE b = o;
        os<<b;
        return os;
    }

    //-------------------------------------------------------------------------
    template<typename NTYPE>
    std::istream &operator>>(std::istream &is,binary_t<NTYPE> &o)
    {
        NTYPE b;
        is>>b;
        o = b;
        return is;
    }

//end of namespace
}
}