PythonAPI.h

Go to the documentation of this file.

//-----------------------------------------------------------------------------
// File: PythonAPI.h
//-----------------------------------------------------------------------------
// Project: Kactus 2
// Author: Mikko Teuho
// Date: 12.02.2020
//
// Description:
// Interface for accessing Kactus2 data using Python.
//-----------------------------------------------------------------------------
 
#ifndef PYTHON_API_H
#define PYTHON_API_H
 
#include "pythonapi_global.h"
 
#include <KactusAPI/KactusAPI.h>
 
#include <string>
#include <vector>
#include <QSharedPointer>
 
#include <KactusAPI/include/ComponentInstanceInterface.h>
#include <KactusAPI/include/InterconnectionInterface.h>
#include <KactusAPI/include/AdHocConnectionInterface.h>
 
#include <KactusAPI/include/BusInterfaceInterface.h>
#include <KactusAPI/include/BusInterfaceInterfaceFactory.h>
#include <KactusAPI/include/ComponentAndInstantiationsParameterFinder.h>
#include <KactusAPI/include/IPXactSystemVerilogParser.h>
#include <KactusAPI/include/ExpressionFormatter.h>
 
#include <KactusAPI/include/PortsInterface.h>
#include <KactusAPI/include/ParametersInterface.h>
 
#include <IPXACTmodels/Component/validators/PortValidator.h>
 
class MessageMediator;
 
class Component;
class Field;
class Register;
class RegisterBase;
class AddressBlock;
class MemoryMap;
class FileSet;
 
class MemoryMapInterface;
class FileSetInterface;
 
class ComponentParameterFinder;
class ExpressionParser;
class PortValidator;
class ExpressionFormatter;
 
class ParameterValidator;
class MemoryMapValidator;
 
class Design;
 
 
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
class PythonAPI
{
public:
    
    enum StdRev
    {
        Std14, // IEEE 1685-2014
        Std22  // IEEE 1685-2022
    };

    PythonAPI();

    ~PythonAPI() = default;
   
    std::string getVersion() const;

    std::vector<std::string> getActiveLibraryPaths() const;

    std::vector<std::string> getAllLibraryPaths() const;
    
    void setLibraryPathActive(std::string const& path, bool isActive);

    void addLibraryPath(std::string const& path, bool isActive = true);

    void removeLibraryPath(std::string const& path);

    PortsInterface* getPortsInterface() const;

    ParametersInterface* getComponentParameterInterface() const;

    MemoryMapInterface* getMapInterface();

    FileSetInterface* getFileSetInterface();

    BusInterfaceInterface* getBusInterface();

    void setupLibrary(std::string const& settingsFileString);

    void setLibraryPaths(std::vector<std::string> const& paths) const;

    std::string getDefaultLibraryPath() const;

    void setDefaultLibraryPath(std::string const& path) const;
    
    int importFile(std::string const& path, std::string const& vlnv, bool overwrite = false) const;

     void generate(std::string const& format, std::string const& vlnv, std::string const& viewName,
        std::string const& outputDirectory) const;
 
     void generateInterconnect();

    int getFileCount() const;

 
    std::vector<std::string> listVLNVs(std::string const& vendor = std::string()) const;

    std::vector<std::string> listComponentVLNVs() const;

    bool vlnvExistsInLibrary(std::string const& vendor, std::string const& library, std::string const& name,
        std::string const& version) const;

    bool createComponent(std::string const& vendor, std::string const& library, std::string const& name,
        std::string const& version, StdRev revision = StdRev::Std22);

    std::string getVLNVDirectory(std::string const& vendor, std::string const& library, std::string const& name,
        std::string const& version) const;

    std::string getFirstViewName() const;

    bool openComponent(std::string const& vlnvString);

    void closeOpenComponent();

 
    std::string getComponentName() const;

 
    std::string getComponentDescription() const;

    std::string getComponentStdRevision() const;

    void saveComponent();
 

    void setBlocksForInterface(std::string const& mapName);

    void setRegistersForInterface(std::string const& mapName, std::string const& blockName);

    void setFieldsForInterface(std::string const& mapName, std::string const& blockName,
        std::string const& registerName);

    void setResetsForInterface(std::string const& mapName, std::string const& blockName,
        std::string const& registerName, std::string const& fieldName);

    void setFilesForInterface(std::string const& setName);

    void setFileBuildersForInterface(std::string const& setName);
        
    bool createDesign(std::string const& vendor, std::string const& library, std::string const& name,
        std::string const& version, StdRev revision = StdRev::Std22);
    
    std::string getDesignStdRevision() const;

    bool openDesign(std::string const& vlnvString);

    void closeOpenDesign();

    void saveDesign();

    bool addComponentInstance(std::string const& vlnvString, std::string const& instanceName);

    bool removeComponentInstance(std::string const& instanceName);

    bool removeInstanceConnections(std::string const& instanceName);

    bool removeInstanceAdHocConnections(std::string const& instanceName);

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

    bool createConnection(std::string const& startInstanceName, std::string const& startBus,
        std::string const& endInstanceName, std::string const& endBus);

    bool createHierarchicalConnection(std::string const& instanceName, std::string const& instanceBus,
        std::string const& topBus);

    bool removeInstanceConnection(std::string const& startInstanceName, std::string const& startBus,
        std::string const& endInstanceName, std::string const& endBus);

    bool removeHierarchicalConnection(std::string const& instanceName, std::string const& instanceBus,
        std::string const& topBus);

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

    bool createAdHocConnection(std::string const& startInstanceName, std::string const& startPort,
        std::string const& endInstanceName, std::string const& endPort);

    bool createHierarchicalAdHocConnection(std::string const& instanceName, std::string const& instancePort,
        std::string const& topPort);

    bool removeInstanceAdHocConnection(std::string const& startInstanceName, std::string const& startPort,
        std::string const& endInstanceName, std::string const& endPort);

    bool removeHierarchicalAdHocConnection(std::string const& instanceName, std::string const& instancePort,
        std::string const& topPort);

    bool renameAdHocConnection(std::string const& currentName, std::string const& newName);
 
private:

    bool connectionEndsCheck(QString const& startInstanceName, QString const& startBus,
        QString const& endInstanceName, QString const& endBus, bool isAdHocConnection);

    bool instanceExists(QString const& instanceName) const;

    bool endsCheckForAdHoc(QSharedPointer<const Component> startComponent, QString const& startBus,
        QString const& startInstanceName, QSharedPointer<const Component> endComponent, QString const& endBus,
        QString const& endInstanceName);

    bool endsCheckForInterconnection(QSharedPointer<const Component> startComponent, QString const& startBus,
        QString const& startInstanceName, QSharedPointer<const Component> endComponent, QString const& endBus,
        QString const& endInstanceName);

    bool removeConnection(std::string const& connectionName);

    bool removeAdHocConnection(std::string const& connectionName);

    QSharedPointer<Document> getDocument(QString const& vlnvString) const;

    void constructMemoryValidators();

    void constructMemoryInterface();

    void constructFileSetInterface();

    QSharedPointer<MemoryMap> getMemoryMap(QString const& mapName) const;

    QSharedPointer<AddressBlock> getAddressBock(QSharedPointer<MemoryMap> containingMap, QString const& blockName)
        const;

    QSharedPointer<Register> getRegister(QSharedPointer<AddressBlock> containingBlock, QString const& registerName)
        const;

    QSharedPointer<Field> getField(QSharedPointer<Register> containingRegister, QString const& fieldName) const;

    QSharedPointer<FileSet> getFileSet(QString const& setName) const;

    void sendMemoryMapNotFoundError(QString const& mapName) const;

    void sendAddressBlockNotFoundError(QString const& mapName, QString const& blockName) const;

    void sendRegisterNotFoundError(QString const& mapName, QString const& blockName, QString const& registerName)
        const;

    void sendFieldNotFoundError(QString const& mapName, QString const& blockName, QString const& registerName,
        QString const& fieldName) const;

    void sendFileSetNotFoundError(QString const& setName) const;
 
    //-----------------------------------------------------------------------------
    // Data.
    //-----------------------------------------------------------------------------

    LibraryInterface* library_{ KactusAPI::getLibrary() };

    MessageMediator* messager_{ KactusAPI::getMessageChannel() };

    QSharedPointer<ComponentParameterFinder> parameterFinder_{ new ComponentAndInstantiationsParameterFinder(nullptr) };

    QSharedPointer<ExpressionParser> expressionParser_{ new IPXactSystemVerilogParser(parameterFinder_) };

    QSharedPointer<ExpressionFormatter>expressionFormatter_{ new ExpressionFormatter(parameterFinder_) };

    QSharedPointer<Component> activeComponent_{ nullptr };

    QSharedPointer<Design> activeDesign_{ nullptr };

    QSharedPointer<PortValidator> portValidator_{ new PortValidator(expressionParser_,
        QSharedPointer<QList<QSharedPointer<View> > >()) };

    QSharedPointer<ParameterValidator> parameterValidator_{ new ParameterValidator(expressionParser_,
        QSharedPointer<QList<QSharedPointer<Choice> > >(), Document::Revision::Std22) };

    QSharedPointer<MemoryMapValidator> mapValidator_{ nullptr };

    PortsInterface* portsInterface_{ new PortsInterface(portValidator_, expressionParser_, expressionFormatter_) };

    BusInterfaceInterface* busInterface_{ BusInterfaceInterfaceFactory::createBusInterface(parameterFinder_,
        expressionFormatter_, expressionParser_,
        QSharedPointer<Component>(new Component(VLNV(), Document::Revision::Unknown)), library_) };

    ParametersInterface* componentParameterInterface_{ new ParametersInterface(parameterValidator_, 
        expressionParser_, expressionFormatter_) };

    MemoryMapInterface* mapInterface_{ nullptr };

    FileSetInterface* fileSetInterface_{ nullptr };

    InterconnectionInterface* connectionInterface_{ new InterconnectionInterface() };

    AdHocConnectionInterface* adhocConnectionInterface_{ new AdHocConnectionInterface() };

    ComponentInstanceInterface* instanceInterface_{ new ComponentInstanceInterface(connectionInterface_, 
        adhocConnectionInterface_) };
 
};
 
#endif // !PYTHON_API_H