LogicLibraryInfo.hpp

Go to the documentation of this file.

#ifndef LIBS_LOGIC_SLOGICLIBRARYINFO_HPP
#define LIBS_LOGIC_SLOGICLIBRARYINFO_HPP
 
#include "logic/CLogicsAllowed.hpp"
#include "logic/structs.hpp"
 
#include <optional>
#include <vector>
 
class LogicLibraryInfo;
 
enum class ELibraryLogicBlockParamConnectedType
{
    Empty = 0,
    Constant,
    Label,
    BroadCastChannel,
    Channel,
    LibraryIO,
    ExecBlock,
    Without
};
 
struct SLibraryLogicBlockParam
{
    // Param info
 
    iv::logic::ParamId m_paramId {iv::logic::eDBBlockParamType::Without,
                                  0};       // From 0 to number of params [ignoring type] [in this block]
    uint32_t m_globalIdOrValueParameter {0};// uint32Value [valid for consts MI, byte, word & floats]
    std::string m_sParamValue;              // SValue [formatted for some types]
    std::string m_paramValue;               // Parameter value in string
    std::string m_paramDescription;         // Description from inside the library
 
    // Connected info
 
    // Connected block type
    ELibraryLogicBlockParamConnectedType m_connectedBlockType {ELibraryLogicBlockParamConnectedType::Empty};
    // Exec block order to which the param is connected
    iv::types::logic::logicExecutionOrder m_connectedExecOrder {
            0};// [0 if not connected to an exec block (Const/LibIO)]
    // Exec block's param ID to which the param is connected
    iv::logic::ParamId m_connectedParamId {iv::logic::eDBBlockParamType::Without,
                                           0};// [Without if not connected to an exec block]
 
    // External params
 
    // Connected block from outside the library [Only for params connected to LibraryIO blocks]
    ELibraryLogicBlockParamConnectedType m_externalConnectedBlockType {
            ELibraryLogicBlockParamConnectedType::Empty};// [Without if not LibIO]
    std::string m_externalParamDescription;              // Description for outside the library
    std::string m_paramOnlineTag;                        // Tag of parameter online
};
 
struct SLibraryLogicBlock
{
    SLibraryLogicBlock() = default;
 
    SLibraryLogicBlock(SLibraryLogicBlock &&other) = default;
    SLibraryLogicBlock(const SLibraryLogicBlock &other);
    ~SLibraryLogicBlock() = default;
 
    SLibraryLogicBlock &operator=(const SLibraryLogicBlock &other);
 
    iv::types::logic::logicExecutionOrder m_executionOrder {0};         // Order of execution of block [works as ID]
    std::string m_blockName;                                            // Block name
    uint8_t m_blockType {0};                                            // Block type
    uint8_t m_blockSubType {0};                                         // Block subtype
    std::map<iv::logic::ParamId, SLibraryLogicBlockParam> m_blockParams;// Parameters of block
 
    bool m_isLibrary {false};                       // If block represents a library
    std::unique_ptr<LogicLibraryInfo> m_libraryInfo;// Library the block represents
};
 
struct SLibraryExternalParameter
{
    iv::logic::ParamId m_externalParamId {iv::logic::eDBBlockParamType::Without, 0};
    std::string m_externalParamDescription;// Parameter description [matches m_externalParamDescription]
 
    struct InternalParameterIdentifier
    {
        iv::logic::ParamId m_internalParamId {iv::logic::eDBBlockParamType::Without, 0};
        iv::types::logic::logicExecutionOrder m_internalBlockExecutionOrder {
                0};                            // Index in parameter description [considering type]
        std::string m_internalParamDescription;// Parameter description [matches m_paramDescription]
        std::string m_internalValue {0};       // Default value
 
        bool operator==(const InternalParameterIdentifier &) const = default;
    };
 
    std::vector<InternalParameterIdentifier> m_internalParameters;
};
 
class LogicLibraryInfo
{
public:
    static ELibraryLogicBlockParamConnectedType enumLibraryLogicBlockParamConnectedType(const std::string &strType);
    static std::string strLibraryLogicBlockParamConnectedType(ELibraryLogicBlockParamConnectedType enumType);
 
    LogicLibraryInfo();
    LogicLibraryInfo(LogicLibraryInfo &&other) = default;
    LogicLibraryInfo(LogicLibraryInfo const &other);
    ~LogicLibraryInfo() = default;
    LogicLibraryInfo &operator=(const LogicLibraryInfo &other);
 
    void processLibraryIntermediateMemory(iv::types::logic::logicIntermediateMemory &currentMemory);
    void setLibIOIntermediateMemoryExternalConnection(iv::logic::ParamId externalParamId,
                                                      iv::types::logic::logicIntermediateMemory memory);
    void setParameterUint32Value(iv::logic::ParamId externalParamId, uint32_t uint32Value);
 
    void updateExternalParameter(const std::string &value, ELibraryLogicBlockParamConnectedType externalConnectionType,
                                 iv::logic::ParamId externalParamId);
 
    void updateOnlineParameter(const std::string &value, iv::logic::ParamId externalParamId);
 
    void setLibFile(const std::string &libFile);
    void setLibLogicBlocks(std::map<iv::types::logic::logicExecutionOrder, SLibraryLogicBlock> libFileLogicBlocks);
    void setLibExternalParameters(std::map<iv::logic::ParamId, SLibraryExternalParameter> libExternalParams);
 
    [[nodiscard]] std::string getLibFileName() const;
    [[nodiscard]] std::string getLibFilePath() const;
    [[nodiscard]] const std::map<iv::types::logic::logicExecutionOrder, SLibraryLogicBlock> &getLibLogicBlocks() const;
    [[nodiscard]] const std::map<iv::logic::ParamId, SLibraryExternalParameter> &getLibExternalParameters() const;
 
    iv::file::xml::node read(const iv::file::xml::node &node);
    iv::file::xml::node save(iv::file::xml::node &node) const;
 
    [[nodiscard]] bool matchesStructureOf(const LogicLibraryInfo &logicLibraryInfo) const;
    [[nodiscard]] std::optional<iv::types::errorMessage> checkMatchesStructureOfLibraryFile() const;
 
private:
    // File de la librería
    std::string m_libFileName;
 
    // Bloques de la librería
    std::map<iv::types::logic::logicExecutionOrder, SLibraryLogicBlock> m_libraryLogicBlocks;
 
    std::map<iv::logic::ParamId, SLibraryExternalParameter> m_libraryExternalParameters;
};
 
#endif//LIBS_LOGIC_SLOGICLIBRARYINFO_HPP