PortAbstractionInterface.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
// File: PortAbstractionInterface.h
//-----------------------------------------------------------------------------
// Project: Kactus2
// Author: Mikko Teuho
// Date: 10.12.2020
//
// Description:
// Interface for editing abstraction definition port abstractions.
//-----------------------------------------------------------------------------
 
#ifndef PORTABSTRACTIONINTERFACE_H
#define PORTABSTRACTIONINTERFACE_H
 
#include <MasterPortInterface.h>
#include <KactusAPI/include/ParameterizableInterface.h>
 
#include "KactusAPI/KactusAPIGlobal.h"
 
#include <IPXACTmodels/common/DirectionTypes.h>
#include <IPXACTmodels/common/PresenceTypes.h>
#include <IPXACTmodels/common/Qualifier.h>
#include <IPXACTmodels/common/Document.h>
#include <IPXACTmodels/AbstractionDefinition/PortAbstraction.h>
 
#include <IPXACTmodels/generaldeclarations.h>
 
class PortAbstraction;
class TransactionalPort;
class WirePort;
class Protocol;
class AbstractionDefinition;
class PortAbstractionValidator;
class ExpressionParser;
class ExpressionFormatter;
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class KACTUS2_API PortAbstractionInterface : public MasterPortInterface, public ParameterizableInterface
{
public:

    PortAbstractionInterface(QSharedPointer<ExpressionParser> expressionParser, 
        QSharedPointer<ExpressionFormatter> expressionFormatter);

    virtual ~PortAbstractionInterface() = default;

    void setAbsDef(QSharedPointer<AbstractionDefinition const> absDef);

    void setPortAbstractionValidator(QSharedPointer<PortAbstractionValidator> validator);

    virtual int getItemIndex(std::string const& itemName) const override final;

    virtual int getItemIndex(std::string const& itemName, General::InterfaceMode mode,
        std::string const& systemGroup = std::string()) const;

    std::string getIndexedItemName(int itemIndex) const final;

    virtual int itemCount() const override final;

    int signalCount(std::string const& portName) const;

    bool portHasMultiplesOfMasterOrSlave(std::string const& portName, std::string const& mode);

    bool setName(std::string const& currentName, std::string const& newName) final;

    bool validateItems() const final;

    bool itemHasValidName(std::string const& itemName) const final;

    bool wireHasValidWidth(int portIndex) const;

    bool wireHasValidDefaultValue(int portIndex) const;

    bool getMatch(int const& portIndex) const;

    bool setMatch(int const& portIndex, bool match) const;

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

    std::vector<std::string> getItemNamesWithModeAndGroup(std::string const& busModeString,
        std::string systemGroup) const;

    General::InterfaceMode getMode(int const& portIndex) const;

    std::string getModeString(int const& portIndex) const;

    bool setMode(int const& portIndex, std::string const& newMode);

    std::string getSystemGroup(int const& portIndex) const;

    std::vector<std::string> getSystemGroupsForPort(std::string const& portName) const;

    bool setSystemGroup(int const& portIndex, std::string const& newSystem);

    std::vector<std::string> getQualifierStringList(int const& portIndex) const;

    bool setQualifier(int const& portIndex, std::string const& newQualifier);

    bool setQualifierStringList(int const& portIndex, std::vector<std::string> const& newQualifierList);

    std::string getQualifierAttribute(int const& portIndex, std::string const& attributeName) const;

    bool setQualifierAttribute(int const& portIndex, std::string const& attributeName, 
        std::string const& attributeValue) const;

    bool setQualifierAttributes(int const& portIndex, std::vector<std::string> const& attributes) const;

    std::vector<std::string> getQualifierAttributes(int const& portIndex) const;

    std::string getDirectionString(int const& portIndex) const;

    DirectionTypes::Direction getDirection(int const& portIndex) const;

    DirectionTypes::Direction getDirection(std::string const& portName, General::InterfaceMode mode,
        std::string const& systemGroup) const;

    bool setDirection(int const& portIndex, std::string const& newDirection);

    std::string getWidthExpression(int const& portIndex) const;

    std::string getWidthExpression(std::string const& portName, std::string const& interfaceMode,
        std::string const& systemGroup) const;

    std::string getWidthExpression(std::string const& portName, General::InterfaceMode interfaceMode,
        std::string const& systemGroup) const;

    std::string getWidthFormattedExpression(int portIndex) const;

    std::string getWidthValue(int portIndex, int const& baseNumber = 0) const;

    std::string getWidthValue(std::string const& portName,
        General::InterfaceMode interfaceMode,
        std::string const& systemGroup,
        int const& baseNumber = 0) const;

    bool setWidth(int const& portIndex, std::string const& newWidth);

    PresenceTypes::Presence getPresence(int const& portIndex) const;

    PresenceTypes::Presence getPresence(std::string const& portName, std::string const& interfaceMode,
        std::string const& systemGroup) const;

    std::string getPresenceString(int const& portIndex) const;

    std::string getPresenceString(std::string const& portName, std::string const& interfaceMode,
        std::string const& systemGroup) const;

    bool setPresence(int const& portIndex, std::string const& newPresence);

    std::string getDefaultValueExpression(int const& portIndex) const;
    
    std::string getDefaultValueFormattedExpression(int const& portIndex) const;

    std::string getDefaultValueValue(int const& portIndex, int baseNumber = 0) const;

    bool setDefaultValue(int const& portIndex, std::string const& newDefaultValue);

    std::string getDriverString(int const& portIndex) const;

    bool setDriverType(int const& portIndex, std::string const& newDriver);

    std::string getBusWidthExpression(int const& portIndex) const;

    std::string getBusWidthExpression(std::string const& portName, std::string const& interfaceMode,
        std::string const& systemGroup) const;

    std::string getBusWidthFormattedExpression(int signalIndex) const;
    
    std::string getBusWidthValue(int portIndex, int baseNumber = 0) const;

    bool setBusWidth(int const& portIndex, std::string const& newBusWidth);
 
    bool transactionalHasValidBusWidth(int portIndex) const;

    std::string getInitiative(int const& portIndex) const;

    std::string getInitiative(std::string const& portName, std::string const& interfaceMode,
        std::string const& systemGroup) const;

    bool setInitiative(int const& portIndex, std::string const& newInitiative);

    std::string getKind(int const& portIndex) const;

    bool setKind(int const& portIndex, std::string const& newKind);

    bool hasProtocol(int const& portIndex) const;

    std::string getProtocolType(int const& portIndex) const;

    bool setProtocolType(int const& portIndex, std::string const& newProtocolType);

    std::string getPayloadName(int const& portIndex);

    bool setPayloadName(int const& portIndex, std::string const& newPayloadName);

    std::string getPayloadType(int const& portIndex);

    bool setPayloadType(int const& portIndex, std::string const& newPayloadType);

    std::string getPayloadExtension(int const& portIndex);

    bool setPayloadExtension(int const& portIndex, std::string const& newPayloadExtension);

    void addWirePort(std::string const& newPortName = std::string("")) final;

    void addTransactionalPort(std::string const& newPortName = std::string("")) final;

    void addModeSpecificWireSignal(std::string const& portName, General::InterfaceMode const& newMode);

    void addWireSystemSignal(std::string const& portName, std::string const& systemGroup);

    void addModeSpecificTransactionalSignal(std::string const& portName, General::InterfaceMode const& newMode);

    void addTransactionalSystemSignal(std::string const& portName, std::string const& systemGroup);

    bool removeSignal(int const& signalIndex);

    bool portIsWire(std::string const& portName) const final;
    
    bool portIsTransactional(std::string const& portName) const final;
    
    std::string getIconPathForSignal(int const& signalIndex) const;

    std::string getIconPathForSignal(std::string const& portName, std::string const& interfaceMode,
        std::string const& systemGroup) const;

    void save();

    bool portHasMode(std::string const& portName, std::string const& interfaceMode, std::string const& systemGroup)
        const;

    QSharedPointer<PortAbstraction> getPort(std::string const& portName) const;

    Document::Revision getRevision() const;
 
    
    int getAllReferencesToIdInRow(int signalIndex, std::string const& itemID) const;

    PortAbstractionInterface(const PortAbstractionInterface& other) = delete;
    PortAbstractionInterface& operator=(const PortAbstractionInterface& other) = delete;
 
private:

    QSharedPointer<NameGroup> getItem(std::string const& portName) const override;

    struct SignalRow
    {
        QSharedPointer<PortAbstraction> abstraction_{ QSharedPointer<PortAbstraction>(new PortAbstraction()) };

        General::InterfaceMode mode_{ General::INTERFACE_MODE_COUNT };

        QSharedPointer<WirePort> wire_{ nullptr };

        QSharedPointer<TransactionalPort> transactional_{ nullptr };

        SignalRow(bool isWirePort, bool isTransactionalPort);

        SignalRow(SignalRow const& other) = default;

        bool operator==(SignalRow const& other) const;

        bool operator!=(SignalRow const& other) const;

        bool operator<(SignalRow const& other) const;
    };
 
    QSharedPointer<SignalRow> getSignal(int const& signalIndex) const;

    QSharedPointer<Protocol> getOrCreateProtocol(int const& signalIndex) const;

    void removeEmptyProtocol(int const& signalIndex, QSharedPointer<Protocol> signalProtocol);

    bool portProcotolTypeIsEmpty(QSharedPointer<Protocol> portProtocol) const;

    QString getProtocolTypeText(QSharedPointer<Protocol> portProtocol) const;
    
    void createWireSignal(QSharedPointer<PortAbstraction> portAbs, QSharedPointer<WirePort> modeSpesific,
        General::InterfaceMode mode);

    void createTransactionalSignal(QSharedPointer<PortAbstraction> portAbs,
        QSharedPointer<TransactionalPort> modeSpesific, General::InterfaceMode mode);

    void savePort(QSharedPointer<PortAbstraction> portAbs, int i);

    bool modeExistsForPort(General::InterfaceMode const& mode, QString const& portName,
        QString const& systemGroup = "") const;

     QSharedPointer<PortAbstractionInterface::SignalRow> constructCopySignal(QSharedPointer<PortAbstraction> port,
         bool isWire, bool isTransactional) const;
    
    DirectionTypes::Direction getMirroredDirectionForSignal(QString const& portName,
        General::InterfaceMode const& opposingMode) const;

    Qualifier::Attribute getQualifierAttributeType(std::string const& attributeName) const;

    int getAllReferencesToIdInItem(const std::string& itemName, std::string const& valueID) const final;
 
    //-----------------------------------------------------------------------------
    // Data.
    //-----------------------------------------------------------------------------
    
    QSharedPointer<QList<QSharedPointer<PortAbstraction> > > ports_;

    QList<QSharedPointer<SignalRow> > signals_;

    Document::Revision abstractionStandardRevision_ = Document::Revision::Unknown;

    QSharedPointer<PortAbstractionValidator> portValidator_ = nullptr;
};
 
#endif // PORTABSTRACTIONINTERFACE_H