PortMapInterface.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
// File: PortMapInterface.h
//-----------------------------------------------------------------------------
// Project: Kactus2
// Author: Mikko Teuho
// Date: 22.10.2020
//
// Description:
// Interface for editing port maps.
//-----------------------------------------------------------------------------
 
#ifndef PORTMAPINTERFACE_H
#define PORTMAPINTERFACE_H
 
#include <CommonInterface.h>
#include <ParameterizableInterface.h>
 
#include <IPXACTmodels/common/PresenceTypes.h>
#include <IPXACTmodels/Component/PortMap.h>
#include <IPXACTmodels/Component/Port.h>
#include <IPXACTmodels/generaldeclarations.h>
 
#include "KactusAPI/KactusAPIGlobal.h"
 
class PortMap;
class PortMapValidator;
class PortAbstraction;
class AbstractionDefinition;
class AbstractionType;
class Component;
class PortsInterface;
class PortAbstractionInterface;
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class KACTUS2_API PortMapInterface : public ParameterizableInterface, public CommonInterface
{
 
public:

    PortMapInterface(QSharedPointer<PortMapValidator> validator,
        QSharedPointer<ExpressionParser> expressionParser,
        QSharedPointer<ExpressionFormatter> expressionFormatter,
        PortsInterface* physicalPortInterface,
        PortAbstractionInterface* logicalPortInterface);

    virtual ~PortMapInterface() = default;

    void setupAbstractionDefinition(QSharedPointer<AbstractionDefinition const> absDef);

    void setupPhysicalPorts(Port::List ports);

    virtual void setupPortMaps(QSharedPointer<AbstractionType> abstractionType);

    void setupBusMode(General::InterfaceMode busMode);

    void setupSystemGroup(QString const& systemGroup);

    virtual std::string getIndexedItemName(int const& itemIndex) const;

    virtual int itemCount() const override final;

    virtual std::vector<std::string> getItemNames() const override final;

    std::string getLogicalPortName(int const& portMapIndex) const;

    bool setLogicalPort(int const& portMapIndex, std::string const& newName);

    bool hasPhysicalPort(int const& portMapIndex) const;

    std::string getPhysicalPortName(int const& portMapIndex) const;

    bool setPhysicalPort(int const& portMapIndex, std::string const& newPhysicalName);

    std::string getLogicalPresence(int const& portMapIndex);

    std::string getLogicalPresenceWithLogicalPort(std::string const& logicalName);

    std::string getInvertString(int const& portMapIndex) const;

    BooleanValue getInvertValue(int const& portMapIndex) const;

    bool getInvertBool(int const& portMapIndex) const;

    bool setInvertValue(int const& portMapIndex, bool newInvertValue) const;

    std::string getIsInformativeString(int const& portMapIndex) const;

    bool getIsInformativeValue(int const& portMapIndex) const;

    bool setIsInformativeValue(int const& portMapIndex, bool newIsInformativeValue) const;

    std::string getLogicalTieOffValue(int const& portMapIndex, int const& baseNumber = 0) const;

    std::string getLogicalTieOffFormattedExpression(int const& portMapIndex) const;

    std::string getLogicalTieOffExpression(int const& portMapIndex) const;

    bool setLogicalTieOff(int const& portMapIndex, std::string const& newTieOff);

    std::string getLogicalLeftBoundValue(int const& portMapIndex, int const& baseNumber = 0) const;

    std::string getLogicalLeftBoundFormattedExpression(int const& portMapIndex) const;

    std::string getLogicalLeftBoundExpression(int const& portMapIndex) const;

    bool setLogicalLeftBound(int const& portMapIndex, std::string const& newLogicalLeft);

    std::string getLogicalRightBoundValue(int const& portMapIndex, int const& baseNumber = 0) const;

    std::string getLogicalRightBoundFormattedExpression(int const& portMapIndex) const;

    std::string getLogicalRightBoundExpression(int const& portMapIndex) const;

    bool setLogicalRightBound(int const& portMapIndex, std::string const& newLogicalRight);

    std::string getPhysicalLeftBoundValue(int const& portMapIndex, int const& baseNumber = 0) const;

    std::string getPhysicalLeftBoundFormattedExpression(int const& portMapIndex) const;

    std::string getPhysicalLeftBoundExpression(int const& portMapIndex) const;

    bool setPhysicalLeftBound(int const& portMapIndex, std::string const& newPhysicalLeft);

    std::string getPhysicalRightBoundValue(int const& portMapIndex, int const& baseNumber = 0) const;

    std::string getPhysicalRightBoundFormattedExpression(int const& portMapIndex) const;

    std::string getPhysicalRightBoundExpression(int const& portMapIndex) const;

    bool setPhysicalRightBound(int const& portMapIndex, std::string const& newPhysicalRight);

    std::string getLogicalPortIconPath(int const& portMapIndex) const;

    std::string getPhysicalPortIconPath(int const& portMapIndex) const;

    bool logicalPortExists(int const& portMapIndex) const;

    virtual int getAllReferencesToIdInItem(const std::string& itemName, std::string const&  valueID) const override
        final;

    std::vector<std::string> getExpressionsInSelectedPortMap(int const& portMapIndex) const;

    virtual bool validateItems() const override final;

    bool logicalPortIsValid(int const& portMapIndex) const;

    bool physicalPortIsValid(int const& portMapIndex) const;

    bool physicalMappingIsValid(int const& portMapIndex) const;

    bool connectedPortsHaveValidPortTypes(int const& portMapIndex) const;

    bool connectedPortsHaveValidDirections(int const& portMapIndex) const;

    bool connectedPortsHaveValidInitiatives(int const& portMapIndex) const;

    bool connectedPortsHaveSameRange(int const& portMapIndex) const;

    bool tieOffIsValid(int const& portMapIndex) const;

    bool logicalPortHasValidRange(int const& portMapIndex) const;

    bool connectPorts(std::string const& logicalPortName, std::string const& physicalPortName);

    void addPortMap(int const& row);

    bool removePortMap(int const& portMapIndex);

    std::vector<std::string> removeAllPortMapsFromLogicalPort(std::string const& logicalPortName);

    PortMap* getPortMapPointer(int const& portMapIndex) const;

    PortsInterface* getPhysicalPortInterface() const;

    PortAbstractionInterface* getLogicalPortInterface() const;

    void createRequiredSignals();

    void createOptionalSignals();

    void createAllSignals();

    General::InterfaceMode getInterfaceMode() const;

    std::string getSystemGroup() const;
 
private:

    QSharedPointer<PortMap> getUnconnectedPortMap(std::string const& logicalPortName) const;

    QSharedPointer<PortMap> getPortMap(int const& portMapIndex) const;

    bool removeEmptyLogicalPort(QSharedPointer<PortMap> editedPortMap);

    bool removeEmptyRange(QSharedPointer<PortMap::LogicalPort> editedPortLogical);

    bool removeEmptyPhysicalPort(QSharedPointer<PortMap> editedPortMap);

    bool removeEmptyPhysicalPartSelect(QSharedPointer<PortMap::PhysicalPort> physicalPort);

    QSharedPointer<PartSelect> getPhysicalPartSelect(int const& portMapIndex);

    void createPortMapsWithPresence(int presence);

    bool portMapExistsForLogicalSignal(std::string const& signalName) const;
 
    //-----------------------------------------------------------------------------
    // Data.
    //-----------------------------------------------------------------------------

    QSharedPointer<QList<QSharedPointer<PortMap> > > portMaps_{ nullptr };

    General::InterfaceMode interfaceMode_;

    std::string systemGroup_;

    QSharedPointer<AbstractionDefinition const> abstractionDef_{ nullptr };

    QSharedPointer<PortMapValidator> validator_{ nullptr };

    PortsInterface* physicalPortInterface_{ nullptr };

    PortAbstractionInterface* logicalPortInterface_{ nullptr };
};
 
#endif // PORTMAPINTERFACE_H