InOut.cpp

/*---------------------------------------------------------------------------*\
*
*  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/>.
*
\*---------------------------------------------------------------------------*/
#include "InOut.hpp"
#include "BaseManipulation.hpp"
 
//==============================================================//
// DATA TYPE  CLASS IMPLEMENTATION                              //
// //==============================================================//
namespace mimmo{
 
DataType::DataType(){
    m_conType = "MC_SCALAR";
    m_dataType = "MD_INT";
};
 
DataType::DataType(containerTAG conType, dataTAG dataType){
    m_conType   = conType;
    m_dataType  = dataType;
    return;
};
 
DataType::~DataType(){};
 
 
bool DataType::operator==(const DataType & other){
    bool check = true;
    check = check && (m_conType == other.m_conType);
    check = check && (m_dataType == other.m_dataType);
    return(check);
};
 
 
//==============================================================//
// BASE INOUT CLASS IMPLEMENTATION                              //
//==============================================================//
 
PortOut::PortOut(){
    m_objLink.clear();
};
 
PortOut::~PortOut(){};
 
PortOut::PortOut(const PortOut & other){
    m_objLink   = other.m_objLink;
    m_obuffer   = other.m_obuffer;
    m_portLink  = other.m_portLink;
    m_datatype  = other.m_datatype;
    return;
};
 
bool PortOut::operator==(const PortOut & other){
    bool check = true;
    check = check && (m_portLink == other.m_portLink);
    check = check && (m_objLink == other.m_objLink);
    check = check && (m_datatype == other.m_datatype);
    return(check);
};
 
std::vector<mimmo::BaseManipulation*>
PortOut::getLink(){
    return(m_objLink);
}
 
std::vector<PortID>
PortOut::getPortLink(){
    return(m_portLink);
}
 
DataType
PortOut::getDataType(){
    return(m_datatype);
}
 
void
mimmo::PortOut::cleanBuffer(){
    m_obuffer.seekg(0);
}
 
void
mimmo::PortOut::clear(){
    m_objLink.clear();
    m_portLink.clear();
}
 
void
mimmo::PortOut::clear(int j){
    if (j < (int)m_objLink.size() && j >= 0){
        m_objLink.erase(m_objLink.begin() + j);
        m_portLink.erase(m_portLink.begin() + j);
    }
}
 
void
mimmo::PortOut::exec(){
    if (m_objLink.size() > 0){
        writeBuffer();
        mimmo::IBinaryStream input(m_obuffer.data(), m_obuffer.getSize());
        cleanBuffer();
        for (int j=0; j<(int)m_objLink.size(); j++){
            if (m_objLink[j] != nullptr){
                m_objLink[j]->setBufferIn(m_portLink[j], input);
                m_objLink[j]->readBufferIn(m_portLink[j]);
                m_objLink[j]->cleanBufferIn(m_portLink[j]);
            }
        }
    }
};
 
PortIn::PortIn(){
    m_mandatory =false;
    m_familym = 0;
};
 
PortIn::~PortIn(){};
 
PortIn::PortIn(const PortIn & other){
    m_objLink   = other.m_objLink;
    m_ibuffer   = other.m_ibuffer;
    m_datatype  = other.m_datatype;
    m_mandatory = other.m_mandatory;
    m_familym   = other.m_familym;
    return;
};
 
bool PortIn::operator==(const PortIn & other){
    bool check = true;
    check = check && (m_objLink == other.m_objLink);
    check = check && (m_datatype == other.m_datatype);
    check = check && (m_mandatory = other.m_mandatory);
    check = check && (m_familym   = other.m_familym);
    return(check);
};
 
std::vector<mimmo::BaseManipulation*>
PortIn::getLink(){
    return(m_objLink);
}
 
DataType
PortIn::getDataType(){
    return(m_datatype);
}
 
bool
PortIn::isMandatory(){
    return(m_mandatory);
}
 
int
PortIn::getFamily(){
    return(m_familym);
}
 
void
mimmo::PortIn::clear(){
    m_objLink.clear();
}
 
void
mimmo::PortIn::clear(int j){
    if (j < (int)m_objLink.size() && j >= 0){
        m_objLink.erase(m_objLink.begin() + j);
    }
}
 
 
void
mimmo::PortIn::cleanBuffer(){
    m_ibuffer.seekg(0);
}
 
}