portManager.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 PORT_MANAGER_HPP
#define PORT_MANAGER_HPP
 
#include "portDefinitions.hpp"
#include <unordered_map>
#include <cassert>
 
 
namespace mimmo{
 
 
struct InfoPort{
 
    long id;                 
    std::string container;   
    std::string datatype;    
    std::string file;        
    InfoPort(){
        id=0;
        container="";
        datatype="";
        file = "";
    };
    virtual ~InfoPort(){};
};
 
class PortManager {
 
private:
    PortManager(){};
    PortManager(const PortManager&);
    PortManager& operator=(const PortManager&);
    ~PortManager() {};
 
public:
    static PortManager& instance(){
        static PortManager manager;
        return manager;
    }
 
    long addPort(const std::string name, const std::string container_name, const std::string datatype_name, const std::string fileregistration)
    {
 
        if(containsPort(name) > 0)  {
 
            std::string orcont =ports[name].container;
            std::string ordata =ports[name].datatype;
            if( orcont != container_name || ordata != datatype_name){
                std::cerr<<"PORT REGISTRATION ERROR: ================"<<std::endl;
                std::cerr<<"Failed Registration of Port "<<name<<" - "<<container_name<<" - "<<datatype_name<<" in file :"<<fileregistration<<std::endl;
                std::cerr<<"It already exists as: "<<name<<" - "<<orcont<<" - "<<ordata<<" in file :"<<fileregistration<<std::endl;
                std::cerr<<"========================================="<<std::endl;
                assert(false && "Port is already registered with different container or datatype or both");
            }
            return ports[name].id;
        }
        InfoPort temp;
        temp.container = container_name;
        temp.datatype = datatype_name;
        temp.file = fileregistration;
        long idC=long(containers.size()), idD=long(datatypes.size());
 
 
        temp.id = long(ports.size());
        ports[name]= temp;
 
        if(!containsContainer(container_name)){
            containers[container_name]= idC;
        }
 
        if(!containsDatatype(datatype_name)){
            datatypes[datatype_name]= idD;
        }
 
        return (long) temp.id;
    }
 
    bool containsPort(const std::string name){
        return ports.count(name) > 0;
    }
 
    bool containsContainer(const std::string name){
        return containers.count(name) > 0;
    }
 
    bool containsDatatype(const std::string name){
        return datatypes.count(name) > 0;
    }
 
    std::unordered_map<std::string, InfoPort> mapRegisteredPorts(){
        return ports;
    }
 
    std::unordered_map<std::string, long> mapRegisteredContainers(){
        return containers;
    }
 
    std::unordered_map<std::string, long> mapRegisteredDataTypes(){
        return datatypes;
    }
 
     InfoPort getPortData(const std::string name){
        assert(containsPort(name));
        return ports[name];
    }
 
 
private:
    std::unordered_map<std::string, InfoPort> ports;  
    std::unordered_map<std::string, long> containers; 
    std::unordered_map<std::string, long> datatypes;  
};
 
};
 
 
 
#define REGISTER_PORT(Name, Container, Datatype, ManipBlock) \
/* Register a Port in the mimmo::portManager*/ \
__attribute__((unused)) static long port_##Name##_##Container##_##Datatype##_##ManipBlock = mimmo::PortManager::instance().addPort(Name, Container, Datatype, __FILE__);\
 
/*static long port_##Name##_##Container##_##Datatype##_##ManipBlock = mimmo::PortManager::instance().addPort(Name, Container, Datatype, __FILE__);\ */
 
 
inline bool isPORT_REGISTERED(const std::string name){
    return mimmo::PortManager::instance().containsPort(name);
}
 
 
#endif