scalar.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: Jun 9, 2011
//     Author: Eugen Wintersberger
//
//
#pragma once

#include <iostream>
#include <array>

#include "../types.hpp"
#include "scalar_iterator.hpp"

namespace pni {
namespace core {

    template<typename ATYPE> class array_view;

    template<typename T> 
    class scalar
    {
        private:
            std::array<T,1> _data; 
        public:
            //================public data types================================
            typedef T value_type;
            typedef scalar<T> array_type;
            typedef std::array<T,1> storage_type;
            typedef scalar_iterator<array_type> iterator;
            typedef scalar_iterator<const array_type> const_iterator;
            typedef array_view<array_type> view_type;
            
            //===============public members====================================
            static const type_id_t type_id = type_id_map<T>::type_id;

            //====================constructors and destructor==================
            scalar():_data() {}

            //-----------------------------------------------------------------
            scalar(const array_type &s):_data(s._data) {}
            
            //-----------------------------------------------------------------
            scalar(const value_type &r):_data(storage_type{{r}}) {}

            //-----------------------------------------------------------------

            //-----------------------------------------------------------------
            ~scalar() {}

            //=================assignment operators============================
            array_type &operator=(const value_type &v)
            {
                this->_data[0] = v;
                return *this;
            }

            //-----------------------------------------------------------------
            array_type &operator=(const array_type &v)
            {
                if(this == &v) return *this;
                this->_data = v._data;
                return *this;
            }

            //=======================conversion operator========================
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
            operator T() const { return this->_data[0]; }
#pragma GCC diagnostic pop

            //===================linear access operators========================
            T operator[](size_t) const { return this->_data[0]; }

            //-----------------------------------------------------------------
            T &operator[](size_t) { return this->_data[0]; }

            //-----------------------------------------------------------------
            T at(size_t) const { return this->_data[0]; }

            //-----------------------------------------------------------------
            T &at(size_t) { return this->_data[0]; }

            //-----------------------------------------------------------------
            void insert(size_t,const T &v) { this->_data[0] = v; }
            
            //-----------------------------------------------------------------
            const storage_type &storage() const { return this->_data; }

            //==================methods for multidim data access===============
            template<typename ...ITYPES> 
            T &operator()(ITYPES ...)
            {
                return this->_data[0];
            }

            //-----------------------------------------------------------------
            template<typename ...ITYPES> 
            T operator()(ITYPES ...) const
            {
                return this->_data[0];
            }

            //-----------------------------------------------------------------
            template<
                     template<typename ...> class CTYPE,
                     typename ...OTS
                    >
            T &operator()(const CTYPE<OTS...> &)
            {
                return this->_data[0];
            }

            //-----------------------------------------------------------------
            template<template<typename ...> class CTYPE,typename ...OTS>
            T operator()(const CTYPE<OTS...> &) const
            {
                return this->_data[0];
            }

            //===================inquery methods===============================
            size_t size() const { return 1; }

            //-----------------------------------------------------------------
            size_t rank() const { return 0; }

            //------------------------------------------------------------------
            template<typename CTYPE> 
            CTYPE shape() const { return CTYPE(); }

            //------------------------------------------------------------------
            iterator begin() { return iterator(this,0); }

            //------------------------------------------------------------------
            iterator end() { return iterator(this,0); }

            //------------------------------------------------------------------
            const_iterator begin() const { const_iterator(this,0); }

            //------------------------------------------------------------------
            const_iterator end() const { return const_iterator(this,0); }
    };

    //-------------------------------------------------------------------------
    template<typename T>
    bool operator==(const scalar<T> &a,const scalar<T> &b)
    {
        return T(a)==T(b);
    }

    //-------------------------------------------------------------------------
    template<typename T>
    bool operator!=(const scalar<T> &a,const scalar<T> &b)
    {
        return !(a==b);
    }

    //-------------------------------------------------------------------------
    template<typename T>
    std::ostream &operator<<(std::ostream &os,const scalar<T> &s)
    {
        T value = s[0]; 
        os<<value;
        return os;
    }

    //-------------------------------------------------------------------------
    template<typename T>
    std::istream &operator>>(std::istream &is,scalar<T> &s)
    {
        T value;
        is>>value;
        s = value;
        return is;
    }

//end of namespace
}
}