InOut.tpp

/*---------------------------------------------------------------------------*\
 *
 *  mimmo
 *
 *  Copyright (C) 2015-2021 OPTIMAD engineering Srl
 *
 *  -------------------------------------------------------------------------
 *  License
 *  This file is part of mimmo.
 *
 *  mimmo is free software: you can redistribute it and/or modify it
 *  under the terms of the GNU Lesser General Public License v3 (LGPL)
 *  as published by the Free Software Foundation.
 *
 *  mimmo 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 Lesser General Public
 *  License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with mimmo. If not, see <http://www.gnu.org/licenses/>.
 *
 \ *---------------------------------------------------------------------------*/
 
//==============================================================//
// TEMPLATE DERIVED INOUT CLASS TEMPLATE METHODS                //
//==============================================================//
 
namespace mimmo {
 
template<typename T, typename O>
PortOutT<T,O>::PortOutT(){
    m_var_ = nullptr;
};
 
template<typename T, typename O>
PortOutT<T,O>::PortOutT(T *var_){
    m_obj_      = nullptr;
    m_var_      = var_;
    m_getVar_   = nullptr;
};
 
template<typename T, typename O>
PortOutT<T,O>::PortOutT(T *var_, DataType datatype){
    m_obj_      = nullptr;
    m_var_      = var_;
    m_getVar_   = nullptr;
    m_datatype  = datatype;
};
 
template<typename T, typename O>
PortOutT<T,O>::PortOutT(O* obj_, T (O::*getVar_)()){
    m_obj_      = obj_;
    m_getVar_   = getVar_;
    m_var_      = nullptr;
};
 
template<typename T, typename O>
PortOutT<T,O>::PortOutT(O* obj_, T (O::*getVar_)(), DataType datatype){
    m_obj_      = obj_;
    m_getVar_   = getVar_;
    m_var_      = nullptr;
    m_datatype  = datatype;
};
 
 
template<typename T, typename O>
PortOutT<T,O>::~PortOutT(){
    m_obj_      = nullptr;
    m_var_      = nullptr;
    m_getVar_   = nullptr;
};
 
template<typename T, typename O>
PortOutT<T,O>::PortOutT(const PortOutT<T,O> & other):PortOut(other){
    m_obj_      = other.m_obj_;
    m_var_      = other.m_var_;
    m_getVar_   = other.m_getVar_;
};
 
template<typename T, typename O>
bool  PortOutT<T,O>::operator==(const PortOutT<T,O> & other){
    bool equal = true;
    equal &= (m_obj_ == other.m_obj_);
    equal &= (m_var_ == other.m_var_);
    equal &= (m_getVar_ == other.m_getVar_);
    return (equal);
};
 
template<typename T, typename O>
void
PortOutT<T,O>::writeBuffer(){
    if (m_getVar_ != nullptr){
        T temp = ((m_obj_->*m_getVar_)());
        m_obuffer << temp;
        return;
    }
    if (m_var_ != nullptr){
        m_obuffer << (*m_var_);
    }
}
 
 
 
template<typename T, typename O>
PortInT<T, O>::PortInT(){
    m_obj_      = nullptr;
    m_var_      = nullptr;
    m_setVar_   = nullptr;
};
 
template<typename T, typename O>
PortInT<T, O>::PortInT(T *var_){
    m_obj_      = nullptr;
    m_var_      = var_;
    m_setVar_   = nullptr;
    m_mandatory = false;
};
 
template<typename T, typename O>
PortInT<T, O>::PortInT(T *var_, DataType datatype, bool mandatory, int family){
    m_obj_      = nullptr;
    m_var_      = var_;
    m_setVar_   = nullptr;
    m_datatype  = datatype;
    m_mandatory = mandatory;
    m_familym   = family;
};
 
template<typename T, typename O>
PortInT<T,O>::PortInT(O* obj_, void (O::*setVar_)(T), bool mandatory, int family){
    m_obj_      = obj_;
    m_setVar_   = setVar_;
    m_var_      = nullptr;
    m_mandatory = mandatory;
    m_familym   = family;
};
 
template<typename T, typename O>
PortInT<T,O>::PortInT(O* obj_, void (O::*setVar_)(T), DataType datatype, bool mandatory, int family){
    m_obj_      = obj_;
    m_setVar_   = setVar_;
    m_var_      = nullptr;
    m_datatype  = datatype;
    m_mandatory = mandatory;
    m_familym   = family;
};
 
template<typename T, typename O>
PortInT<T, O>::~PortInT(){
    m_obj_      = nullptr;
    m_var_      = nullptr;
    m_setVar_   = nullptr;
};
 
template<typename T, typename O>
PortInT<T, O>::PortInT(const PortInT<T, O> & other):PortIn(other){
    m_obj_      = other.m_obj_;
    m_var_      = other.m_var_;
    m_setVar_   = other.m_setVar_;
};
 
template<typename T, typename O>
bool  PortInT<T, O>::operator==(const PortInT<T, O> & other){
    bool equal = true;
    equal &= (m_obj_ == other.m_obj_);
    equal &= (m_var_ == other.m_var_);
    equal &= (m_setVar_ == other.m_setVar_);
    return (equal);
};
 
template<typename T, typename O>
void
PortInT<T, O>::readBuffer(){
    T temp;
    m_ibuffer >> temp;
    if (m_setVar_ != nullptr){
        (m_obj_->*m_setVar_)(temp);
        return;
    }
    if (m_var_ != nullptr){
        (*m_var_) = temp;
    }
}
 
 
} //end of mimmo namespace