exception_utils.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 lipniutils.  If not, see <http://www.gnu.org/licenses/>.
//
// ============================================================================
//
// Created on: May 23, 2012
//     Author: Eugen Wintersberger
//
//
#pragma once

#include <vector>
#include <iostream>
#include <algorithm>
#include <boost/units/detail/utility.hpp>

#include "../error/exceptions.hpp"
#include "../utilities/service.hpp"

namespace pni{
namespace core{

    template<typename VTYPE>
    void print_vector(std::ostream &o,const VTYPE &v)
    {
        o<<"( ";
        for(auto x: v) o<<x<<" ";
        o<<")";
    }

    //=====================Exception related helper functions==================
    template<
             typename A,
             typename B
            >
    bool check_equal_size(const A &a,const B &b) 
    {
        return a.size() == b.size();
    }

    //-------------------------------------------------------------------------
    template<
             typename A,
             typename B
            > 
    void check_equal_size(const A &a,const B &b,const exception_record &i)
    {
        if(!check_equal_size(a,b))
        {
            std::stringstream ss;
            ss<<"Size of "<<boost::units::detail::demangle(typeid(A).name())<<" (";
            ss<<a.size()<<") ";
            ss<<"does not match size of "<<boost::units::detail::demangle(typeid(B).name())<<" (";
            ss<<b.size()<<")!";
            throw size_mismatch_error(i,string(ss.str()));
        }
    }

    //-------------------------------------------------------------------------
    bool check_index_in_dim(size_t index,size_t dimsize);

    //-------------------------------------------------------------------------
    void check_index_in_dim(size_t index,size_t dimsize,
                            const exception_record &i);

    //-------------------------------------------------------------------------
    template<
             typename ITYPE,
             typename STYPE
            >
    bool check_indexes(const ITYPE &index,const STYPE &shape)
    {
        if(!check_equal_size(index,shape)) return false;

        auto iiter = index.begin();
        auto siter = shape.begin();

        for(;iiter!=index.end();++iiter,++siter)
            if(*iiter>=*siter) return false;

        return true;
    }

    //-------------------------------------------------------------------------
    template<
             typename ITYPE,
             typename STYPE
            >
    void check_indexes(const ITYPE &index,const STYPE &shape,
                       const exception_record &record)
    {
        //check size - if it does not match throw an exception
        if(!check_equal_size(index,shape))
        {
            std::stringstream ss;
            ss<<"Rank of index vector ("<<index.size()<<") does not match ";
            ss<<"the rank of the shape vector ("<<shape.size()<<")!";
            throw shape_mismatch_error(record,ss.str());
        }
       
        //if sizes of the vectors match check the individual ranges. 
        if(!check_indexes(index,shape))
        {
            std::stringstream ss;
            ss<<"Indexes ";
            print_vector(ss,index);
            ss<<" do not match shape ";
            print_vector(ss,shape);
            ss<<std::endl;

            throw index_error(record,ss.str());
        }

    }

    //-------------------------------------------------------------------------
    template<
             typename A,
             typename B
            >
    bool check_equal_rank(const A &a,const B &b)
    {
        return a.rank() == b.rank();
    }

    //-------------------------------------------------------------------------
    template<
             typename A,
             typename B
            >
    void check_equal_rank(const A &a,const B &b,const exception_record &i)
    {
        if(!check_equal_rank(a,b))
        {
            std::stringstream ss;
            ss<<"Rank of "<<boost::units::detail::demangle(typeid(a).name())<<" (";
            ss<<a.rank()<<") does not match that of ";
            ss<<boost::units::detail::demangle(typeid(b).name())<<" (";
            ss<<b.rank()<<")!";
            throw shape_mismatch_error(i,ss.str());
        }
    }

    //-------------------------------------------------------------------------
    template<
             typename A,
             typename B
            >
    bool check_equal_shape(const A &a,const B &b)
    {
        //check if the sizes match
        if(!check_equal_size(a,b)) return false;
        if(!check_equal_rank(a,b)) return false;

        auto sa = a.template shape<std::vector<size_t> >();
        auto sb = b.template shape<std::vector<size_t> >();
        
        if(!std::equal(sa.begin(),sa.end(),sb.begin()))
            return false;

        return true;
    }


    //-------------------------------------------------------------------------
    template<typename A,typename B>
    void check_equal_shape(const A &a,const B &b,const exception_record &i)
    {
        check_equal_size(a,b,i);
        check_equal_rank(a,b,i);

        if(!check_equal_shape(a,b))
        {
            std::stringstream ss;
            ss<<"Shape of "<<boost::units::detail::demangle(typeid(a).name())<<" (";
            ss<<a.size()<<") does not match that of ";
            ss<<boost::units::detail::demangle(typeid(b).name())<<" (";
            ss<<b.size()<<")!";
            throw shape_mismatch_error(i,ss.str());
        }

    }

    //-------------------------------------------------------------------------
    template<typename OTYPE> 
    void check_allocation_state(const OTYPE &o,const exception_record &i)
    {
        if(!o.size())
        {
            std::stringstream ss;
            ss<<"Instance of "<<boost::units::detail::demangle(typeid(OTYPE).name());
            ss<<" not allocated!";
            throw memory_not_allocated_error(i,ss.str());
        }
    }

    //-------------------------------------------------------------------------
    template<typename T> 
    void check_ptr_state(const T *ptr,const exception_record &i)
    {
        if(!ptr)
        {
            std::stringstream ss;
            ss<<"Pointer is nullptr!";
            throw memory_not_allocated_error(i,ss.str());
        }
    }



//end of namespace
}
}