CLogicsAllowed.hpp

Go to the documentation of this file.

#ifndef LIBS_LOGIC_CLOGICSALLOWED_HPP_
#define LIBS_LOGIC_CLOGICSALLOWED_HPP_
 
#include "logic/defines.hpp"
#include "logic/structs.hpp"
 
#include <bits/stdint-uintn.h>
#include <map>
#include <set>
#include <string>
 
class CLogicsAllowed
{
public:
    struct SBlockData;
    typedef std::map<iv::logic::ParamId, std::string> TMapDBBlockParamNStr;
    typedef std::map<iv::logic::eDBBlockParamType, uint8_t>
            TMapDBBlockParamSize;// map of <block param type, param size in bytes>
    typedef std::map<uint32_t, std::string> TMapBlockTypeDescription;
    typedef std::map<iv::logic::LogicBlockId, SBlockData> TMapBlockSubTypeData;
 
    struct SBlockData
    {
        std::string m_name {};
        uint8_t m_size {};
        uint8_t m_extraSize {};
        TMapDBBlockParamNStr m_mapBlockParamDesc {};// <block param, description>
    };
 
    static iv::logic::eDBBlockParamType enumDBBlockParamType(std::string_view strType);
    static std::string_view strDBBlockParamType(iv::logic::eDBBlockParamType type);
    static std::string getDefaultParameterValue(iv::logic::eDBBlockParamType paramType);
    static std::optional<std::string> getSpecificDefaultParameterValue(iv::logic::LogicBlockId blockId,
                                                                       iv::logic::ParamId paramId);
 
    static bool isEditableDBBlockParam(iv::logic::eDBBlockParamType type);
    static bool allowsExternalDescriptionDBBlockParam(iv::logic::eDBBlockParamType type);
    static bool allowsParameterOnlineDBBlockParam(iv::logic::eDBBlockParamType type);
 
    static CLogicsAllowed &getInstance();
 
    [[nodiscard]] uint8_t blockExtraSize(uint32_t blockType, uint32_t blockSubType) const;
    [[nodiscard]] std::string blockName(uint32_t blockType, uint32_t blockSubType) const;
    [[nodiscard]] TMapDBBlockParamNStr blockParamsDesc(uint32_t blockType, uint32_t blockSubType) const;
    [[nodiscard]] uint8_t blockSize(uint32_t blockType, uint32_t blockSubType) const;
    [[nodiscard]] std::string dbVersion() const;
    bool loadData();
    bool isAllowedSubtypeInLOM(uint32_t idLOM, uint32_t idSubtype);
    bool isEmpty() const;
 
    [[nodiscard]] TMapBlockSubTypeData getBlockSubTypes() const;
    [[nodiscard]] TMapBlockTypeDescription getBlockTypesDesc() const;
    [[nodiscard]] const std::string &getErrorText() const;
    [[nodiscard]] const TMapDBBlockParamSize &getParamSizes() const;
 
    [[nodiscard]] bool isDataLoadedOk() const;
    void eraseSubType(iv::logic::LogicBlockId pairTypeSubType);
    void collapseTreeStructure();
 
    virtual ~CLogicsAllowed() = default;
    CLogicsAllowed();
 
private:
    struct SPrvDBVersion
    {
        SPrvDBVersion() = default;
        ~SPrvDBVersion() = default;
        SPrvDBVersion(const SPrvDBVersion &other) = default;
        SPrvDBVersion(SPrvDBVersion &&other) = delete;
        SPrvDBVersion &operator=(const SPrvDBVersion &other) = default;
        SPrvDBVersion &operator=(SPrvDBVersion &&other) = delete;
 
        bool operator<(const SPrvDBVersion &other) const;
 
        std::string m_version {}; //ejemplo: 1.2
        std::string m_revision {};//ejemplo: 3
        std::string m_date {};    //ejemplo: 13/11/17 00:00:00
    };
 
    //CLogicsAllowed(const CLogicsAllowed &other) = delete;
    //CLogicsAllowed(CLogicsAllowed &&other) = delete;
    //CLogicsAllowed &operator=(const CLogicsAllowed &other) = delete;
    //CLogicsAllowed &operator=(CLogicsAllowed &&other) = delete;
 
    // general database methods
    void prvReadTable(const std::string &tableName);// method to DEBUG table description
 
    // methods to extract specific information from the database
    void prvExtractBlockParams();
    void prvExtractBlockParamsSize();
    void prvExtractBlockSubTypeParams(uint32_t blockType, uint32_t blockSubType);
    void prvExtractBlockSubTypes();
    void prvExtractBlockTypes();
    void prvExtractVersion();
    void prvExtractBlockAllowedSubTypes();
    // methods to calculate internal data
    void prvCalculateAndStoreBlocksSize();
    void prvCalculateAndStoreData();
 
    bool m_isDataLoadedOk {};
    std::string m_errorText {};
 
    // data obtained from the source file
    SPrvDBVersion m_dbVersion {};
    TMapDBBlockParamSize m_mapBlockParamSize {};
    TMapBlockTypeDescription m_mapBlockTypesDesc {};
    TMapBlockSubTypeData m_mapBlockSubTypesData {};// <<type, subType>, SBlockData>
    std::set<std::pair<uint32_t, uint32_t>> m_setIdTypeLOMIdSubtype {};
};
 
#endif /* LIBS_LOGIC_CLOGICSALLOWED_HPP_ */