CLogicsDrawingAreaModel.hpp

Go to the documentation of this file.

#ifndef LIBS_GUI_CLOGICSDRAWINGAREAMODEL_HPP_
#define LIBS_GUI_CLOGICSDRAWINGAREAMODEL_HPP_
 
#include "logic/CFormulaLogic.hpp"
#include "logic/CLogicFile.hpp"
#include "logic/CustomBlockIOInfos.hpp"
#include "logic/LogicLibraryIOInfo.hpp"
#include "logic/LogicLibraryInfo.hpp"
#include "logic/ParametersOnline.hpp"
#include "logic/components/CLogicsComponent.hpp"
#include "logic/components/CLogicsComponentChannel.hpp"
#include "logic/components/CLogicsComponentConstant.hpp"
#include "logic/components/CLogicsComponentExec.hpp"
#include "logic/components/CLogicsComponentLabel.hpp"
#include "logic/components/CLogicsComponentLibrary.hpp"
#include "logic/components/CLogicsComponentLibraryInOutBlock.hpp"
#include "logic/components/CLogicsComponentOthers.hpp"
#include "logic/components/LogicComponentBroadCastChannel.hpp"
#include "logic/components/LogicRectangle.hpp"
#include "logic/components/LogicText.hpp"
#include "logic/structs.hpp"
#include "ui/graphics/IGraphics.hpp"
#include "ui/gui/AbstractCanvasItem.hpp"
 
#include <bits/stdint-uintn.h>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <unordered_map>
 
class CLogicsDrawingAreaModel
{
public:
    enum class EActionOnLogicsComponent
    {
        ChangeOrderOfExecution,
        ConstState,
        Delete,
        Join,
        Paste,
        Properties,
        SelectConnections,
        SelectInsideBlocks,
        SelectChannel,
        SplitHorizontal,
        SplitVertical,
        LoadLibrary,
        ZoomFit,
        First = ChangeOrderOfExecution,
        Last = ZoomFit
    };
 
    // NOTE: 2020/07/29. "CMap::add()" can't manage unique_ptr (probably because it should call std::move inside)
    typedef std::map<AbstractCanvasItem::TId, std::shared_ptr<AbstractLogicsElement>> TMapIdElement;
    typedef std::unordered_map<std::string, AbstractCanvasItem::TId> TMapLabelId;
    typedef std::unordered_map<std::string, AbstractCanvasItem::TId> TMapLibraryIOBlockId;
 
    static std::shared_ptr<CLogicsDrawingAreaModel>
    ledFileToCLogicsDrawingAreaModel(const std::string &file,
                                     std::optional<iv::types::unitId> logicUnitId = std::nullopt,
                                     std::optional<iv::types::logic::customBlockId> customBlockId = std::nullopt);
 
    explicit CLogicsDrawingAreaModel(std::optional<iv::types::unitId> logicUnitId = std::nullopt,
                                     std::optional<iv::types::logic::customBlockId> customBlockId = std::nullopt);
    ~CLogicsDrawingAreaModel() = default;
    CLogicsDrawingAreaModel(const CLogicsDrawingAreaModel &other) = delete;
    CLogicsDrawingAreaModel(CLogicsDrawingAreaModel &&other) = delete;
    CLogicsDrawingAreaModel &operator=(const CLogicsDrawingAreaModel &other) = delete;
    CLogicsDrawingAreaModel &operator=(CLogicsDrawingAreaModel &&other) = delete;
 
    void addLogicsElement(AbstractCanvasItem::TId id, const std::shared_ptr<AbstractLogicsElement> &logicsElement);
    void deleteLogicsElement(AbstractCanvasItem::TId id);
    void changeOrderOfExecution(iv::types::logic::logicExecutionOrder oldOrder,
                                iv::types::logic::logicExecutionOrder newOrder);
 
    std::shared_ptr<CLogicFile> generateCLogicFileObject(uint32_t logicId) const;
    std::shared_ptr<iv::logic::UnitParamsOnline> generateUnitParamsOnline(uint32_t logicId) const;
 
    LogicLibraryInfo generateLogicLibraryInfo(const CLogicsAllowed::TMapDBBlockParamNStr &mapBlockParamsDesc) const;
 
    CLogicsAllowed::TMapDBBlockParamNStr getLibraryParametersDesc() const;
    CLogicsAllowed::TMapDBBlockParamNStr getLibraryExternalParametersValues() const;
 
    void read(const iv::file::xml::File &fileXml);
    void readInfoLogic(const iv::file::xml::File &fileXml);
 
    void save(iv::file::xml::File &fileXml) const;
    bool saveLogicLedFiles(const std::string &projectFolder, uint16_t logicUnitId) const;
 
    void checkIntegrity(AbstractLog *logger) const;
 
    void updateLogicsElements();
    void checkAndFixIntegrity();
 
    void setFlagProjectJustLoaded(bool flag);
 
    bool getFlagProjectJustLoaded() const;
    iv::logic::InfoLogicTxt *getInfoLogicPtr();
    void setInfoLogic(const iv::logic::InfoLogicTxt &infoLogicTxt);
    std::shared_ptr<const AbstractLogicsElement> getLogicsElement(AbstractCanvasItem::TId id) const;
    std::shared_ptr<AbstractLogicsElement> getLogicsElement(AbstractCanvasItem::TId id);
    std::set<AbstractCanvasItem::TId> getLogicsElementsIds() const;
    AbstractCanvasItem::TId getNextIdInc();// gets next and increments 1
 
    bool addCustomBlockInfo(const iv::logic::LogicLibraryIOInfo &info) const;
 
    std::map<iv::types::logic::libraryIOId, std::shared_ptr<iv::logic::LogicLibraryIOInfo>>
    getCustomBlockInInfos() const;
    std::weak_ptr<iv::logic::LogicLibraryIOInfo> getCustomBlockInInfo(const iv::types::logic::libraryIOId &id) const;
    bool updateCustomBlockInInfo(const iv::types::logic::libraryIOId &id,
                                 const iv::logic::LogicLibraryIOInfo &info) const;
    bool removeCustomBlockInInfo(const iv::types::logic::libraryIOId &id) const;
 
    std::map<iv::types::logic::libraryIOId, std::shared_ptr<iv::logic::LogicLibraryIOInfo>>
    getCustomBlockOutInfos() const;
    std::weak_ptr<iv::logic::LogicLibraryIOInfo> getCustomBlockOutInfo(const iv::types::logic::libraryIOId &id) const;
    bool updateCustomBlockOutInfo(const iv::types::logic::libraryIOId &id,
                                  const iv::logic::LogicLibraryIOInfo &info) const;
    bool removeCustomBlockOutInfo(const iv::types::logic::libraryIOId &id) const;
 
    iv::types::logic::logicExecutionOrder getNextOrderOfExecution() const;
    iv::types::logic::logicExecutionOrder getNextOrderOfExecutionInc();// gets next and increments 1
    iv::types::logic::logicExecutionOrder getOrderOfExecution(AbstractCanvasItem::TId id) const;
 
    void addUniqueLabel(const std::string &labelName, AbstractCanvasItem::TId lEId);
    void deleteUniqueLabel(const std::string &labelName, CLogicsComponentLabel::ELabelIOType labelIOType);
    bool existUniqueLabel(const std::string &labelName) const;
    std::set<AbstractCanvasItem::TId> findChannelsLabelsAndIOBlocks() const;
    std::string getUniqueLabelDescription(const std::string &labelName);
    std::string getFirstUniqueCreatedLabelName() const;
    std::string getNextDefaultUniqueLabelNameInc();// gets next and increments 1
    void updateUniqueLabel(const std::string &oldLabelName, const std::string &newLabelName,
                           const std::string &newDescription);
    void updateUnsetLabels(const std::string &newLabelName);
    void updateBasicBlockValues(AbstractCanvasItem::TId itemId);
    void clearBasicBlocksParamValue(AbstractCanvasItem::TId itemRemovingId);
 
    std::shared_ptr<AbstractLogicsElement> getAbstractLogicElement(AbstractCanvasItem::TId id) const;
 
    std::shared_ptr<iv::logic::component::LogicText> getLogicsText(AbstractCanvasItem::TId id) const;
    static std::shared_ptr<iv::logic::component::LogicText>
    getLogicsText(const std::shared_ptr<AbstractLogicsElement> &logicsElement);
 
    std::shared_ptr<iv::logic::component::LogicRectangle> getLogicsRectangle(AbstractCanvasItem::TId id) const;
    static std::shared_ptr<iv::logic::component::LogicRectangle>
    getLogicsRectangle(const std::shared_ptr<AbstractLogicsElement> &logicsElement);
 
    std::shared_ptr<CLogicsComponent> getLogicsComponent(AbstractCanvasItem::TId id) const;
    static std::shared_ptr<CLogicsComponent>
    getLogicsComponent(const std::shared_ptr<AbstractLogicsElement> &logicsElement);
 
    std::shared_ptr<CLogicsComponentOthers> getLogicsComponentOthers(AbstractCanvasItem::TId id) const;
    static std::shared_ptr<CLogicsComponentOthers>
    getLogicsComponentOthers(const std::shared_ptr<AbstractLogicsElement> &logicsElement);
 
    std::shared_ptr<CLogicsComponentConstant> getLogicsComponentConstant(AbstractCanvasItem::TId id) const;
    static std::shared_ptr<CLogicsComponentConstant>
    getLogicsComponentConstant(const std::shared_ptr<AbstractLogicsElement> &logicsElement);
 
    std::shared_ptr<CLogicsComponentChannel> getLogicsComponentChannel(AbstractCanvasItem::TId id) const;
    static std::shared_ptr<CLogicsComponentChannel>
    getLogicsComponentChannel(const std::shared_ptr<AbstractLogicsElement> &logicsElement);
 
    std::shared_ptr<LogicComponentBroadCastChannel>
    getLogicsComponentBroadCastChannel(AbstractCanvasItem::TId id) const;
    static std::shared_ptr<LogicComponentBroadCastChannel>
    getLogicsComponentBroadCastChannel(const std::shared_ptr<AbstractLogicsElement> &logicsElement);
 
    std::shared_ptr<CLogicsComponentLabel> getLogicsComponentLabel(AbstractCanvasItem::TId id) const;
    static std::shared_ptr<CLogicsComponentLabel>
    getLogicsComponentLabel(const std::shared_ptr<AbstractLogicsElement> &logicsElement);
 
    std::shared_ptr<CLogicsConnection> getLogicsComponentConnection(AbstractCanvasItem::TId id) const;
    static std::shared_ptr<CLogicsConnection>
    getLogicsComponentConnection(const std::shared_ptr<AbstractLogicsElement> &logicsElement);
 
    std::shared_ptr<CLogicsConnectionPoint> getLogicsComponentConnectionPoint(AbstractCanvasItem::TId id) const;
    static std::shared_ptr<CLogicsConnectionPoint>
    getLogicsComponentConnectionPoint(const std::shared_ptr<AbstractLogicsElement> &logicsElement);
 
    std::shared_ptr<CLogicsComponentLibraryInOutBlock>
    getLogicsComponentLibraryIOBlock(AbstractCanvasItem::TId id) const;
    static std::shared_ptr<CLogicsComponentLibraryInOutBlock>
    getLogicsComponentLibraryIOBlock(const std::shared_ptr<AbstractLogicsElement> &logicsElement);
 
    std::shared_ptr<CLogicsComponentExec> getLogicsComponentExec(AbstractCanvasItem::TId id) const;
    static std::shared_ptr<CLogicsComponentExec>
    getLogicsComponentExec(const std::shared_ptr<AbstractLogicsElement> &logicsElement);
 
    std::shared_ptr<CLogicsComponentLibrary> getLogicsComponentLibraryBlock(AbstractCanvasItem::TId id) const;
    static std::shared_ptr<CLogicsComponentLibrary>
    getLogicsComponentLibraryBlock(const std::shared_ptr<AbstractLogicsElement> &logicsElement);
 
    bool isItemCopyable(AbstractCanvasItem::TId id) const;
 
    bool isItemLogicText(AbstractCanvasItem::TId id) const;
    static bool isItemLogicText(const std::shared_ptr<const AbstractLogicsElement> &component);
 
    bool isItemLogicRectangle(AbstractCanvasItem::TId id) const;
    static bool isItemLogicRectangle(const std::shared_ptr<const AbstractLogicsElement> &component);
 
    bool isItemLogicComponent(AbstractCanvasItem::TId id) const;
    static bool isItemLogicComponent(const std::shared_ptr<const AbstractLogicsElement> &component);
 
    bool isItemChannelOrLabelOrIOBlock(AbstractCanvasItem::TId id) const;
    bool isItemIOBlock(AbstractCanvasItem::TId id) const;
    static bool isItemIOBlock(const std::shared_ptr<const AbstractLogicsElement> &component);
 
    bool isItemBasicBlock(AbstractCanvasItem::TId id) const;
    static bool isItemBasicBlock(const std::shared_ptr<const AbstractLogicsElement> &component);
 
    bool isItemLibraryBlock(AbstractCanvasItem::TId id) const;
    static bool isItemLibraryBlock(const std::shared_ptr<const AbstractLogicsElement> &component);
 
    bool isItemExecBlock(AbstractCanvasItem::TId id) const;
    static bool isItemExecBlock(const std::shared_ptr<const AbstractLogicsElement> &component);
 
    bool isItemBasicOrLibraryBlock(AbstractCanvasItem::TId id) const;
    static bool isItemBasicOrLibraryBlock(const std::shared_ptr<const AbstractLogicsElement> &component);
 
    bool isItemChannel(AbstractCanvasItem::TId id) const;
    static bool isItemChannel(const std::shared_ptr<const AbstractLogicsElement> &component);
 
    bool isItemConstant(AbstractCanvasItem::TId id) const;
    static bool isItemConstant(const std::shared_ptr<const AbstractLogicsElement> &component);
 
    bool isItemBroadCastChannel(AbstractCanvasItem::TId id) const;
    static bool isItemBroadCastChannel(const std::shared_ptr<const AbstractLogicsElement> &component);
 
    bool isItemLabel(AbstractCanvasItem::TId id) const;
    static bool isItemLabel(const std::shared_ptr<const AbstractLogicsElement> &component);
 
    bool isItemLibraryIOBlock(AbstractCanvasItem::TId id) const;
    static bool isItemLibraryIOBlock(const std::shared_ptr<const AbstractLogicsElement> &component);
 
    bool isItemMovable(AbstractCanvasItem::TId id) const;
 
    bool isLogicEmpty() const;
    bool isLogicCompletelyConnected() const;
 
    void setCustomBlockId(std::optional<iv::types::logic::customBlockId> customBlockId);
    void setInfoLogicTxtDataFileAndDate(const std::string &fileName);
    void updateLogicsChannels();
    const TMapIdElement *getElementsMap() const;
    void checkAllConnections(const std::shared_ptr<CFormulaLogic> &formulaOptRef);
    void checkAllStationConnections(const std::vector<std::shared_ptr<iv::logic::formulaLogic::SBlock>> &logicBlocks);
    static void checkConnections(iv::logic::formulaLogic::SBlock &block,
                                 const std::shared_ptr<CLogicsComponent> &component);
    std::string getLibraryFilePath() const;
    std::set<iv::types::logic::libraryTagName> getAllLibraryBlockTagnames() const;
    std::set<std::string> getLabelsNames() const;
 
    std::optional<iv::types::unitId> getLogicUnitId() const;
    std::optional<iv::types::logic::customBlockId> getCustomBlockId() const;
    std::shared_ptr<iv::logic::CustomBlockIOInfos> getCustomBlockIOInfos() const;
 
    std::vector<std::weak_ptr<iv::channels::AbstractChannel>> getChannels() const;
 
private:
    void checkRepeatedOrderOfExecution(AbstractLog *logger) const;
    void checkInvertedOrderOfExecutions(AbstractLog *logger) const;
    void checkLibraryBlocksRepeatedOrderOfExecution(AbstractLog *logger) const;
    void checkLibraryBlocksOrderOfExecution(AbstractLog *logger) const;
    void checkDefinedLibraryInParamNotUsed(AbstractLog *logger) const;
    void checkDefinedLibraryOutParamNotUsed(AbstractLog *logger) const;
 
    static std::map<iv::types::logic::libraryIOId, iv::logic::LogicLibraryIOInfo>
    prvReadLibraryInputs(const iv::file::xml::node &nodeDataLogic);
    static std::map<iv::types::logic::libraryIOId, iv::logic::LogicLibraryIOInfo>
    prvReadLibraryOutputs(const iv::file::xml::node &nodeDataLogic);
 
    void prvSaveLibraryInputs(iv::file::xml::node &nodeDataLogic) const;
    void prvSaveLibraryOutputs(iv::file::xml::node &nodeDataLogic) const;
 
    void prvClearConnectionPointParameter(std::shared_ptr<CLogicsConnectionPoint> connectionPoint) const;
 
    ELibraryLogicBlockParamConnectedType prvGetLibraryLogicBlockParamConnectedTypeForParameter(
            const std::shared_ptr<CLogicsComponentLibrary> &componentLibraryRef, iv::logic::ParamId paramId) const;
    void prvUpdateLibraryBlockExternalParams(const std::shared_ptr<CLogicsComponentLibrary> &componentLibraryRef) const;
 
    CFormulaLogic *prvGenerateCLogicFileObjectLomData(uint32_t unitId, const CLogicsAllowed &logicsAllowed) const;
 
    bool prvGenerateCLogicFileObjectLomDataParams(
            uint32_t unitId, const std::shared_ptr<CLogicsComponentExec> &currentLogicComponentExec,
            const CLogicsAllowed &logicsAllowed, iv::logic::formulaLogic::SBlock &blockRef, std::string &error,
            uint16_t &blockWrittenIndex) const;
 
    bool prvGenerateCLogicFileObjectLomDataLibrary(uint32_t unitId, const LogicLibraryInfo &currentLibraryInfo,
                                                   const CLogicsAllowed &logicsAllowed,
                                                   iv::logic::formulaLogic::SBlock &libraryBlocksRef,
                                                   std::string &error, uint16_t &blockWrittenIndex) const;
 
    bool prvGenerateCLogicFileObjectLomDataLibraryBlockParams(uint32_t unitId, const SLibraryLogicBlock &currentBlock,
                                                              const CLogicsAllowed &logicsAllowed,
                                                              iv::logic::formulaLogic::SBlock &blockRef,
                                                              std::string &error, uint16_t &blockWrittenIndex) const;
 
    std::shared_ptr<iv::logic::UnitParamsOnline> prvGenerateCParamOnLineListObject(uint32_t unitId,
                                                                                   CFormulaLogic *formulaLogic) const;
 
    bool prvGenerateCParamOnlineListObjectBlockLibrary(
            const iv::logic::formulaLogic::SBlock &logicBlock, uint32_t unitId, const std::string &libraryBlockTagName,
            uint32_t &onlineParamOrderInLogicOut,
            const std::shared_ptr<iv::logic::LibraryParamsOnline> &libraryParamsOnlineOut) const;
    static bool prvGenerateCParamOnlineListObjectBlockParams(
            const iv::logic::formulaLogic::SBlock &logicBlock, uint32_t unitId, const std::string &libraryBlockTagName,
            uint32_t &onlineParamOrderInLogicOut,
            const std::shared_ptr<iv::logic::LibraryParamsOnline> &libraryParamsOnlineOut);
 
    CLogicsComponentConstant *prvGetCLogicsComponentConstant(AbstractCanvasItem::TId id) const;
    void prvSetConnectionValues(const std::shared_ptr<CLogicsConnectionPoint> &basicBlockConnectionPoint,
                                const std::shared_ptr<CLogicsConnectionPoint> &connectedConnectionPoint);
    void prvSetConnectionValues(const std::shared_ptr<CLogicsConnection> &connection);
    void prvPostReadProcessing();
    void prvPostReadProcessingConnection(const std::shared_ptr<AbstractLogicsElement> &lE);
    void prvPostReadProcessingConnectionPoint(const std::shared_ptr<AbstractLogicsElement> &lE) const;
    void prvSetComponentExecBlockParams(AbstractCanvasItem::TId itemId);
    void prvSetConnectionComponentMI(const std::shared_ptr<CLogicsConnectionPoint> &connectionPoint,
                                     uint32_t currentMI) const;
    bool prvSetIdOutputPins() const;
 
    std::string prvFormatParameterLogicDrawing(const iv::logic::formulaLogic::SBlockParam &pPar,
                                               const std::shared_ptr<AbstractLogicsElement> &logicComponent,
                                               uint32_t globalIdOrValueParameter) const;
    std::string
    prvFormatExternalParameterBlocksInLibraryLogicsDrawing(const iv::logic::formulaLogic::SBlockParam &pPar,
                                                           const std::shared_ptr<AbstractLogicsElement> &logicComponent,
                                                           uint32_t globalIdOrValueParameter) const;
 
    std::string prvFormatParameterLogicLibraryInfo(const iv::logic::formulaLogic::SBlockParam &pPar,
                                                   const SLibraryLogicBlockParam &libraryLogicBlockParam,
                                                   uint32_t globalIdOrValueParameter) const;
    std::string prvFormatEditParameterLogicLibraryInfo(const iv::logic::formulaLogic::SBlockParam &pPar,
                                                       uint32_t globalIdOrValueParameter, uint32_t blockOrder) const;
    std::string
    prvFormatExternalParameterBlocksInLibraryLogicLibraryInfo(const iv::logic::formulaLogic::SBlockParam &pPar,
                                                              const SLibraryLogicBlockParam &libraryLogicBlockParam,
                                                              uint32_t globalIdOrValueParameter) const;
    void prvUpdateComponent(const std::shared_ptr<CLogicsComponent> &lComponent);
    void prvUpdateLabels(const std::string &oldLabelName, const std::string &newLabelName,
                         const std::string &newLabelDescription);
    void prvUpdateOrdersOfExecution(
            EActionOnLogicsComponent lastAction, iv::types::logic::logicExecutionOrder oldOrder,
            iv::types::logic::logicExecutionOrder newOrder = AbstractCanvasItem::kInvalidCanvasItemId);
 
    uint32_t prvFindParameterValue(const std::shared_ptr<CLogicsComponentExec> &lcExec,
                                   iv::logic::eDBBlockParamType blockParamType,
                                   iv::types::logic::paramNumber parameterNumber, const std::string &paramDescription,
                                   std::string &paramValueText, uint32_t &channelUnitId, uint16_t &channelId,
                                   std::string &channelType, std::string &description, std::string &error) const;
    std::string prvFindSParameterValue(const std::shared_ptr<CLogicsComponentExec> &lcExec,
                                       iv::logic::eDBBlockParamType blockParamType,
                                       iv::types::logic::paramNumber paramNum, bool isLibrary,
                                       const std::string &paramValue, std::string &error) const;
 
    uint32_t prvFindParameterValueInLib(const SLibraryLogicBlockParam &blockParam, const SLibraryLogicBlock &blockRef,
                                        std::string &paramValueText, uint32_t &channelUnitId, uint16_t &channelId,
                                        std::string &channelType, std::string &description, std::string &error) const;
 
    static uint32_t prvGetComponentIdOfOppositeConnectionPoint(const std::shared_ptr<CLogicsComponentExec> &pExec,
                                                               iv::logic::eDBBlockParamType type,
                                                               iv::types::logic::paramNumber paramNum);
    std::shared_ptr<CLogicsConnectionPoint> prvGetOppositeConnectionPointFromPoint(AbstractCanvasItem::TId tId) const;
 
    std::string prvGetBlockDescription(const std::shared_ptr<AbstractLogicsElement> &block,
                                       const std::shared_ptr<CLogicsConnectionPoint> &connectionPoint);
 
    // all the elements in the canvas
    TMapLabelId m_mapUniqueLabelId;
    // names and ids of the unique label elements in the canvas. No upper/lowercase distinction
    TMapIdElement m_mapIdElement;
 
    // upper/lowercase distinction
    std::shared_ptr<iv::logic::CustomBlockIOInfos> m_libraryIOInfos;
 
    AbstractCanvasItem::TId m_nextIdToUse;
    iv::types::logic::logicExecutionOrder m_nextOrderOfExecution;
    CLogicsComponentLabel::TUniqueLabelDefaultIdNumber m_nextUniqueLabelDefaultIdNumber;
    iv::logic::InfoLogicTxt m_infoLogic;
 
    std::optional<iv::types::unitId> m_logicUnitId;
    std::optional<iv::types::logic::customBlockId> m_customBlockId;
    bool m_flagProjectJustLoaded;// true after having read a project
    void deleteLogicElementFromCanvas(std::vector<std::string> logicChannelsToDelete, IGraphics *graphics);
};
 
#endif /* LIBS_GUI_CLOGICSDRAWINGAREAMODEL_HPP_ */