torc::generic::_impl::Copier< class View > Class Template Reference

#include <Cloning.hpp>

Inheritance diagram for torc::generic::_impl::Copier< class View >:

Collaboration diagram for torc::generic::_impl::Copier< class View >:

Public Types
typedef View	Type
typedef boost::shared_ptr< Type >	Pointer

Public Member Functions
Pointer	operator() (const Pointer &inSource, const ObjectFactorySharedPtr &inFactory) throw (Error)
void	visit (View &inView) throw (Error)
void	connectNets (const NetSharedPtr &inNet, const NetSharedPtr &outNet, const ViewSharedPtr &inView)
void	cloneConnection (const NetSharedPtr &inNet, const NetSharedPtr &outNet, const ViewSharedPtr &inView)
	Copier ()
	~Copier () throw ()
virtual void	visit (_Tp &client)=0 throw (Error)

Private Attributes
ObjectFactorySharedPtr	mFactory
Pointer	mReturnVal

Detailed Description

template<>
class torc::generic::_impl::Copier< class View >

Definition at line 665 of file Cloning.hpp.

Member Typedef Documentation

typedef boost::shared_ptr<Type> torc::generic::_impl::Copier< class View >::Pointer

Definition at line 668 of file Cloning.hpp.

typedef View torc::generic::_impl::Copier< class View >::Type

Definition at line 667 of file Cloning.hpp.

Constructor & Destructor Documentation

torc::generic::_impl::Copier< class View >::Copier ( )

inline

Definition at line 981 of file Cloning.hpp.

             : Type::Visitor(), mFactory(), mReturnVal() {
    }

torc::generic::_impl::Copier< class View >::~Copier ( ) throw ( )

inline

Definition at line 984 of file Cloning.hpp.

                       {
    }

Member Function Documentation

void torc::generic::_impl::Copier< class View >::cloneConnection ( const NetSharedPtr &  inNet, const NetSharedPtr &  outNet, const ViewSharedPtr &  inView  )

inline

Definition at line 823 of file Cloning.hpp.

                                     {
        try {
            std::vector<PortSharedPtr> connectedPorts;
            inNet->getConnectedPorts(connectedPorts, true);
            for(std::vector<PortSharedPtr>::iterator it = connectedPorts.begin();
                it != connectedPorts.end(); ++it) {
                std::vector < std::string > nestedNames;
                PortSharedPtr actualPort = *it;
                PortSharedPtr port = actualPort;
                while(port) {
                    if(eCompositionTypeVectorBit != port->getCompositionType())
                        nestedNames.push_back(port->getName());
                    port = port->getParentCollection();
                }
                std::string portName = *nestedNames.rbegin();
                PortSharedPtr targetPort = inView->findPort(portName);
                if(!targetPort) {
                    Error e(eMessageIdErrorPointerToItemDoesNotExist, __FUNCTION__, __FILE__,
                        __LINE__);
                    e.saveContextData("Pointer to the target port does not exist", targetPort);
                    throw e;
                }
                if(nestedNames.size() > 1) {
                    findLeafConnectable(nestedNames, targetPort);
                }
                std::vector < size_t > indices;
                if(eCompositionTypeVectorBit == actualPort->getCompositionType()) {
                    indices = IndexFinder<Port, VectorPortBit>()(actualPort);
                }
                connectNetToElement(indices, targetPort, outNet);
            }
            std::vector<PortReferenceSharedPtr> connectedPortRefs;
            inNet->getConnectedPortRefs(connectedPortRefs, true);
            for(std::vector<PortReferenceSharedPtr>::iterator it = connectedPortRefs.begin();
                it != connectedPortRefs.end(); ++it) {
                std::vector < std::string > nestedNames;
                PortReferenceSharedPtr actualPort = *it;
                PortReferenceSharedPtr port = *it;
                InstanceSharedPtr instance;
                while(port) {
                    if(eCompositionTypeVectorBit != port->getCompositionType()) {
                        nestedNames.push_back(port->getName());
                        instance = port->getParent();
                    }
                    port = port->getParentCollection();
                }
                std::vector < size_t > indices;
                if(eCompositionTypeVectorBit == instance->getCompositionType()) {
                    indices = IndexFinder<Instance, InstanceArrayMember>()(instance);
                    instance = instance->getParentCollection();
                }
                InstanceSharedPtr targetInst = inView->findInstance(instance->getName());
                if(!indices.empty()) {
                    targetInst = targetInst->get(indices);
                }
                std::string portName = *nestedNames.rbegin();
                PortReferenceSharedPtr targetPort = targetInst->findPortReference(portName);
                if(!targetPort) {
                    Error e(eMessageIdErrorPointerToItemDoesNotExist, __FUNCTION__, __FILE__,
                        __LINE__);
                    e.saveContextData("Pointer to the target port does not exist", targetPort);
                    throw e;
                }
                if(nestedNames.size() > 1) {
                    findLeafConnectable(nestedNames, targetPort);
                }
                std::vector < size_t > portIndices;
                if(eCompositionTypeVectorBit == actualPort->getCompositionType()) {
                    portIndices = IndexFinder<PortReference, VectorPortBitReference>()(actualPort);
                }
                connectNetToElement(portIndices, targetPort, outNet);
            }
            std::vector<PortListSharedPtr> connectedPortLists;
            inNet->getConnectedPortLists(connectedPortLists);
            for(std::vector<PortListSharedPtr>::iterator it = connectedPortLists.begin();
                it != connectedPortLists.end(); ++it) {
                // PortList Clone has not been called directly because, its only
                // add child port/portRef to portList
                PortListSharedPtr cloned;
                mFactory->create(cloned);
                std::list<PortList::PortListElement> elements;
                (*it)->getChildren(elements);
                for(std::list<PortList::PortListElement>::iterator element = elements.begin();
                    element != elements.end(); ++element) {
                    switch((*element).getType()) {
                    case PortList::PortListElement::eElementTypePort: {
                        std::vector < std::string > nestedNames;
                        PortSharedPtr actualPort = (*element).getPort();
                        PortSharedPtr port = actualPort;
                        while(port) {
                            if(eCompositionTypeVectorBit != port->getCompositionType())
                                nestedNames.push_back(port->getName());
                            port = port->getParentCollection();
                        }
                        std::vector<std::string>::reverse_iterator name = nestedNames.rbegin();
                        std::string portName = *name;
                        PortSharedPtr targetPort = inView->findPort(portName);
                        if(nestedNames.size() > 1) {
                            findLeafConnectable(nestedNames, targetPort);
                        }
                        if(eCompositionTypeVectorBit == actualPort->getCompositionType()) {
                            targetPort = targetPort->get(
                                IndexFinder<Port, VectorPortBit>()(actualPort));
                        }
                        cloned->addChildPort(targetPort);
                        break;
                    }
                    case PortList::PortListElement::eElementTypePortReference: {
                        std::vector < std::string > nestedNames;
                        PortReferenceSharedPtr actualPort = (*element).getPortReference();
                        PortReferenceSharedPtr port = actualPort;
                        InstanceSharedPtr instance;
                        while(port) {
                            if(eCompositionTypeVectorBit != port->getCompositionType()) {
                                nestedNames.push_back(port->getName());
                                instance = port->getParent();
                            }
                            port = port->getParentCollection();
                        }
                        std::vector < size_t > indices;
                        if(eCompositionTypeVectorBit == instance->getCompositionType()) {
                            indices = IndexFinder<Instance, InstanceArrayMember>()(instance);
                            instance = instance->getParentCollection();
                        }
                        InstanceSharedPtr targetInst = inView->findInstance(instance->getName());
                        if(!indices.empty()) {
                            targetInst = targetInst->get(indices);
                        }
                        std::string portName = *nestedNames.rbegin();
                        PortReferenceSharedPtr targetPort = targetInst->findPortReference(portName);
                        if(!targetPort) {
                            Error e(eMessageIdErrorPointerToItemDoesNotExist, __FUNCTION__,
                                __FILE__, __LINE__);
                            e.saveContextData("Pointer to the target port does not exist",
                                targetPort);
                            throw e;
                        }
                        if(nestedNames.size() > 1) {
                            findLeafConnectable(nestedNames, targetPort);
                        }
                        if(eCompositionTypeVectorBit == actualPort->getCompositionType()) {
                            targetPort = targetPort->get(
                                IndexFinder<PortReference, VectorPortBitReference>()(actualPort));
                        }
                        cloned->addChildPortReference(targetPort);
                        break;
                    }
                    }
                }
                cloned->connect(outNet);
            }
        } catch(Error& e) {
            e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
            throw;
        }
    }

Here is the call graph for this function:

void torc::generic::_impl::Copier< class View >::connectNets ( const NetSharedPtr &  inNet, const NetSharedPtr &  outNet, const ViewSharedPtr &  inView  )

inline

Definition at line 807 of file Cloning.hpp.

                                     {
        if(eCompositionTypeBundle == inNet->getCompositionType()) {
            std::vector<NetSharedPtr> inChildren;
            std::vector<NetSharedPtr> outChildren;
            inNet->getChildren(inChildren);
            outNet->getChildren(outChildren);
            std::vector<NetSharedPtr>::iterator inIt = inChildren.begin();
            std::vector<NetSharedPtr>::iterator outIt = outChildren.begin();
            for(; inIt != inChildren.end(); ++inIt, ++outIt) {
                connectNets(*inIt, *outIt, inView);
            }
        }
        cloneConnection(inNet, outNet, inView);
    }

Pointer torc::generic::_impl::Copier< class View >::operator() ( const Pointer &  inSource, const ObjectFactorySharedPtr &  inFactory  ) throw ( Error )

inline

Definition at line 670 of file Cloning.hpp.

                      {
        mFactory = inFactory;
        inSource->accept(*this);
        return mReturnVal;
    }

template<typename _Tp >

virtual void torc::generic::VisitorType< _Tp >::visit ( _Tp &  client ) throw ( Error )

pure virtualinherited

Visit the target object. This will typically be a derived leaf type.

Parameters

[in,out]

client

A reference to the target object

Exceptions

Error

Exception generated by any of the functions called from inside visit()

Here is the caller graph for this function:

void torc::generic::_impl::Copier< class View >::visit ( View &  inView ) throw ( Error )

inline

Definition at line 677 of file Cloning.hpp.

                                           {
        try {
            ViewSharedPtr viewPtr;
            mFactory->create(viewPtr);
            viewPtr->setComments(inView.getComments());

            std::list < std::string > userData;
            inView.getUserData(userData);
            viewPtr->setUserData(userData);

            std::vector<StatusSharedPtr> outStatus;
            inView.getStatuses(outStatus);
            for(std::vector<StatusSharedPtr>::iterator it = outStatus.begin();
                it != outStatus.end(); ++it) {
                StatusSharedPtr clonedStatus = clone(*it, mFactory);
                viewPtr->addStatus(clonedStatus);
            }

            viewPtr->setIsExtern(inView.getIsExtern());
            viewPtr->setName(inView.getName());
            viewPtr->setParent(inView.getParent());
            viewPtr->setType(inView.getType());

            std::map<std::string, PropertySharedPtr> outProperties;
            std::vector<PropertySharedPtr> properties;
            inView.getProperties(outProperties);
            for(std::map<std::string, PropertySharedPtr>::iterator it = outProperties.begin();
                it != outProperties.end(); ++it) {
                PropertySharedPtr clonedProperty = clone((*it).second, mFactory);
                properties.push_back(clonedProperty);
            }
            for(std::vector<PropertySharedPtr>::iterator it = properties.begin();
                it != properties.end(); ++it) {
                viewPtr->setProperty((*it)->getName(), *it);
            }

            viewPtr->setOriginalName(inView.getOriginalName());

            ParameterMapSharedPtr oldParams = inView.getParameters();
            ParameterMapSharedPtr newParams = viewPtr->getParameters();
            ParameterContext oldCtx = inView.getParameterContext();
            ParameterContext newCtx = viewPtr->getParameterContext();
            std::map<std::string, ParameterSharedPtr> params;
            oldParams->getAllParameters(oldCtx, params);
            for(std::map<std::string, ParameterSharedPtr>::iterator it = params.begin();
                it != params.end(); ++it) {
                ParameterSharedPtr clonedParam = clone((*it).second, mFactory);
                newParams->set(newCtx, (*it).first, clonedParam);
            }

            std::vector<InstanceSharedPtr> outInstances;
            inView.getInstances(outInstances);
            std::vector<InstanceSharedPtr>::iterator instIt = outInstances.begin();
            for(; instIt != outInstances.end(); ++instIt) {
                InstanceSharedPtr newInst = clone(*instIt, mFactory);
                viewPtr->addInstance(newInst);
            }

            std::vector<PortSharedPtr> outPorts;
            inView.getPorts(outPorts);
            std::vector<PortSharedPtr>::iterator portIt = outPorts.begin();
            for(; portIt != outPorts.end(); ++portIt) {
                PortSharedPtr newPort = clone(*portIt, mFactory);
                viewPtr->addPort(newPort);
            }

            std::vector<PermutableSharedPtr> outPermutables;
            inView.getPermutables(outPermutables);
            for(std::vector<PermutableSharedPtr>::iterator it = outPermutables.begin();
                it != outPermutables.end(); ++it) {
                PermutableSharedPtr clonedPermutable = clonePermutable(*it, mFactory, viewPtr);
                viewPtr->addPermutable(clonedPermutable);
            }

            std::vector<InterfaceJoinedInfoSharedPtr> outJoinedInfos;
            inView.getInterfaceJoinedInfos(outJoinedInfos);
            for(std::vector<InterfaceJoinedInfoSharedPtr>::iterator it = outJoinedInfos.begin();
                it != outJoinedInfos.end(); ++it) {
                InterfaceJoinedInfoSharedPtr clonedJoinedInfo = cloneJoinedInfo(*it, mFactory,
                    viewPtr);
                viewPtr->addInterfaceJoinedInfo(clonedJoinedInfo);
            }

            std::vector<NetSharedPtr> outNets;
            inView.getNets(outNets);
            std::vector<NetSharedPtr>::iterator netIt = outNets.begin();
            for(; netIt != outNets.end(); ++netIt) {
                NetSharedPtr netPtr = clone(*netIt, mFactory);
                viewPtr->addNet(netPtr);
                connectNets(*netIt, netPtr, viewPtr);
            }
            if(NULL != inView.getTiming()) {
                TimingSharedPtr clonedTiming = clone(inView.getTiming(), mFactory);
                viewPtr->setTiming(clonedTiming);
            }
            if(NULL != inView.getInterfaceAttributes()) {
                InterfaceAttributesSharedPtr attrib = inView.getInterfaceAttributes();
                InterfaceAttributesSharedPtr newAttrib(new InterfaceAttributes());
                if(!attrib->getDesignator().empty()) {
                    newAttrib->setDesignator(attrib->getDesignator());
                }
                if(NULL != attrib->getSimulate()) {
                    SimulateSharedPtr clonedSimulate = clone(attrib->getSimulate(), mFactory);
                    newAttrib->setSimulate(clonedSimulate);
                }
                if(NULL != attrib->getTiming()) {
                    TimingSharedPtr clonedTiming = clone(attrib->getTiming(), mFactory);
                    newAttrib->setTiming(clonedTiming);
                }
                newAttrib->setComments(attrib->getComments());

                std::list < std::string > userData;
                attrib->getUserData(userData);
                newAttrib->setUserData(userData);

                viewPtr->setInterfaceAttributes(newAttrib);
            }

            if(NULL != inView.getSimulate()) {
                SimulateSharedPtr clonedSimulate = clone(inView.getSimulate(), mFactory);
                viewPtr->setSimulate(clonedSimulate);
            }

            mReturnVal = viewPtr;
        } catch(Error& e) {
            e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
            throw;
        }
    }

Here is the call graph for this function:

Field Documentation

ObjectFactorySharedPtr torc::generic::_impl::Copier< class View >::mFactory

private

Definition at line 988 of file Cloning.hpp.

Pointer torc::generic::_impl::Copier< class View >::mReturnVal

private

Definition at line 989 of file Cloning.hpp.

---

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

• Cloning.hpp