datapack_interface.h

Go to the documentation of this file.

/* * NRP Core - Backend infrastructure to synchronize simulations
 *
 * Copyright 2020-2023 NRP Team
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * This project has received funding from the European Union’s Horizon 2020
 * Framework Programme for Research and Innovation under the Specific Grant
 * Agreement No. 945539 (Human Brain Project SGA3).
 */
 
#ifndef DATAPACK_INTERFACE_H
#define DATAPACK_INTERFACE_H
 
#include "nrp_general_library/utils/ptr_templates.h"
 
#include <string>
#include <string_view>
#include <memory>
#include <type_traits>
#include <vector>
#include <set>
 
 
struct DataPackIdentifier
{
    public:
    std::string Name;
 
    std::string EngineName;
 
    std::string Type;
 
    DataPackIdentifier() = default;
 
    DataPackIdentifier (const DataPackIdentifier&) = default;
    DataPackIdentifier& operator= (const DataPackIdentifier&) = default;
 
    DataPackIdentifier(DataPackIdentifier&& obj) = default;
    DataPackIdentifier& operator = (DataPackIdentifier&&) = default;
 
    DataPackIdentifier(const std::string &_name, const std::string &_engineName, const std::string &_type);
 
    DataPackIdentifier(std::string &&_name, std::string &&_engineName, std::string &&_type)
        : Name(std::forward<std::string>(_name)),
          EngineName(std::forward<std::string>(_engineName)),
          Type(std::forward<std::string>(_type))
    {}
 
    bool operator == (const DataPackIdentifier & rhs) const {
        return (Name == rhs.Name)
     && (EngineName == rhs.EngineName)
     && (Type == rhs.Type);
    }
 
    bool operator < (const DataPackIdentifier & rhs) const{
        return (Name < rhs.Name) || (Name == rhs.Name && EngineName < rhs.EngineName) || (Name == rhs.Name &&
        EngineName == rhs.EngineName && Type < rhs.Type);
    }
 
};
 
 
class DataPackInterface
        : public PtrTemplates<DataPackInterface>
{
    public:
        DataPackInterface() = default;
 
        DataPackInterface (const DataPackInterface&) = default;
        DataPackInterface& operator= (const DataPackInterface&) = default;
 
        DataPackInterface(DataPackInterface&& obj) = default;
        DataPackInterface& operator = (DataPackInterface&&) = default;
 
        template<class DEV_ID_T>
        DataPackInterface(DEV_ID_T &&id)
            : _id(std::forward<DEV_ID_T>(id)){
                static_assert(std::is_same_v<std::remove_reference_t<DEV_ID_T>, const DataPackIdentifier> || std::is_same_v< DataPackIdentifier, std::remove_reference_t<DEV_ID_T> >,"Parameter DEV_ID_T must be type DataPackIdentifier or DataPackIdentifier&");
                static_assert(std::is_same_v<std::remove_reference_t<DEV_ID_T>, DataPackIdentifier> || std::is_same_v< const DataPackIdentifier, std::remove_reference_t<DEV_ID_T> >,"Parameter DEV_ID_T must be type DataPackIdentifier or DataPackIdentifier&");
            }
 
        DataPackInterface(const std::string &name, const std::string &engineName, const std::string &type);
        virtual ~DataPackInterface() = default;
 
        const std::string &name() const;
        void setName(const std::string &name);
 
        const std::string &type() const;
        void setType(const std::string &type);
 
        const std::string &engineName() const;
        void setEngineName(const std::string &engineName);
 
        const DataPackIdentifier &id() const;
        void setID(const DataPackIdentifier &id);
 
        virtual DataPackInterface* clone() const
        { return new DataPackInterface(this->name(), this->engineName(), this->type(), this->isUpdated()); }
 
        bool isEmpty() const;
 
        bool isUpdated() const;
 
        void resetIsUpdated() const;
 
    protected:
 
        void setIsEmpty(bool value);
        DataPackInterface(const std::string &name, const std::string &engineName, const std::string &type, bool isUpdated)
        : DataPackInterface(name, engineName, type)
        {
            this->_isUpdated = isUpdated;
        }
 
    private:
        DataPackIdentifier _id;
 
        bool _isEmpty = true;
 
        mutable bool _isUpdated = true;
};
 
using DataPackInterfaceSharedPtr      = DataPackInterface::shared_ptr;
using DataPackInterfaceConstSharedPtr = DataPackInterface::const_shared_ptr;
 
 
struct DataPackPointerComparator
{
    // Let the container know that we may be comparing with other types than shared_ptr (e.g. DataPackIdentifier)
    // Needed when operator() is overloaded
    using is_transparent = std::true_type;
 
    bool operator() (const std::shared_ptr<const DataPackInterface> & lhs, const std::shared_ptr<const DataPackInterface> & rhs) const
    {
        return  lhs->id().Name       <  rhs->id().Name ||
               (lhs->id().Name       == rhs->id().Name &&
                lhs->id().EngineName <  rhs->id().EngineName);
    }
 
    bool operator() (const std::shared_ptr<const DataPackInterface> & lhs, const DataPackIdentifier & rhs) const
    {
        return  lhs->id().Name       <  rhs.Name ||
               (lhs->id().Name       == rhs.Name &&
                lhs->id().EngineName <  rhs.EngineName);
    }
 
    bool operator() (const DataPackIdentifier & lhs, const std::shared_ptr<const DataPackInterface> & rhs) const
    {
        return  lhs.Name       <  rhs->id().Name ||
               (lhs.Name       == rhs->id().Name &&
                lhs.EngineName <  rhs->id().EngineName);
    }
};
 
using datapacks_set_t            = std::set<std::shared_ptr<const DataPackInterface>, DataPackPointerComparator>;
using datapacks_vector_t         = std::vector<std::shared_ptr<const DataPackInterface>>;
using datapack_identifiers_set_t = std::set<DataPackIdentifier>;
 
 
#endif // DATAPACK_INTERFACE_H