#include <IPXactModel.hh>

Inheritance diagram for IPXactModel:

Collaboration diagram for IPXactModel:

Public Types
enum	BusMode { INVALID , MASTER , MIRRORED_MASTER , SLAVE , MIRRORED_SLAVE , SYSTEM , MIRRORED_SYSTEM , MONITOR }

Public Member Functions
	IPXactModel ()

	IPXactModel (const ObjectState *state)

virtual	~IPXactModel ()

virtual void	loadState (const ObjectState *state)

virtual ObjectState *	saveState () const

void	setVLNV (TCEString vendor, TCEString library, TCEString name, TCEString version)

void	setHdlFile (const TCEString &file)

void	setFile (const TCEString &file)

void	setHdlFiles (const std::vector< TCEString > &files)

void	addSignal (const HDLPort &signal)

void	addParameter (const ProGe::Parameter &parameter)

void	addBusInterface (IPXactInterface *interface)

void	addAddressSpace (IPXactAddressSpace *addrSpace)

Public Member Functions inherited from Serializable
virtual	~Serializable ()

Static Public Attributes
static const TCEString	OSNAME_IPXACT_MODEL = "spirit:component"

static const TCEString	OSNAME_VENDOR = "spirit:vendor"

static const TCEString	OSNAME_LIBRARY = "spirit:library"

static const TCEString	OSNAME_NAME = "spirit:name"

static const TCEString	OSNAME_VERSION = "spirit:version"

static const TCEString	OSNAME_BUS_INTERFACES = "spirit:busInterfaces"

static const TCEString	OSNAME_BUS_INTERFACE = "spirit:busInterface"

static const TCEString	OSNAME_BUS_TYPE = "spirit:busType"

static const TCEString	OSNAME_BUS_ABS_TYPE = "spirit:abstractionType"

static const TCEString	OSNAME_BUS_MASTER = "spirit:master"

static const TCEString	OSNAME_BUS_MIRRORED_MASTER

static const TCEString	OSNAME_BUS_SLAVE = "spirit:slave"

static const TCEString	OSNAME_BUS_MIRRORED_SLAVE

static const TCEString	OSNAME_BUS_SYSTEM = "spirit:system"

static const TCEString	OSNAME_BUS_MIRRORED_SYSTEM

static const TCEString	OSNAME_BUS_MONITOR = "spirit:monitor"

static const TCEString	OSNAME_BUS_PORT_MAPS = "spirit:portMaps"

static const TCEString	OSNAME_BUS_PORT_MAP = "spirit:portMap"

static const TCEString	OSNAME_BUS_PORT_MAP_NAME = "spirit:name"

static const TCEString	OSNAME_BUS_PORT_MAP_COMP

static const TCEString	OSNAME_BUS_PORT_MAP_BUS

static const TCEString	OSNAME_MODEL = "spirit:model"

static const TCEString	OSNAME_PORTS = "spirit:ports"

static const TCEString	OSNAME_WIRE = "spirit:wire"

static const TCEString	OSNAME_VECTOR = "spirit:vector"

static const TCEString	OSNAME_PORT = "spirit:port"

static const TCEString	OSNAME_PORT_DIRECTION = "spirit:direction"

static const TCEString	OSNAME_PORT_LEFT = "spirit:left"

static const TCEString	OSNAME_PORT_RIGHT = "spirit:right"

static const TCEString	OSNAME_FILESETS = "spirit:fileSets"

static const TCEString	OSNAME_FILESET = "spirit:fileSet"

static const TCEString	OSNAME_FILE = "spirit:file"

static const TCEString	OSNAME_FILE_NAME = "spirit:name"

static const TCEString	OSNAME_FILE_TYPE = "spirit:fileType"

static const std::string	OSNAME_ADDRESS_SPACES = "spirit:addressSpaces"

static const std::string	OSNAME_ADDRESS_SPACE = "spirit:addressSpace"

static const std::string	OSNAME_AS_RANGE = "spirit:range"

static const std::string	OSNAME_AS_WIDTH = "spirit:width"

static const std::string	OSNAME_AS_MAU = "spirit:addressUnitBits"

static const TCEString	OSNAME_MODEL_PARAMS = "spirit:modelParameters"

static const TCEString	OSNAME_MODEL_PARAM = "spirit:modelParameter"

static const TCEString	OSNAME_DISPLAY_NAME = "spirit:displayName"

static const TCEString	OSNAME_VALUE = "spirit:value"

static const TCEString	OSNAME_ATTR_DATA_TYPE = "spirit:dataType"

static const TCEString	OSNAME_ATTR_FORMAT = "spirit:format"

static const TCEString	OSNAME_ATTR_ID = "spirit:id"

static const TCEString	OSNAME_ATTR_RESOLVE = "spirit:resolve"

Private Member Functions
	IPXactModel (const IPXactModel &old)

void	addBusInterfaceObject (const IPXactInterface bus, ObjectState parent) const

void	addAddressSpaceObject (const IPXactAddressSpace as, ObjectState parent) const

void	addSignalObject (const HDLPort port, ObjectState parent) const

void	addModelParamsObject (ObjectState *parent) const

void	addFileObject (const TCEString &name, const TCEString &type, ObjectState *parent) const

void	extractVLNV (const ObjectState *root)

IPXact::Vlnv	extractVlnvFromAttr (const ObjectState *busType) const

void	extractBusInterfaces (const ObjectState *busInterfaces)

void	extractBusInterface (const ObjectState *busInterface)

void	extractAddressSpaces (const ObjectState *addressSpaces)

void	extractAddressSpace (const ObjectState *as)

BusMode	extractBusMode (const ObjectState *busInterface) const

void	extractPortMappings (const ObjectState *portMaps, IPXactInterface &interface) const

void	extractPortMap (const ObjectState *portMap, IPXactInterface &interface) const

void	extractSignals (const ObjectState *signals)

void	extractModelParams (const ObjectState *modelParameters)

void	extractModelParam (const ObjectState *modelParameter)

void	extractFiles (const ObjectState *fileSets)

IPXactInterface *	interfaceByType (const IPXact::Vlnv &type, const IPXact::Vlnv &absType, const TCEString instanceName, BusMode mode) const

Private Attributes
IPXact::Vlnv	vlnv_

std::vector< HDLPort * >	signals_

std::vector< ProGe::Parameter >	parameters_

std::vector< IPXactInterface * >	busInterfaces_

std::vector< IPXactAddressSpace * >	addressSpaces_

std::vector< TCEString >	hdlFiles_

std::vector< TCEString >	otherFiles_

Static Private Attributes
static const TCEString	HDL_SET_ID = "hdlSources"

static const TCEString	VHDL_FILE = "vhdlSource"

static const TCEString	OTHER_FILE = "unknown"

static const TCEString	RESOLVE_USER = "user"

static const TCEString	STRING_PARAM = "string"

static const TCEString	INTEGER_PARAM = "integer"

static const TCEString	LONG_PARAM = "long"

static const TCEString	DEV_FAMILY_GENERIC = "dev_family_g"

Detailed Description

Definition at line 47 of file IPXactModel.hh.

Member Enumeration Documentation

◆ BusMode

enum IPXactModel::BusMode

Enumerator
INVALID
MASTER
MIRRORED_MASTER
SLAVE
MIRRORED_SLAVE
SYSTEM
MIRRORED_SYSTEM
MONITOR

Definition at line 50 of file IPXactModel.hh.

                 {
        INVALID,
        MASTER,
        MIRRORED_MASTER,
        SLAVE,
        MIRRORED_SLAVE,
        SYSTEM,
        MIRRORED_SYSTEM,
        MONITOR
    };

Constructor & Destructor Documentation

◆ IPXactModel() [1/3]

IPXactModel::IPXactModel ( )

Definition at line 110 of file IPXactModel.cc.

                        : 
    vlnv_("","","",""), signals_(), parameters_(), busInterfaces_(),
    addressSpaces_(),  hdlFiles_(), otherFiles_() {
}

◆ IPXactModel() [2/3]

IPXactModel::IPXactModel ( const ObjectState * state )

Definition at line 115 of file IPXactModel.cc.

    : vlnv_("", "", "", ""),
      signals_(),
      parameters_(),
      busInterfaces_(),
      addressSpaces_(),
      hdlFiles_(),
      otherFiles_() {
    loadState(state);
}

References loadState().

Here is the call graph for this function:

◆ ~IPXactModel()

IPXactModel::~IPXactModel ( )

virtual

Definition at line 126 of file IPXactModel.cc.

                          {
 
    for (unsigned int i = 0; i < signals_.size(); i++) {
        delete signals_.at(i);
    }
    for (unsigned int i = 0; i < busInterfaces_.size(); i++) {
        if (busInterfaces_.at(i) != NULL) {
            delete busInterfaces_.at(i);
        }
    }
    for (unsigned int i = 0; i < addressSpaces_.size(); i++) {
        if (addressSpaces_.at(i) != NULL) {
            delete addressSpaces_.at(i);
        }
    }
}

References addressSpaces_, busInterfaces_, and signals_.

◆ IPXactModel() [3/3]

IPXactModel::IPXactModel ( const IPXactModel & old )

private

Member Function Documentation

◆ addAddressSpace()

void IPXactModel::addAddressSpace ( IPXactAddressSpace * addrSpace )

Definition at line 307 of file IPXactModel.cc.

                                                          {
 
    addressSpaces_.push_back(addrSpace);
}

References addressSpaces_.

Referenced by IPXactFileGenerator::addAddressSpaces().

◆ addAddressSpaceObject()

void IPXactModel::addAddressSpaceObject	(	const IPXactAddressSpace *	as,
		ObjectState *	parent
	)		const

private

Definition at line 381 of file IPXactModel.cc.

                               {
    
    ObjectState* name = new ObjectState(OSNAME_NAME);
    name->setValue(as->name());
    parent->addChild(name);
    
    ObjectState* range = new ObjectState(OSNAME_AS_RANGE);
    range->setValue(as->memRange());
    parent->addChild(range);
    
    ObjectState* width = new ObjectState(OSNAME_AS_WIDTH);
    width->setValue(as->memLocationWidth());
    parent->addChild(width);
    
    if (as->mauWidth() > 0) {
        ObjectState* mau = new ObjectState(OSNAME_AS_MAU);
        mau->setValue(as->mauWidth());
        parent->addChild(mau);
    }
}

References ObjectState::addChild(), IPXactAddressSpace::mauWidth(), IPXactAddressSpace::memLocationWidth(), IPXactAddressSpace::memRange(), IPXactAddressSpace::name(), OSNAME_AS_MAU, OSNAME_AS_RANGE, OSNAME_AS_WIDTH, OSNAME_NAME, and ObjectState::setValue().

Referenced by saveState().

Here is the call graph for this function:

◆ addBusInterface()

void IPXactModel::addBusInterface ( IPXactInterface * interface )

Definition at line 301 of file IPXactModel.cc.

                                                       {
    
    busInterfaces_.push_back(interface);
}

References busInterfaces_.

Referenced by IPXactFileGenerator::addBusInterfaces().

◆ addBusInterfaceObject()

void IPXactModel::addBusInterfaceObject	(	const IPXactInterface *	bus,
		ObjectState *	parent
	)		const

private

Definition at line 314 of file IPXactModel.cc.

                               {
 
    ObjectState* busName = new ObjectState(OSNAME_NAME);
    busName->setValue(bus->instanceName());
    parent->addChild(busName);
    
    Vlnv busIfType = bus->busType();
    ObjectState* busType = new ObjectState(OSNAME_BUS_TYPE);
    busType->setAttribute(OSNAME_VENDOR, busIfType.vendor);
    busType->setAttribute(OSNAME_LIBRARY, busIfType.library);
    busType->setAttribute(OSNAME_NAME, busIfType.name);
    busType->setAttribute(OSNAME_VERSION, busIfType.version);
    parent->addChild(busType);
    
    Vlnv absType = bus->busAbstractionType();
    ObjectState* busAbsType = new ObjectState(OSNAME_BUS_ABS_TYPE);
    busAbsType->setAttribute(OSNAME_VENDOR, absType.vendor);
    busAbsType->setAttribute(OSNAME_LIBRARY, absType.library);
    busAbsType->setAttribute(OSNAME_NAME, absType.name);
    busAbsType->setAttribute(OSNAME_VERSION, absType.version);
    parent->addChild(busAbsType);
    
    ObjectState* mode = NULL;
    BusMode busMode = bus->busMode();
    if (busMode == MASTER) {
        mode = new ObjectState(OSNAME_BUS_MASTER);
    } else if (busMode == MIRRORED_MASTER) {
        mode = new ObjectState(OSNAME_BUS_MIRRORED_MASTER);
    } else if (busMode == SLAVE) {
        mode = new ObjectState(OSNAME_BUS_SLAVE);
    } else if (busMode == MIRRORED_SLAVE) {
        mode = new ObjectState(OSNAME_BUS_MIRRORED_SLAVE);
    } else {
        TCEString msg = "Unknown bus mode!";
        InvalidData exc(__FILE__, __LINE__, "IPXactModel", msg);
        throw exc;
    }
    parent->addChild(mode);
    
    ObjectState* portMaps = new ObjectState(OSNAME_BUS_PORT_MAPS);
    parent->addChild(portMaps);
 
    const SignalMappingList& signalMap = bus->interfaceMapping();
    for (unsigned int i = 0; i < signalMap.size(); i++) {
        ObjectState* portMapping = new ObjectState(OSNAME_BUS_PORT_MAP);
        portMaps->addChild(portMapping);
 
        ObjectState* compPort = new ObjectState(OSNAME_BUS_PORT_MAP_COMP);
        ObjectState* compPortName = new ObjectState(OSNAME_BUS_PORT_MAP_NAME);
        compPortName->setValue(signalMap.at(i)->first);
        compPort->addChild(compPortName);
 
        ObjectState* busPort = new ObjectState(OSNAME_BUS_PORT_MAP_BUS);
        ObjectState* busPortName = new ObjectState(OSNAME_BUS_PORT_MAP_NAME);
        busPortName->setValue(signalMap.at(i)->second);
        busPort->addChild(busPortName);
 
        // in IP-XACT 1.5 bus logical port comes before physical port
        portMapping->addChild(busPort);
        portMapping->addChild(compPort);
    }
}

References ObjectState::addChild(), IPXactInterface::busAbstractionType(), IPXactInterface::busMode(), IPXactInterface::busType(), IPXactInterface::instanceName(), IPXactInterface::interfaceMapping(), IPXact::Vlnv::library, MASTER, MIRRORED_MASTER, MIRRORED_SLAVE, IPXact::Vlnv::name, OSNAME_BUS_ABS_TYPE, OSNAME_BUS_MASTER, OSNAME_BUS_MIRRORED_MASTER, OSNAME_BUS_MIRRORED_SLAVE, OSNAME_BUS_PORT_MAP, OSNAME_BUS_PORT_MAP_BUS, OSNAME_BUS_PORT_MAP_COMP, OSNAME_BUS_PORT_MAP_NAME, OSNAME_BUS_PORT_MAPS, OSNAME_BUS_SLAVE, OSNAME_BUS_TYPE, OSNAME_LIBRARY, OSNAME_NAME, OSNAME_VENDOR, OSNAME_VERSION, ObjectState::setAttribute(), ObjectState::setValue(), SLAVE, IPXact::Vlnv::vendor, and IPXact::Vlnv::version.

Referenced by saveState().

Here is the call graph for this function:

◆ addFileObject()

void IPXactModel::addFileObject	(	const TCEString &	name,
		const TCEString &	type,
		ObjectState *	parent
	)		const

private

Definition at line 503 of file IPXactModel.cc.

                               {
 
    ObjectState* fileName = new ObjectState(OSNAME_FILE_NAME);
    fileName->setValue(name);
    parent->addChild(fileName);
    ObjectState* fileType = new ObjectState(OSNAME_FILE_TYPE);
    fileType->setValue(type);
    parent->addChild(fileType);
}

References ObjectState::addChild(), OSNAME_FILE_NAME, OSNAME_FILE_TYPE, and ObjectState::setValue().

Referenced by saveState().

Here is the call graph for this function:

◆ addModelParamsObject()

void IPXactModel::addModelParamsObject ( ObjectState * parent ) const

private

Definition at line 461 of file IPXactModel.cc.

                                                           {
 
    ObjectState* params = new ObjectState(OSNAME_MODEL_PARAMS);
    parent->addChild(params);
    for (unsigned int i = 0; i < parameters_.size(); i++) {
        ObjectState* param= new ObjectState(OSNAME_MODEL_PARAM);
        if (parameters_.at(i).type().lower() == STRING_PARAM) {
            param->setAttribute(OSNAME_ATTR_DATA_TYPE, STRING_PARAM);
        } else if (parameters_.at(i).type().lower() == INTEGER_PARAM) {
            param->setAttribute(OSNAME_ATTR_DATA_TYPE, LONG_PARAM);
        } else {
            // unsuppored type, ignore
            delete param;
            continue;
        }
        params->addChild(param);
 
        ObjectState* name = new ObjectState(OSNAME_NAME);
        name->setValue(parameters_.at(i).name());
        param->addChild(name);
 
        ObjectState* displayName =  new ObjectState(OSNAME_DISPLAY_NAME);
        displayName->setValue(parameters_.at(i).name());
        param->addChild(displayName);
 
        ObjectState* value = new ObjectState(OSNAME_VALUE);
        if (parameters_.at(i).type().lower() == STRING_PARAM) {
            value->setAttribute(OSNAME_ATTR_FORMAT, STRING_PARAM);
        } else if (parameters_.at(i).type().lower() == INTEGER_PARAM) {
            value->setAttribute(OSNAME_ATTR_FORMAT, LONG_PARAM);
        }
        TCEString id;
        id << parameters_.at(i).name().upper() << "_ID";
        value->setAttribute(OSNAME_ATTR_ID, id);
        value->setAttribute(OSNAME_ATTR_RESOLVE, RESOLVE_USER);
        value->setValue(parameters_.at(i).value());
        param->addChild(value);
    }
}

References ObjectState::addChild(), INTEGER_PARAM, LONG_PARAM, OSNAME_ATTR_DATA_TYPE, OSNAME_ATTR_FORMAT, OSNAME_ATTR_ID, OSNAME_ATTR_RESOLVE, OSNAME_DISPLAY_NAME, OSNAME_MODEL_PARAM, OSNAME_MODEL_PARAMS, OSNAME_NAME, OSNAME_VALUE, parameters_, RESOLVE_USER, ObjectState::setAttribute(), ObjectState::setValue(), STRING_PARAM, and TCEString::upper().

Referenced by saveState().

Here is the call graph for this function:

◆ addParameter()

void IPXactModel::addParameter ( const ProGe::Parameter & parameter )

Definition at line 296 of file IPXactModel.cc.

                                                         {
    parameters_.push_back(parameter);
}

References parameters_.

Referenced by IPXactFileGenerator::writeProjectFiles().

◆ addSignal()

void IPXactModel::addSignal ( const HDLPort & signal )

Definition at line 290 of file IPXactModel.cc.

                                            {
 
    signals_.push_back(new HDLPort(signal));
}

References signals_.

Referenced by IPXactFileGenerator::writeProjectFiles().

◆ addSignalObject()

void IPXactModel::addSignalObject	(	const HDLPort *	port,
		ObjectState *	parent
	)		const

private

Definition at line 406 of file IPXactModel.cc.

                                                    {
 
    ObjectState* name = new ObjectState(OSNAME_NAME);
    name->setValue(port->name());
    parent->addChild(name);
 
    ObjectState* wire = new ObjectState(OSNAME_WIRE);
    parent->addChild(wire);
 
    ObjectState* direction = new ObjectState(OSNAME_PORT_DIRECTION);
    TCEString dir = "";
    if (port->direction() == ProGe::IN) {
        dir = "in";
    } else if (port->direction() == ProGe::OUT) {
        dir = "out";
    } else if (port->direction() == ProGe::BIDIR) {
        dir = "inout";
    } else {
        assert(false && "unknown direction");
    }
    direction->setValue(dir);
    wire->addChild(direction);
    
    ObjectState* vector = NULL;
    if (port->type() == ProGe::BIT_VECTOR) {
        int leftBorder = 0;
        int rightBorder = 0;
        vector = new ObjectState(OSNAME_VECTOR);
        if (port->hasRealWidth()) {
            int width = port->realWidth();
            if (width > 1) {
                leftBorder = width-1;
            }
        } else {
            // width is unknown, guessing 1
            leftBorder = 0;
        }
        ObjectState* left = new ObjectState(OSNAME_PORT_LEFT);
        left->setValue(leftBorder);
        vector->addChild(left);
        ObjectState* right = new ObjectState(OSNAME_PORT_RIGHT);
        right->setValue(rightBorder);
        vector->addChild(right);
    } else if (port->type() != ProGe::BIT) {
        assert(false && "unknown port type");
    }
 
    if (vector != NULL) {
        wire->addChild(vector);
    }
}

References ObjectState::addChild(), assert, ProGe::BIDIR, ProGe::BIT, ProGe::BIT_VECTOR, HDLPort::direction(), HDLPort::hasRealWidth(), ProGe::IN, HDLPort::name(), OSNAME_NAME, OSNAME_PORT_DIRECTION, OSNAME_PORT_LEFT, OSNAME_PORT_RIGHT, OSNAME_VECTOR, OSNAME_WIRE, ProGe::OUT, HDLPort::realWidth(), ObjectState::setValue(), and HDLPort::type().

Referenced by saveState().

Here is the call graph for this function:

◆ extractAddressSpace()

void IPXactModel::extractAddressSpace ( const ObjectState * as )

private

Definition at line 649 of file IPXactModel.cc.

                                                      {
 
    assert(as->name() == OSNAME_ADDRESS_SPACE);
    TCEString errorMsg = "Address space has no ";
    if (!as->hasChild(OSNAME_NAME)) {
        errorMsg << "name.";
        ObjectStateLoadingException* exc = 
            new ObjectStateLoadingException(
                __FILE__, __LINE__, "IPXactModel", errorMsg);
       throw exc;
    } else if (!as->hasChild(OSNAME_AS_RANGE)) {
        errorMsg << "range.";
        ObjectStateLoadingException* exc = 
            new ObjectStateLoadingException(
                __FILE__, __LINE__, "IPXactModel", errorMsg);
        throw exc;
    } else if (!as->hasChild(OSNAME_AS_WIDTH)) {
        errorMsg << "width.";
        ObjectStateLoadingException* exc = 
            new ObjectStateLoadingException(
                __FILE__, __LINE__, "IPXactModel", errorMsg);
        throw exc;
    }
    TCEString name = as->childByName(OSNAME_NAME)->stringValue();
    int range = as->childByName(OSNAME_AS_RANGE)->intValue();
    int width = as->childByName(OSNAME_AS_WIDTH)->intValue();
    int mau = 0;
    if (as->hasChild(OSNAME_AS_MAU)) {
        mau = as->childByName(OSNAME_AS_WIDTH)->intValue();
    }
    IPXactAddressSpace* ipXactAs = 
        new IPXactAddressSpace(name, range, width, mau);
    addressSpaces_.push_back(ipXactAs);
}

References addressSpaces_, assert, ObjectState::childByName(), ObjectState::hasChild(), ObjectState::intValue(), ObjectState::name(), OSNAME_ADDRESS_SPACE, OSNAME_AS_MAU, OSNAME_AS_RANGE, OSNAME_AS_WIDTH, OSNAME_NAME, and ObjectState::stringValue().

Referenced by extractAddressSpaces().

Here is the call graph for this function:

◆ extractAddressSpaces()

void IPXactModel::extractAddressSpaces ( const ObjectState * addressSpaces )

private

Definition at line 633 of file IPXactModel.cc.

                                                                  {
    
    assert(addressSpaces->name() == OSNAME_ADDRESS_SPACES);
    if (!addressSpaces->hasChild(OSNAME_ADDRESS_SPACE)) {
        return;
    }
    for (int i = 0; i < addressSpaces->childCount(); i++) {
        const ObjectState* as = addressSpaces->child(i);
        if (as->name() == OSNAME_ADDRESS_SPACE) {
            extractAddressSpace(as);
        }
    }
}

References assert, ObjectState::child(), ObjectState::childCount(), extractAddressSpace(), ObjectState::hasChild(), ObjectState::name(), OSNAME_ADDRESS_SPACE, and OSNAME_ADDRESS_SPACES.

Referenced by loadState().

Here is the call graph for this function:

◆ extractBusInterface()

void IPXactModel::extractBusInterface ( const ObjectState * busInterface )

private

Definition at line 578 of file IPXactModel.cc.

                                                                {
 
    assert(busInterface->name() == OSNAME_BUS_INTERFACE);
    if (!busInterface->hasChild(OSNAME_NAME)) {
        TCEString msg = "Bus has no name";
        ObjectStateLoadingException* exc = 
            new ObjectStateLoadingException(__FILE__, __LINE__,
                                            "IPXactModel", msg);
        throw exc;
    }
    if (!busInterface->hasChild(OSNAME_BUS_TYPE)) {
        TCEString msg = "Bus has no type";
        ObjectStateLoadingException* exc = 
            new ObjectStateLoadingException(__FILE__, __LINE__,
                                            "IPXactModel", msg);
        throw exc;
    }
    if (!busInterface->hasChild(OSNAME_BUS_ABS_TYPE)) {
        TCEString msg = "Bus has no abstraction type";
        ObjectStateLoadingException* exc = 
            new ObjectStateLoadingException(__FILE__, __LINE__, 
                                            "IPXactModel", msg);
        throw exc;
    }
    
    TCEString instanceName =
        busInterface->childByName(OSNAME_NAME)->stringValue();
    const ObjectState* busType =
        busInterface->childByName(OSNAME_BUS_TYPE);
    const ObjectState* busAbsType = busInterface->childByName(
        OSNAME_BUS_ABS_TYPE);
    IPXact::Vlnv type = extractVlnvFromAttr(busType);
    IPXact::Vlnv absType = extractVlnvFromAttr(busAbsType);
    BusMode mode = extractBusMode(busInterface);
    
    IPXactInterface* interface =
        interfaceByType(type, absType, instanceName, mode);
    if (!interface) {
        TCEString msg = "Unknown bus type";
        ObjectStateLoadingException* exc = 
            new ObjectStateLoadingException(__FILE__, __LINE__,
                                            "IPXactModel", msg);
        throw exc;
    }
 
    if (busInterface->hasChild(OSNAME_BUS_PORT_MAPS)) {
        const ObjectState* portMaps = 
            busInterface->childByName(OSNAME_BUS_PORT_MAPS);
        extractPortMappings(portMaps, *interface);
    }
    busInterfaces_.push_back(interface);
}

References assert, busInterfaces_, ObjectState::childByName(), extractBusMode(), extractPortMappings(), extractVlnvFromAttr(), ObjectState::hasChild(), interfaceByType(), ObjectState::name(), OSNAME_BUS_ABS_TYPE, OSNAME_BUS_INTERFACE, OSNAME_BUS_PORT_MAPS, OSNAME_BUS_TYPE, OSNAME_NAME, and ObjectState::stringValue().

Referenced by extractBusInterfaces().

Here is the call graph for this function:

◆ extractBusInterfaces()

void IPXactModel::extractBusInterfaces ( const ObjectState * busInterfaces )

private

Definition at line 562 of file IPXactModel.cc.

                                                                  {
 
    assert(busInterfaces->name() == OSNAME_BUS_INTERFACES);
    if (!busInterfaces->hasChild(OSNAME_BUS_INTERFACE)) {
        return;
    }
    for (int i = 0; i < busInterfaces->childCount(); i++) {
        const ObjectState* bus = busInterfaces->child(i);
         if (bus->name() == OSNAME_BUS_INTERFACE) {
            extractBusInterface(bus);
        }
    }
}

References assert, ObjectState::child(), ObjectState::childCount(), extractBusInterface(), ObjectState::hasChild(), ObjectState::name(), OSNAME_BUS_INTERFACE, and OSNAME_BUS_INTERFACES.

Referenced by loadState().

Here is the call graph for this function:

◆ extractBusMode()

IPXactModel::BusMode IPXactModel::extractBusMode ( const ObjectState * busInterface ) const

private

Definition at line 686 of file IPXactModel.cc.

                                                                 {
 
    assert(busInterface->name() == OSNAME_BUS_INTERFACE);
    BusMode mode = INVALID;
    if (busInterface->hasChild(OSNAME_BUS_MASTER)) {
        mode = MASTER;
    } else if (busInterface->hasChild(OSNAME_BUS_MIRRORED_MASTER)) {
        mode = MIRRORED_MASTER;
    } else if (busInterface->hasChild(OSNAME_BUS_SLAVE)) {
        mode = SLAVE;
    } else if (busInterface->hasChild(OSNAME_BUS_MIRRORED_SLAVE)) {
        mode = MIRRORED_SLAVE;
    } else if (busInterface->hasChild(OSNAME_BUS_SYSTEM)) {
        mode = SYSTEM;
    } else if (busInterface->hasChild(OSNAME_BUS_MIRRORED_SYSTEM)) {
        mode = MIRRORED_SYSTEM;
    } else if (busInterface->hasChild(OSNAME_BUS_MONITOR)) {
        mode = MONITOR;
    } else {
        assert(false && "Unknown bus mode!");
    }
    assert(mode != INVALID && "Bus mode is invalid");
    return mode;
}

References assert, ObjectState::hasChild(), INVALID, MASTER, MIRRORED_MASTER, MIRRORED_SLAVE, MIRRORED_SYSTEM, MONITOR, ObjectState::name(), OSNAME_BUS_INTERFACE, OSNAME_BUS_MASTER, OSNAME_BUS_MIRRORED_MASTER, OSNAME_BUS_MIRRORED_SLAVE, OSNAME_BUS_MIRRORED_SYSTEM, OSNAME_BUS_MONITOR, OSNAME_BUS_SLAVE, OSNAME_BUS_SYSTEM, SLAVE, and SYSTEM.

Referenced by extractBusInterface().

Here is the call graph for this function:

◆ extractFiles()

void IPXactModel::extractFiles ( const ObjectState * fileSets )

private

Definition at line 851 of file IPXactModel.cc.

                                                     {
 
    assert(fileSets->name() == OSNAME_FILESETS);
    for (int i = 0; i < fileSets->childCount(); i++) {
        const ObjectState* fs = fileSets->child(i);
        if (fs->name() != OSNAME_FILESET) {
            continue;
        }
        if (!fs->hasChild(OSNAME_FILE_NAME)) {
            TCEString msg = "Fileset has no name!";
            InvalidData exc(__FILE__, __LINE__, "IPXactModel", msg);
            throw exc;
        }
        TCEString fsName = fs->childByName(OSNAME_FILE_NAME)->stringValue();
        if (fsName != HDL_SET_ID) {
            // unknown stuff, ignore
            continue;
        }
 
        for (int j = 0; j < fs->childCount(); j++) {
            const ObjectState* file = fs->child(j);
            if (file->name() != OSNAME_FILE) {
                continue;
            }
            TCEString fileName = "";
            TCEString fileType = "";
            if (file->hasChild(OSNAME_NAME)) {
                fileName = file->childByName(OSNAME_NAME)->stringValue();
            }
            if (file->hasChild(OSNAME_FILE_TYPE)) {
                fileType = file->childByName(OSNAME_FILE_TYPE)->stringValue();
            }
 
            if (fileType == VHDL_FILE) {
                hdlFiles_.push_back(fileName);
            } else if (fileType == OTHER_FILE) {
                otherFiles_.push_back(fileName);
            } else {
                // unknown file type, ignore
                continue;
            }
        }
    }
}

References assert, ObjectState::child(), ObjectState::childByName(), ObjectState::childCount(), ObjectState::hasChild(), HDL_SET_ID, hdlFiles_, ObjectState::name(), OSNAME_FILE, OSNAME_FILE_NAME, OSNAME_FILE_TYPE, OSNAME_FILESET, OSNAME_FILESETS, OSNAME_NAME, OTHER_FILE, otherFiles_, ObjectState::stringValue(), and VHDL_FILE.

Referenced by loadState().

Here is the call graph for this function:

◆ extractModelParam()

void IPXactModel::extractModelParam ( const ObjectState * modelParameter )

private

Definition at line 942 of file IPXactModel.cc.

                                                                {
    
    assert(modelParameter->name() == OSNAME_MODEL_PARAM);
    if (!modelParameter->hasChild(OSNAME_NAME)) {
        TCEString msg = "Model parameter has no name";
        ObjectStateLoadingException* exc = 
            new ObjectStateLoadingException(__FILE__, __LINE__,
                                            "IPXactModel", msg);
        throw exc;
    }
    if (!modelParameter->hasChild(OSNAME_VALUE)) {
        TCEString msg = "Model parameter has no value";
        ObjectStateLoadingException* exc = 
            new ObjectStateLoadingException(__FILE__, __LINE__,
                                            "IPXactModel", msg);
        throw exc;
    }
    ProGe::Parameter parameter;
    const ObjectState* nameObj = modelParameter->childByName(OSNAME_NAME);
    parameter.setName(nameObj->stringValue());
 
    parameter.setType(STRING_PARAM);
    if (nameObj->hasAttribute(OSNAME_ATTR_DATA_TYPE)) {
        TCEString typeAttr =
            nameObj->stringAttribute(OSNAME_ATTR_DATA_TYPE);
        if (typeAttr.lower() == STRING_PARAM) {
            parameter.setType(STRING_PARAM);
        } else if (typeAttr.lower() == LONG_PARAM) {
            parameter.setType(INTEGER_PARAM);
        }
    }
    
    const ObjectState* valueObj = modelParameter->childByName(OSNAME_VALUE);
    parameter.setValue(valueObj->stringValue());
    parameters_.push_back(parameter);
}

References assert, ObjectState::childByName(), ObjectState::hasAttribute(), ObjectState::hasChild(), INTEGER_PARAM, LONG_PARAM, TCEString::lower(), ObjectState::name(), OSNAME_ATTR_DATA_TYPE, OSNAME_MODEL_PARAM, OSNAME_NAME, OSNAME_VALUE, parameters_, ProGe::Parameter::setName(), ProGe::Parameter::setType(), ProGe::Parameter::setValue(), STRING_PARAM, ObjectState::stringAttribute(), and ObjectState::stringValue().

Referenced by extractModelParams().

Here is the call graph for this function:

◆ extractModelParams()

void IPXactModel::extractModelParams ( const ObjectState * modelParameters )

private

Definition at line 930 of file IPXactModel.cc.

                                                                  {
 
    assert(modelParameters->name() == OSNAME_MODEL_PARAMS);
    for (int i = 0; i < modelParameters->childCount(); i++) {
        TCEString childName = modelParameters->child(i)->name();
        if (childName ==  OSNAME_MODEL_PARAM) {
            extractModelParam(modelParameters->child(i));
        }
    }
}

References assert, ObjectState::child(), ObjectState::childCount(), extractModelParam(), ObjectState::name(), OSNAME_MODEL_PARAM, and OSNAME_MODEL_PARAMS.

Referenced by loadState().

Here is the call graph for this function:

◆ extractPortMap()

void IPXactModel::extractPortMap	(	const ObjectState *	portMap,
		IPXactInterface &	interface
	)		const

private

Definition at line 729 of file IPXactModel.cc.

                                      {
 
    assert(portMap->name() == OSNAME_BUS_PORT_MAP);
    if (!(portMap->hasChild(OSNAME_BUS_PORT_MAP_BUS) &&
          portMap->hasChild(OSNAME_BUS_PORT_MAP_COMP))) {
        
        TCEString msg = "Bus interface port map is invalid";
        ObjectStateLoadingException* exc = 
            new ObjectStateLoadingException(__FILE__, __LINE__,
                                            "IPXactModel", msg);
        throw exc;
    }
    
    const ObjectState* busPort =
        portMap->childByName(OSNAME_BUS_PORT_MAP_BUS);
    const ObjectState* compPort =
        portMap->childByName(OSNAME_BUS_PORT_MAP_COMP);
    if (!busPort->hasChild(OSNAME_BUS_PORT_MAP_NAME) || 
        !compPort->hasChild(OSNAME_BUS_PORT_MAP_NAME)) {
        
        TCEString msg = "Port name missing from port map";
        ObjectStateLoadingException* exc = 
            new ObjectStateLoadingException(__FILE__, __LINE__,
                                            "IPXactModel", msg);
        throw exc;
    }
    TCEString compPortName =
        compPort->childByName(OSNAME_BUS_PORT_MAP_NAME)->stringValue();
    TCEString busPortName =
        busPort->childByName(OSNAME_BUS_PORT_MAP_NAME)->stringValue();
 
    if (busPortName.empty() || compPortName.empty()) {
        TCEString msg = "Port name is empty in port map";
        ObjectStateLoadingException* exc = 
            new ObjectStateLoadingException(__FILE__, __LINE__,
                                            "IPXactModel", msg);
        throw exc;
    }
    interface.addSignalMapping(compPortName, busPortName);
}

References IPXactInterface::addSignalMapping(), assert, ObjectState::childByName(), ObjectState::hasChild(), ObjectState::name(), OSNAME_BUS_PORT_MAP, OSNAME_BUS_PORT_MAP_BUS, OSNAME_BUS_PORT_MAP_COMP, OSNAME_BUS_PORT_MAP_NAME, and ObjectState::stringValue().

Referenced by extractPortMappings().

Here is the call graph for this function:

◆ extractPortMappings()

void IPXactModel::extractPortMappings	(	const ObjectState *	portMaps,
		IPXactInterface &	interface
	)		const

private

Definition at line 712 of file IPXactModel.cc.

                                      {
 
    assert(portMaps->name() == OSNAME_BUS_PORT_MAPS);
    if (!portMaps->hasChild(OSNAME_BUS_PORT_MAP)) {
        return;
    }
    for (int i = 0; i < portMaps->childCount(); i++) {
        const ObjectState* map = portMaps->child(i);
        if (map->name() == OSNAME_BUS_PORT_MAP) {
            extractPortMap(map, interface);
        }
    }
}

References assert, ObjectState::child(), ObjectState::childCount(), extractPortMap(), ObjectState::hasChild(), ObjectState::name(), OSNAME_BUS_PORT_MAP, and OSNAME_BUS_PORT_MAPS.

Referenced by extractBusInterface().

Here is the call graph for this function:

◆ extractSignals()

void IPXactModel::extractSignals ( const ObjectState * signals )

private

Definition at line 773 of file IPXactModel.cc.

                                                      {
 
    assert(signals->name() == OSNAME_PORTS);
 
    for (int i = 0; i < signals->childCount(); i++) {
        const ObjectState* signal = signals->child(i);
        if (signal->name() != OSNAME_PORT) {
            continue;
        }
 
        TCEString name = "";
        ProGe::Direction direction = ProGe::IN;
        ProGe::DataType type = ProGe::BIT;
        int width = 0;
        
        if (signal->hasChild(OSNAME_NAME)) {
            name = signal->childByName(OSNAME_NAME)->stringValue();
        }
        if (!signal->hasChild(OSNAME_WIRE)) {
            TCEString msg = "Wire node not found from Port!";
            InvalidData exc(__FILE__, __LINE__, "IPXactModel", msg);
            throw exc;
        }
        const ObjectState* wire = signal->childByName(OSNAME_WIRE);
        if (wire->hasChild(OSNAME_PORT_DIRECTION)) {
            TCEString dir =
                wire->childByName(OSNAME_PORT_DIRECTION)->stringValue();
            if (dir == "in") {
                direction = ProGe::IN;
            } else if (dir == "out") {
                direction = ProGe::OUT;
            } else if (dir == "inout") {
                direction = ProGe::BIDIR;
            } else {
                assert(false && "Unknown direction");
            }
        } else {
            TCEString msg = "Port does not have direction!";
            InvalidData exc(__FILE__, __LINE__, "IPXactModel", msg);
            throw exc;
        }
        
        if (wire->hasChild(OSNAME_VECTOR)) {
            type = ProGe::BIT_VECTOR;
            int leftBorder = 0;
            int rightBorder = 0;
            const ObjectState* vector = wire->childByName(OSNAME_VECTOR);
            if (vector->hasChild(OSNAME_PORT_LEFT)) {
                leftBorder =
                    vector->childByName(OSNAME_PORT_LEFT)->intValue();
                assert(leftBorder >= 0);
            }
            if (vector->hasChild(OSNAME_PORT_RIGHT)) {
                rightBorder =
                    vector->childByName(OSNAME_PORT_RIGHT)->intValue();
                assert(rightBorder >= 0);
            }
            if (leftBorder < rightBorder) {
                TCEString msg = "Reversed bit order is not supported";
                UnexpectedValue* exc =
                    new UnexpectedValue(__FILE__, __LINE__, "IPXactModel",
                        msg);
                throw exc;
            }
            width = leftBorder - rightBorder + 1;
        } else {
            type = ProGe::BIT;
            width = 0;
        }
 
        TCEString widthFormula = Conversion::toString(width);
        HDLPort* port = new HDLPort(name, widthFormula, type, direction,
                                    false, width);
        signals_.push_back(port);
    }
}

References assert, ProGe::BIDIR, ProGe::BIT, ProGe::BIT_VECTOR, ObjectState::child(), ObjectState::childByName(), ObjectState::childCount(), ObjectState::hasChild(), ProGe::IN, ObjectState::intValue(), ObjectState::name(), OSNAME_NAME, OSNAME_PORT, OSNAME_PORT_DIRECTION, OSNAME_PORT_LEFT, OSNAME_PORT_RIGHT, OSNAME_PORTS, OSNAME_VECTOR, OSNAME_WIRE, ProGe::OUT, signals_, ObjectState::stringValue(), and Conversion::toString().

Referenced by loadState().

Here is the call graph for this function:

◆ extractVLNV()

void IPXactModel::extractVLNV ( const ObjectState * root )

private

Definition at line 518 of file IPXactModel.cc.

                                                {
 
    assert(root->name() == OSNAME_IPXACT_MODEL);
    TCEString vendor = "";
    TCEString library = "";
    TCEString name = "";
    TCEString version = "";
    if (root->hasChild(OSNAME_VENDOR)) {
        vendor = root->childByName(OSNAME_VENDOR)->stringValue();
    }
    if (root->hasChild(OSNAME_LIBRARY)) {
        library = root->childByName(OSNAME_LIBRARY)->stringValue();
    }
    if (root->hasChild(OSNAME_NAME)) {
        name = root->childByName(OSNAME_NAME)->stringValue();
    }
    if (root->hasChild(OSNAME_VERSION)) {
        version = root->childByName(OSNAME_VERSION)->stringValue();
    }
    setVLNV(vendor, library, name, version);
}

References assert, ObjectState::childByName(), ObjectState::hasChild(), ObjectState::name(), OSNAME_IPXACT_MODEL, OSNAME_LIBRARY, OSNAME_NAME, OSNAME_VENDOR, OSNAME_VERSION, setVLNV(), and ObjectState::stringValue().

Referenced by loadState().

Here is the call graph for this function:

◆ extractVlnvFromAttr()

IPXact::Vlnv IPXactModel::extractVlnvFromAttr ( const ObjectState * busType ) const

private

Definition at line 541 of file IPXactModel.cc.

                                                                 {
    
    assert(busType->name() == OSNAME_BUS_TYPE ||
           busType->name() == OSNAME_BUS_ABS_TYPE);
    IPXact::Vlnv vlnv;
    if (busType->hasAttribute(OSNAME_VENDOR)) {
        vlnv.vendor = busType->stringAttribute(OSNAME_VENDOR);
    }
    if (busType->hasAttribute(OSNAME_LIBRARY)) {
        vlnv.library = busType->stringAttribute(OSNAME_LIBRARY);
    }
    if (busType->hasAttribute(OSNAME_NAME)) {
        vlnv.name = busType->stringAttribute(OSNAME_NAME);
    }
    if (busType->hasAttribute(OSNAME_VERSION)) {
        vlnv.version = busType->stringAttribute(OSNAME_VERSION);
    }
    return vlnv;
}

References assert, ObjectState::hasAttribute(), IPXact::Vlnv::library, IPXact::Vlnv::name, ObjectState::name(), OSNAME_BUS_ABS_TYPE, OSNAME_BUS_TYPE, OSNAME_LIBRARY, OSNAME_NAME, OSNAME_VENDOR, OSNAME_VERSION, ObjectState::stringAttribute(), IPXact::Vlnv::vendor, and IPXact::Vlnv::version.

Referenced by extractBusInterface().

Here is the call graph for this function:

◆ interfaceByType()

IPXactInterface * IPXactModel::interfaceByType	(	const IPXact::Vlnv &	type,
		const IPXact::Vlnv &	absType,
		const TCEString	instanceName,
		BusMode	mode
	)		const

private

Definition at line 898 of file IPXactModel.cc.

                            {
    
    IPXactInterface* interface = NULL;
    
    vector<IPXactInterface*> available;
    available.push_back(new IPXactClkInterface());
    available.push_back(new IPXactResetInterface());
    available.push_back(new IPXactHibiInterface());
    
    bool found = false;
    for (unsigned int i = 0; i < available.size(); i++) {
        if (!found) {
            if (available.at(i)->busType() == type &&
                available.at(i)->busAbstractionType() == absType &&
                available.at(i)->busMode() == mode) {
                interface = available.at(i);
                interface->setInstanceName(instanceName);
                found = true;
                continue;
            }
        }
        delete available.at(i);
    }
    return interface;
}

References IPXactInterface::setInstanceName().

Referenced by extractBusInterface().

Here is the call graph for this function:

◆ loadState()

void IPXactModel::loadState ( const ObjectState * state )

virtual

Loads the state of the object from the given ObjectState object.

Parameters

state ObjectState object from which (and the children of which) the state is loaded.

Implements Serializable.

Definition at line 145 of file IPXactModel.cc.

                                               {
    
    extractVLNV(state);
 
    if (state->hasChild(OSNAME_BUS_INTERFACES)) {
        extractBusInterfaces(state->childByName(OSNAME_BUS_INTERFACES));
    }
    
    if (state->hasChild(OSNAME_ADDRESS_SPACES)) {
        extractAddressSpaces(state->childByName(OSNAME_ADDRESS_SPACES));
    }
 
    if (state->hasChild(OSNAME_MODEL)) {
        const ObjectState* model = state->childByName(OSNAME_MODEL);
        if (model->hasChild(OSNAME_PORTS)) {
            extractSignals(model->childByName(OSNAME_PORTS));
        }
        if (model->hasChild(OSNAME_MODEL_PARAMS)) {
            const ObjectState* modelParams =
                model->childByName(OSNAME_MODEL_PARAMS);
            if (modelParams->hasChild(OSNAME_MODEL_PARAM)) {
                extractModelParams(modelParams);
            }
        }
    }
 
    if (state->hasChild(OSNAME_FILESETS)) {
        extractFiles(state->childByName(OSNAME_FILESETS));
    }
}

References ObjectState::childByName(), extractAddressSpaces(), extractBusInterfaces(), extractFiles(), extractModelParams(), extractSignals(), extractVLNV(), ObjectState::hasChild(), OSNAME_ADDRESS_SPACES, OSNAME_BUS_INTERFACES, OSNAME_FILESETS, OSNAME_MODEL, OSNAME_MODEL_PARAM, OSNAME_MODEL_PARAMS, and OSNAME_PORTS.

Referenced by IPXactModel().

Here is the call graph for this function:

◆ saveState()

ObjectState * IPXactModel::saveState ( ) const

virtual

Saves the objects state into an ObjectState object and maybe its child objects.

Returns: The root of the ObjectState tree created.

Implements Serializable.

Definition at line 178 of file IPXactModel.cc.

                             {
    
    ObjectState* root = new ObjectState(OSNAME_IPXACT_MODEL);
 
    // add VLNV
    ObjectState* vendor = new ObjectState(OSNAME_VENDOR);
    vendor->setValue(vlnv_.vendor);
    root->addChild(vendor);
    ObjectState* library = new ObjectState(OSNAME_LIBRARY);
    library->setValue(vlnv_.library);
    root->addChild(library);
    ObjectState* compName = new ObjectState(OSNAME_NAME);
    compName->setValue(vlnv_.name);
    root->addChild(compName);
    ObjectState* compVersion = new ObjectState(OSNAME_VERSION);
    compVersion->setValue(vlnv_.version);
    root->addChild(compVersion);
 
    // add bus interfaces
    ObjectState* busInterfaces = new ObjectState(OSNAME_BUS_INTERFACES);
    root->addChild(busInterfaces);
    for (unsigned int i = 0; i < busInterfaces_.size(); i++) {        
        ObjectState* busInterface = new ObjectState(OSNAME_BUS_INTERFACE);
        addBusInterfaceObject(busInterfaces_.at(i), busInterface);
        busInterfaces->addChild(busInterface);
    }
 
    // add address spaces
    ObjectState* addressSpaces = new ObjectState(OSNAME_ADDRESS_SPACES);
    root->addChild(addressSpaces);
    for (unsigned int i = 0; i < addressSpaces_.size(); i++) {
        ObjectState* addressSpace = new ObjectState(OSNAME_ADDRESS_SPACE);
        addAddressSpaceObject(addressSpaces_.at(i), addressSpace);
        addressSpaces->addChild(addressSpace);
    }
    
    // create model and add signals
    ObjectState* model = new ObjectState(OSNAME_MODEL);
    root->addChild(model);
    ObjectState* signals = new ObjectState(OSNAME_PORTS);
    model->addChild(signals);
    for (unsigned int i = 0; i < signals_.size(); i++) {
        ObjectState* signal = new ObjectState(OSNAME_PORT);
        addSignalObject(signals_.at(i), signal);
        signals->addChild(signal);
    }
 
    // add model parameters if any
    if (parameters_.size() > 0) {
        addModelParamsObject(model);
    }
 
    // add hdl files
    ObjectState* fileSets = new ObjectState(OSNAME_FILESETS);
    root->addChild(fileSets);
    ObjectState* fileSet = new ObjectState(OSNAME_FILESET);
    ObjectState* fileSetName =  new ObjectState(OSNAME_FILE_NAME);
    fileSetName->setValue(HDL_SET_ID);
    fileSet->addChild(fileSetName);
    fileSets->addChild(fileSet);
    for (unsigned int i = 0; i < hdlFiles_.size(); i++) {
        ObjectState* file = new ObjectState(OSNAME_FILE);
        addFileObject(hdlFiles_.at(i), VHDL_FILE, file);
        fileSet->addChild(file);
    }
    // add other files (memory init files etc)
    for (unsigned int i = 0; i < otherFiles_.size(); i++) {
        ObjectState* file = new ObjectState(OSNAME_FILE);
        addFileObject(otherFiles_.at(i), OTHER_FILE, file);
        fileSet->addChild(file);
    }
    return root;
}

References addAddressSpaceObject(), addBusInterfaceObject(), ObjectState::addChild(), addFileObject(), addModelParamsObject(), addressSpaces_, addSignalObject(), busInterfaces_, HDL_SET_ID, hdlFiles_, IPXact::Vlnv::library, IPXact::Vlnv::name, OSNAME_ADDRESS_SPACE, OSNAME_ADDRESS_SPACES, OSNAME_BUS_INTERFACE, OSNAME_BUS_INTERFACES, OSNAME_FILE, OSNAME_FILE_NAME, OSNAME_FILESET, OSNAME_FILESETS, OSNAME_IPXACT_MODEL, OSNAME_LIBRARY, OSNAME_MODEL, OSNAME_NAME, OSNAME_PORT, OSNAME_PORTS, OSNAME_VENDOR, OSNAME_VERSION, OTHER_FILE, otherFiles_, parameters_, ObjectState::setValue(), signals_, IPXact::Vlnv::vendor, IPXact::Vlnv::version, VHDL_FILE, and vlnv_.

Referenced by IPXactSerializer::writeIPXactModel().

Here is the call graph for this function:

◆ setFile()

void IPXactModel::setFile ( const TCEString & file )

Definition at line 274 of file IPXactModel.cc.

                                          {
 
    otherFiles_.push_back(file);
}

References otherFiles_.

Referenced by IPXactFileGenerator::writeProjectFiles().

◆ setHdlFile()

void IPXactModel::setHdlFile ( const TCEString & file )

Definition at line 268 of file IPXactModel.cc.

                                             {
    
    hdlFiles_.push_back(file);
}

References hdlFiles_.

Referenced by setHdlFiles().

◆ setHdlFiles()

void IPXactModel::setHdlFiles ( const std::vector< TCEString > & files )

Definition at line 281 of file IPXactModel.cc.

                                                          {
 
    for (unsigned int i = 0; i < files.size(); i++) {
        setHdlFile(files.at(i));
    }
}

References setHdlFile().

Referenced by IPXactFileGenerator::writeProjectFiles().

Here is the call graph for this function:

◆ setVLNV()

void IPXactModel::setVLNV	(	TCEString	vendor,
		TCEString	library,
		TCEString	name,
		TCEString	version
	)

Definition at line 254 of file IPXactModel.cc.

                       {
 
    vlnv_.vendor = vendor;
    vlnv_.library = library;
    vlnv_.name = name;
    vlnv_.version = version;
}

References IPXact::Vlnv::library, IPXact::Vlnv::name, IPXact::Vlnv::vendor, IPXact::Vlnv::version, and vlnv_.

Referenced by extractVLNV(), and IPXactFileGenerator::writeProjectFiles().

Member Data Documentation

◆ addressSpaces_

std::vector<IPXactAddressSpace*> IPXactModel::addressSpaces_

private

Definition at line 205 of file IPXactModel.hh.

Referenced by addAddressSpace(), extractAddressSpace(), saveState(), and ~IPXactModel().

◆ busInterfaces_

std::vector<IPXactInterface*> IPXactModel::busInterfaces_

private

Definition at line 203 of file IPXactModel.hh.

Referenced by addBusInterface(), extractBusInterface(), saveState(), and ~IPXactModel().

◆ DEV_FAMILY_GENERIC

const TCEString IPXactModel::DEV_FAMILY_GENERIC = "dev_family_g"

staticprivate

Definition at line 217 of file IPXactModel.hh.

◆ HDL_SET_ID

const TCEString IPXactModel::HDL_SET_ID = "hdlSources"

staticprivate

Definition at line 210 of file IPXactModel.hh.

Referenced by extractFiles(), and saveState().

◆ hdlFiles_

std::vector<TCEString> IPXactModel::hdlFiles_

private

Definition at line 207 of file IPXactModel.hh.

Referenced by extractFiles(), saveState(), and setHdlFile().

◆ INTEGER_PARAM

const TCEString IPXactModel::INTEGER_PARAM = "integer"

staticprivate

Definition at line 215 of file IPXactModel.hh.

Referenced by addModelParamsObject(), and extractModelParam().

◆ LONG_PARAM

const TCEString IPXactModel::LONG_PARAM = "long"

staticprivate

Definition at line 216 of file IPXactModel.hh.

Referenced by addModelParamsObject(), and extractModelParam().

◆ OSNAME_ADDRESS_SPACE

const std::string IPXactModel::OSNAME_ADDRESS_SPACE = "spirit:addressSpace"

static

Definition at line 126 of file IPXactModel.hh.

Referenced by extractAddressSpace(), extractAddressSpaces(), and saveState().

◆ OSNAME_ADDRESS_SPACES

const std::string IPXactModel::OSNAME_ADDRESS_SPACES = "spirit:addressSpaces"

static

Definition at line 125 of file IPXactModel.hh.

Referenced by extractAddressSpaces(), loadState(), and saveState().

◆ OSNAME_AS_MAU

const std::string IPXactModel::OSNAME_AS_MAU = "spirit:addressUnitBits"

static

Definition at line 129 of file IPXactModel.hh.

Referenced by addAddressSpaceObject(), and extractAddressSpace().

◆ OSNAME_AS_RANGE

const std::string IPXactModel::OSNAME_AS_RANGE = "spirit:range"

static

Definition at line 127 of file IPXactModel.hh.

Referenced by addAddressSpaceObject(), and extractAddressSpace().

◆ OSNAME_AS_WIDTH

const std::string IPXactModel::OSNAME_AS_WIDTH = "spirit:width"

static

Definition at line 128 of file IPXactModel.hh.

Referenced by addAddressSpaceObject(), and extractAddressSpace().

◆ OSNAME_ATTR_DATA_TYPE

const TCEString IPXactModel::OSNAME_ATTR_DATA_TYPE = "spirit:dataType"

static

Definition at line 134 of file IPXactModel.hh.

Referenced by addModelParamsObject(), and extractModelParam().

◆ OSNAME_ATTR_FORMAT

const TCEString IPXactModel::OSNAME_ATTR_FORMAT = "spirit:format"

static

Definition at line 135 of file IPXactModel.hh.

Referenced by addModelParamsObject().

◆ OSNAME_ATTR_ID

const TCEString IPXactModel::OSNAME_ATTR_ID = "spirit:id"

static

Definition at line 136 of file IPXactModel.hh.

Referenced by addModelParamsObject().

◆ OSNAME_ATTR_RESOLVE

const TCEString IPXactModel::OSNAME_ATTR_RESOLVE = "spirit:resolve"

static

Definition at line 137 of file IPXactModel.hh.

Referenced by addModelParamsObject().

◆ OSNAME_BUS_ABS_TYPE

const TCEString IPXactModel::OSNAME_BUS_ABS_TYPE = "spirit:abstractionType"

static

Definition at line 99 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), extractBusInterface(), and extractVlnvFromAttr().

◆ OSNAME_BUS_INTERFACE

const TCEString IPXactModel::OSNAME_BUS_INTERFACE = "spirit:busInterface"

static

Definition at line 97 of file IPXactModel.hh.

Referenced by extractBusInterface(), extractBusInterfaces(), extractBusMode(), and saveState().

◆ OSNAME_BUS_INTERFACES

const TCEString IPXactModel::OSNAME_BUS_INTERFACES = "spirit:busInterfaces"

static

Definition at line 96 of file IPXactModel.hh.

Referenced by extractBusInterfaces(), loadState(), and saveState().

◆ OSNAME_BUS_MASTER

const TCEString IPXactModel::OSNAME_BUS_MASTER = "spirit:master"

static

Definition at line 100 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), and extractBusMode().

◆ OSNAME_BUS_MIRRORED_MASTER

const TCEString IPXactModel::OSNAME_BUS_MIRRORED_MASTER

static

Initial value:

=

"spirit:mirroredMaster"

Definition at line 101 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), and extractBusMode().

◆ OSNAME_BUS_MIRRORED_SLAVE

const TCEString IPXactModel::OSNAME_BUS_MIRRORED_SLAVE

static

Initial value:

=

"spirit:mirroredSlave"

Definition at line 103 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), and extractBusMode().

◆ OSNAME_BUS_MIRRORED_SYSTEM

const TCEString IPXactModel::OSNAME_BUS_MIRRORED_SYSTEM

static

Initial value:

=

"spirit:mirroredSystem"

Definition at line 105 of file IPXactModel.hh.

Referenced by extractBusMode().

◆ OSNAME_BUS_MONITOR

const TCEString IPXactModel::OSNAME_BUS_MONITOR = "spirit:monitor"

static

Definition at line 106 of file IPXactModel.hh.

Referenced by extractBusMode().

◆ OSNAME_BUS_PORT_MAP

const TCEString IPXactModel::OSNAME_BUS_PORT_MAP = "spirit:portMap"

static

Definition at line 108 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), extractPortMap(), and extractPortMappings().

◆ OSNAME_BUS_PORT_MAP_BUS

const TCEString IPXactModel::OSNAME_BUS_PORT_MAP_BUS

static

Initial value:

=

"spirit:logicalPort"

Definition at line 111 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), and extractPortMap().

◆ OSNAME_BUS_PORT_MAP_COMP

const TCEString IPXactModel::OSNAME_BUS_PORT_MAP_COMP

static

Initial value:

=

"spirit:physicalPort"

Definition at line 110 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), and extractPortMap().

◆ OSNAME_BUS_PORT_MAP_NAME

const TCEString IPXactModel::OSNAME_BUS_PORT_MAP_NAME = "spirit:name"

static

Definition at line 109 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), and extractPortMap().

◆ OSNAME_BUS_PORT_MAPS

const TCEString IPXactModel::OSNAME_BUS_PORT_MAPS = "spirit:portMaps"

static

Definition at line 107 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), extractBusInterface(), and extractPortMappings().

◆ OSNAME_BUS_SLAVE

const TCEString IPXactModel::OSNAME_BUS_SLAVE = "spirit:slave"

static

Definition at line 102 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), and extractBusMode().

◆ OSNAME_BUS_SYSTEM

const TCEString IPXactModel::OSNAME_BUS_SYSTEM = "spirit:system"

static

Definition at line 104 of file IPXactModel.hh.

Referenced by extractBusMode().

◆ OSNAME_BUS_TYPE

const TCEString IPXactModel::OSNAME_BUS_TYPE = "spirit:busType"

static

Definition at line 98 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), extractBusInterface(), and extractVlnvFromAttr().

◆ OSNAME_DISPLAY_NAME

const TCEString IPXactModel::OSNAME_DISPLAY_NAME = "spirit:displayName"

static

Definition at line 132 of file IPXactModel.hh.

Referenced by addModelParamsObject().

◆ OSNAME_FILE

const TCEString IPXactModel::OSNAME_FILE = "spirit:file"

static

Definition at line 122 of file IPXactModel.hh.

Referenced by extractFiles(), and saveState().

◆ OSNAME_FILE_NAME

const TCEString IPXactModel::OSNAME_FILE_NAME = "spirit:name"

static

Definition at line 123 of file IPXactModel.hh.

Referenced by addFileObject(), extractFiles(), and saveState().

◆ OSNAME_FILE_TYPE

const TCEString IPXactModel::OSNAME_FILE_TYPE = "spirit:fileType"

static

Definition at line 124 of file IPXactModel.hh.

Referenced by addFileObject(), and extractFiles().

◆ OSNAME_FILESET

const TCEString IPXactModel::OSNAME_FILESET = "spirit:fileSet"

static

Definition at line 121 of file IPXactModel.hh.

Referenced by extractFiles(), and saveState().

◆ OSNAME_FILESETS

const TCEString IPXactModel::OSNAME_FILESETS = "spirit:fileSets"

static

Definition at line 120 of file IPXactModel.hh.

Referenced by extractFiles(), loadState(), and saveState().

◆ OSNAME_IPXACT_MODEL

const TCEString IPXactModel::OSNAME_IPXACT_MODEL = "spirit:component"

static

Definition at line 91 of file IPXactModel.hh.

Referenced by extractVLNV(), and saveState().

◆ OSNAME_LIBRARY

const TCEString IPXactModel::OSNAME_LIBRARY = "spirit:library"

static

Definition at line 93 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), extractVLNV(), extractVlnvFromAttr(), and saveState().

◆ OSNAME_MODEL

const TCEString IPXactModel::OSNAME_MODEL = "spirit:model"

static

Definition at line 112 of file IPXactModel.hh.

Referenced by loadState(), and saveState().

◆ OSNAME_MODEL_PARAM

const TCEString IPXactModel::OSNAME_MODEL_PARAM = "spirit:modelParameter"

static

Definition at line 131 of file IPXactModel.hh.

Referenced by addModelParamsObject(), extractModelParam(), extractModelParams(), and loadState().

◆ OSNAME_MODEL_PARAMS

const TCEString IPXactModel::OSNAME_MODEL_PARAMS = "spirit:modelParameters"

static

Definition at line 130 of file IPXactModel.hh.

Referenced by addModelParamsObject(), extractModelParams(), and loadState().

◆ OSNAME_NAME

const TCEString IPXactModel::OSNAME_NAME = "spirit:name"

static

Definition at line 94 of file IPXactModel.hh.

Referenced by addAddressSpaceObject(), addBusInterfaceObject(), addModelParamsObject(), addSignalObject(), extractAddressSpace(), extractBusInterface(), extractFiles(), extractModelParam(), extractSignals(), extractVLNV(), extractVlnvFromAttr(), and saveState().

◆ OSNAME_PORT

const TCEString IPXactModel::OSNAME_PORT = "spirit:port"

static

Definition at line 116 of file IPXactModel.hh.

Referenced by extractSignals(), and saveState().

◆ OSNAME_PORT_DIRECTION

const TCEString IPXactModel::OSNAME_PORT_DIRECTION = "spirit:direction"

static

Definition at line 117 of file IPXactModel.hh.

Referenced by addSignalObject(), and extractSignals().

◆ OSNAME_PORT_LEFT

const TCEString IPXactModel::OSNAME_PORT_LEFT = "spirit:left"

static

Definition at line 118 of file IPXactModel.hh.

Referenced by addSignalObject(), and extractSignals().

◆ OSNAME_PORT_RIGHT

const TCEString IPXactModel::OSNAME_PORT_RIGHT = "spirit:right"

static

Definition at line 119 of file IPXactModel.hh.

Referenced by addSignalObject(), and extractSignals().

◆ OSNAME_PORTS

const TCEString IPXactModel::OSNAME_PORTS = "spirit:ports"

static

Definition at line 113 of file IPXactModel.hh.

Referenced by extractSignals(), loadState(), and saveState().

◆ OSNAME_VALUE

const TCEString IPXactModel::OSNAME_VALUE = "spirit:value"

static

Definition at line 133 of file IPXactModel.hh.

Referenced by addModelParamsObject(), and extractModelParam().

◆ OSNAME_VECTOR

const TCEString IPXactModel::OSNAME_VECTOR = "spirit:vector"

static

Definition at line 115 of file IPXactModel.hh.

Referenced by addSignalObject(), and extractSignals().

◆ OSNAME_VENDOR

const TCEString IPXactModel::OSNAME_VENDOR = "spirit:vendor"

static

Definition at line 92 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), extractVLNV(), extractVlnvFromAttr(), and saveState().

◆ OSNAME_VERSION

const TCEString IPXactModel::OSNAME_VERSION = "spirit:version"

static

Definition at line 95 of file IPXactModel.hh.

Referenced by addBusInterfaceObject(), extractVLNV(), extractVlnvFromAttr(), and saveState().

◆ OSNAME_WIRE

const TCEString IPXactModel::OSNAME_WIRE = "spirit:wire"

static

Definition at line 114 of file IPXactModel.hh.

Referenced by addSignalObject(), and extractSignals().

◆ OTHER_FILE

const TCEString IPXactModel::OTHER_FILE = "unknown"

staticprivate

Definition at line 212 of file IPXactModel.hh.

Referenced by extractFiles(), and saveState().

◆ otherFiles_

std::vector<TCEString> IPXactModel::otherFiles_

private

Definition at line 208 of file IPXactModel.hh.

Referenced by extractFiles(), saveState(), and setFile().

◆ parameters_

std::vector<ProGe::Parameter> IPXactModel::parameters_

private

Definition at line 201 of file IPXactModel.hh.

Referenced by addModelParamsObject(), addParameter(), extractModelParam(), and saveState().

◆ RESOLVE_USER

const TCEString IPXactModel::RESOLVE_USER = "user"

staticprivate

Definition at line 213 of file IPXactModel.hh.

Referenced by addModelParamsObject().

◆ signals_

std::vector<HDLPort*> IPXactModel::signals_

private

Definition at line 199 of file IPXactModel.hh.

Referenced by addSignal(), extractSignals(), saveState(), and ~IPXactModel().

◆ STRING_PARAM

const TCEString IPXactModel::STRING_PARAM = "string"

staticprivate

Definition at line 214 of file IPXactModel.hh.

Referenced by addModelParamsObject(), and extractModelParam().

◆ VHDL_FILE

const TCEString IPXactModel::VHDL_FILE = "vhdlSource"

staticprivate

Definition at line 211 of file IPXactModel.hh.

Referenced by extractFiles(), and saveState().

◆ vlnv_

IPXact::Vlnv IPXactModel::vlnv_

private

Definition at line 197 of file IPXactModel.hh.

Referenced by saveState(), and setVLNV().

The documentation for this class was generated from the following files:

Public Types

Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Enumeration Documentation

◆ BusMode

Constructor & Destructor Documentation

◆ IPXactModel() [1/3]

◆ IPXactModel() [2/3]

◆ ~IPXactModel()

◆ IPXactModel() [3/3]

Member Function Documentation

◆ addAddressSpace()

◆ addAddressSpaceObject()

◆ addBusInterface()

◆ addBusInterfaceObject()

◆ addFileObject()

◆ addModelParamsObject()

◆ addParameter()

◆ addSignal()

◆ addSignalObject()

◆ extractAddressSpace()

◆ extractAddressSpaces()

◆ extractBusInterface()

◆ extractBusInterfaces()

◆ extractBusMode()

◆ extractFiles()

◆ extractModelParam()

◆ extractModelParams()

◆ extractPortMap()

◆ extractPortMappings()

◆ extractSignals()

◆ extractVLNV()

◆ extractVlnvFromAttr()

◆ interfaceByType()

◆ loadState()

◆ saveState()

◆ setFile()

◆ setHdlFile()

◆ setHdlFiles()

◆ setVLNV()

Member Data Documentation

◆ addressSpaces_

◆ busInterfaces_

◆ DEV_FAMILY_GENERIC

◆ HDL_SET_ID

◆ hdlFiles_

◆ INTEGER_PARAM

◆ LONG_PARAM

◆ OSNAME_ADDRESS_SPACE

◆ OSNAME_ADDRESS_SPACES

◆ OSNAME_AS_MAU

◆ OSNAME_AS_RANGE

◆ OSNAME_AS_WIDTH

◆ OSNAME_ATTR_DATA_TYPE

◆ OSNAME_ATTR_FORMAT

◆ OSNAME_ATTR_ID

◆ OSNAME_ATTR_RESOLVE

◆ OSNAME_BUS_ABS_TYPE

◆ OSNAME_BUS_INTERFACE

◆ OSNAME_BUS_INTERFACES

◆ OSNAME_BUS_MASTER

◆ OSNAME_BUS_MIRRORED_MASTER

◆ OSNAME_BUS_MIRRORED_SLAVE

◆ OSNAME_BUS_MIRRORED_SYSTEM

◆ OSNAME_BUS_MONITOR

◆ OSNAME_BUS_PORT_MAP

◆ OSNAME_BUS_PORT_MAP_BUS

◆ OSNAME_BUS_PORT_MAP_COMP

◆ OSNAME_BUS_PORT_MAP_NAME

◆ OSNAME_BUS_PORT_MAPS

◆ OSNAME_BUS_SLAVE

◆ OSNAME_BUS_SYSTEM

◆ OSNAME_BUS_TYPE

◆ OSNAME_DISPLAY_NAME

◆ OSNAME_FILE

◆ OSNAME_FILE_NAME