InOut.hpp

/*---------------------------------------------------------------------------*\
*
*  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/>.
*
\*---------------------------------------------------------------------------*/
#ifndef __INOUT_HPP__
#define __INOUT_HPP__
 
#include <mimmo_binary_stream.hpp>
#include <functional>
 
namespace mimmo{
 
class BaseManipulation;
 
typedef std::string                 PortID; 
typedef std::string                 containerTAG; 
typedef std::string                 dataTAG; 
class DataType{
public:
    containerTAG    m_conType; 
    dataTAG         m_dataType;
public:
    DataType();
    DataType(containerTAG conType, dataTAG dataType);
    virtual ~DataType();
 
    DataType(const DataType&) = default;
    DataType& operator=(const DataType&) = default;
 
    bool operator==(const DataType & other);
 
};
 
class PortOut{
public:
    //members
    mimmo::OBinaryStream            m_obuffer;  
    std::vector<BaseManipulation*>  m_objLink;  
    std::vector<PortID>             m_portLink; 
    DataType                        m_datatype; 
public:
    PortOut();
    virtual ~PortOut();
 
    PortOut(const PortOut & other);
    bool operator==(const PortOut & other);
 
    std::vector<BaseManipulation*>  getLink();
    std::vector<PortID>             getPortLink();
    DataType                        getDataType();
 
    virtual void    writeBuffer() = 0;
    void            cleanBuffer();
 
    void clear();
    void clear(int j);
 
    void exec();
 
};
 
 
//==============================================================//
// TEMPLATE DERIVED INOUT CLASS                                 //
//==============================================================//
 
template<typename T, typename O>
class PortOutT: public PortOut {
 
public:
 
    O*  m_obj_;             
    T   *m_var_;            
    T   (O::*m_getVar_)();  
public:
    PortOutT();
    PortOutT(T *var_);
    PortOutT(T *var_, DataType datatype);
    PortOutT(O* obj_, T (O::*getVar_)());
    PortOutT(O* obj_, T (O::*getVar_)(), DataType datatype);
    virtual ~PortOutT();
 
    PortOutT(const PortOutT & other);
    bool operator==(const PortOutT & other);
 
    void writeBuffer();
 
};
 
 
 
class PortIn{
public:
    //members
    mimmo::IBinaryStream                m_ibuffer;          
    std::vector<BaseManipulation*>      m_objLink;          
    DataType                            m_datatype;         
    bool                                m_mandatory;        
    int                                 m_familym;          
public:
    PortIn();
    virtual ~PortIn();
 
    PortIn(const PortIn & other);
    bool operator==(const PortIn & other);
 
    std::vector<mimmo::BaseManipulation*>   getLink();
    DataType                                getDataType();
    bool                                    isMandatory();
    int                                     getFamily();
 
    void clear();
    void clear(int j);
 
    virtual void    readBuffer() = 0;
    void            cleanBuffer();
 
};
 
 
//==============================================================//
// TEMPLATE DERIVED INOUT CLASS                                 //
//==============================================================//
 
template<typename T, typename O>
class PortInT: public PortIn {
 
public:
 
    O*      m_obj_;             
    T       *m_var_;            
    void    (O::*m_setVar_)(T); 
public:
    PortInT();
    PortInT(T *var_);
    PortInT(T *var_, DataType datatype, bool mandatory = false, int family = 0);
    PortInT(O* obj_, void (O::*setVar_)(T), bool mandatory = false, int family = 0);
    PortInT(O* obj_, void (O::*setVar_)(T), DataType datatype, bool mandatory = false, int family = 0);
    virtual ~PortInT();
 
    PortInT(const PortInT & other);
    bool operator==(const PortInT & other);
 
    void readBuffer();
 
};
 
}
 
#include "InOut.tpp"
 
#endif /* __INOUT_HPP__ */