torc::generic::_impl Namespace Reference

Data Structures
class	Copier
class	Copier< class Root >
class	Copier< class Design >
class	Copier< class Library >
class	Copier< class Cell >
class	Copier< class Status >
class	Copier< class SimulationInfo >
class	Copier< class LogicValue >
class	Copier< class View >
class	Copier< class ScalarPort >
class	Copier< class ScalarPortReference >
class	Copier< class VectorPort >
class	Copier< class VectorPortReference >
class	Copier< class PortBundle >
class	Copier< class PortBundleReference >
class	Copier< class SingleInstance >
class	Copier< class ScalarNet >
class	Copier< class NetBundle >
class	Copier< class VectorNet >
class	Copier< class InstanceArray >
class	Copier< class SingleParameter >
class	Copier< class ParameterArray >
class	Copier< class Property >
class	Copier< class Port >
class	Copier< class PortReference >
class	Copier< class Net >
class	Copier< class Instance >
class	Copier< class Parameter >
class	Copier< class Permutable >
class	Copier< class InterfaceJoinedInfo >
class	Copier< class PortList >
class	Copier< class Simulate >
class	Copier< class LogicalResponse >
class	Copier< class Timing >
class	Copier< class ForbiddenEvent >
class	Copier< class Event >
class	Copier< class LogicElement >

Functions
template<typename _PointerType >
void	copyObject (ScalarPort &inPort, ObjectFactorySharedPtr &inFactory, _PointerType &outPointer) throw (Error)
template<typename _PointerType >
void	copyObject (ScalarPortReference &inPortRef, ObjectFactorySharedPtr &inFactory, _PointerType &outPointer) throw (Error)
template<typename _PointerType >
void	copyObject (VectorPort &inPort, ObjectFactorySharedPtr &inFactory, _PointerType &outPointer) throw (Error)
template<typename _PointerType >
void	copyObject (VectorPortReference &inPortRef, ObjectFactorySharedPtr &inFactory, _PointerType &outPointer) throw (Error)
template<typename _PointerType >
void	copyObject (PortBundle &inPort, ObjectFactorySharedPtr &inFactory, _PointerType &outPointer) throw (Error)
template<typename _PointerType >
void	copyObject (PortBundleReference &inPortRef, ObjectFactorySharedPtr &inFactory, _PointerType &outPointer) throw (Error)
template<typename _PointerType >
void	copyObject (SingleInstance &inInstance, ObjectFactorySharedPtr &inFactory, _PointerType &outPointer) throw (Error)
template<typename _PointerType >
void	copyObject (ScalarNet &inNet, ObjectFactorySharedPtr &inFactory, _PointerType &outPointer) throw (Error)
template<typename _PointerType >
void	copyObject (NetBundle &inNet, ObjectFactorySharedPtr &inFactory, _PointerType &outPointer) throw (Error)
template<typename _PointerType >
void	copyObject (VectorNet &inNet, ObjectFactorySharedPtr &inFactory, _PointerType &outPointer) throw (Error)
template<typename _PointerType >
void	copyObject (InstanceArray &inInstanceArray, ObjectFactorySharedPtr &inFactory, _PointerType &outPointer) throw (Error)
template<typename _PointerType >
void	copyObject (SingleParameter &inSingleParameter, ObjectFactorySharedPtr &inFactory, _PointerType &outPointer) throw (Error)
template<typename _PointerType >
void	copyObject (ParameterArray &inParamArray, ObjectFactorySharedPtr &inFactory, _PointerType &outPointer) throw (Error)

Function Documentation

template<typename _PointerType >

void torc::generic::_impl::copyObject	(	ScalarPort &	inPort,
		ObjectFactorySharedPtr &	inFactory,
		_PointerType &	outPointer
	)
throw	(	Error
	)

Definition at line 993 of file Cloning.hpp.

                                                                               {
    try {
        ScalarPortSharedPtr scalarPort;
        inFactory->create(scalarPort);
        scalarPort->setComments(inPort.getComments());
        scalarPort->setName(inPort.getName());
        scalarPort->setDirection(inPort.getDirection());
        scalarPort->setOriginalName(inPort.getOriginalName());
        scalarPort->setAttributes(inPort.getAttributes());
        scalarPort->setIsExtern(inPort.getIsExtern());
        scalarPort->setParent(inPort.getParent());
        scalarPort->setParentCollection(inPort.getParentCollection());

        std::list < std::string > userData;
        inPort.getUserData(userData);
        scalarPort->setUserData(userData);

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

template<typename _PointerType >

void torc::generic::_impl::copyObject	(	ScalarPortReference &	inPortRef,
		ObjectFactorySharedPtr &	inFactory,
		_PointerType &	outPointer
	)
throw	(	Error
	)

Definition at line 1064 of file Cloning.hpp.

                                                                               {
    try {
        ScalarPortReferenceSharedPtr portRefPtr;
        inFactory->create(portRefPtr);
        portRefPtr->setParent(inPortRef.getParent());
        portRefPtr->setParentCollection(inPortRef.getParentCollection());
        portRefPtr->setParent(inPortRef.getParent());
        portRefPtr->bindToMasterPort(inPortRef.getMaster());
        outPointer = portRefPtr;
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

template<typename _PointerType >

void torc::generic::_impl::copyObject	(	VectorPort &	inPort,
		ObjectFactorySharedPtr &	inFactory,
		_PointerType &	outPointer
	)
throw	(	Error
	)

Definition at line 1113 of file Cloning.hpp.

                                                                               {
    try {
        VectorPortSharedPtr vectorPortPtr;
        inFactory->create(vectorPortPtr);
        vectorPortPtr->setComments(inPort.getComments());
        vectorPortPtr->setName(inPort.getName());
        vectorPortPtr->setDirection(inPort.getDirection());
        vectorPortPtr->setOriginalName(inPort.getOriginalName());
        vectorPortPtr->setAttributes(inPort.getAttributes());
        vectorPortPtr->setIsExtern(inPort.getIsExtern());
        vectorPortPtr->setParent(inPort.getParent());
        vectorPortPtr->setParentCollection(inPort.getParentCollection());

        std::list < std::string > userData;
        inPort.getUserData(userData);
        vectorPortPtr->setUserData(userData);

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

        //CREATE AND POPULATE CHILDREN
        std::vector < size_t > outLimits;
        inPort.getLimits(outLimits);
        vectorPortPtr->constructChildren(inFactory, outLimits);
        VectorPort::BaseType::List children;
        inPort.getCreatedChildren(children);
        for(VectorPort::BaseType::List::iterator it = children.begin(); it != children.end();
            ++it) {
            PortSharedPtr child = *it;
            PortSharedPtr clonedChild = vectorPortPtr->get(
                IndexFinder<Port, VectorPortBit>()(child));
            clonedChild->setComments(child->getComments());
            clonedChild->setName(child->getName());
            clonedChild->setDirection(child->getDirection());
            clonedChild->setOriginalName(child->getOriginalName());
            clonedChild->setAttributes(child->getAttributes());
            clonedChild->setIsExtern(child->getIsExtern());
            clonedChild->setParent(child->getParent());

            std::map < std::string, PropertySharedPtr > outProperties;
            std::vector < PropertySharedPtr > properties;
            child->getProperties(outProperties);
            for(std::map<std::string, PropertySharedPtr>::iterator it = outProperties.begin();
                it != outProperties.end(); ++it) {
                PropertySharedPtr clonedProperty = clone((*it).second, inFactory);
                properties.push_back(clonedProperty);
            }
            for(std::vector<PropertySharedPtr>::iterator it = properties.begin();
                it != properties.end(); ++it) {
                clonedChild->setProperty((*it)->getName(), *it);
            }
        }
        //CONNECTIONS ARE NOT COPIED
        outPointer = vectorPortPtr;
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

template<typename _PointerType >

void torc::generic::_impl::copyObject	(	VectorPortReference &	inPortRef,
		ObjectFactorySharedPtr &	inFactory,
		_PointerType &	outPointer
	)
throw	(	Error
	)

Definition at line 1217 of file Cloning.hpp.

                                                                               {
    try {
        VectorPortReferenceSharedPtr vectorPortRefPtr;
        inFactory->create(vectorPortRefPtr);
        //CREATE AND POPULATE CHILDREN
        std::vector < size_t > outLimits;
        inPortRef.getLimits(outLimits);
        vectorPortRefPtr->constructChildren(inFactory, outLimits);
        vectorPortRefPtr->setParent(inPortRef.getParent());
        vectorPortRefPtr->setParentCollection(inPortRef.getParentCollection());
        vectorPortRefPtr->bindToMasterPort(inPortRef.getMaster());
        VectorPortReference::BaseType::List children;
        inPortRef.getCreatedChildren(children);
        for(VectorPortReference::BaseType::List::iterator it = children.begin();
            it != children.end(); ++it) {
            PortReferenceSharedPtr child = *it;
            PortReferenceSharedPtr clonedChild = vectorPortRefPtr->get(
                IndexFinder<PortReference, VectorPortBitReference>()(child));
            clonedChild->setParent(child->getParent());
            //        clonedChild->bindToMasterPort(child->getMaster());
        }
        //CONNECTIONS ARE NOT COPIED
        outPointer = vectorPortRefPtr;
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

template<typename _PointerType >

void torc::generic::_impl::copyObject	(	PortBundle &	inPort,
		ObjectFactorySharedPtr &	inFactory,
		_PointerType &	outPointer
	)
throw	(	Error
	)

Definition at line 1280 of file Cloning.hpp.

                                                                               {
    try {
        PortBundleSharedPtr portBundlePtr;
        inFactory->create(portBundlePtr);
        portBundlePtr->setComments(inPort.getComments());
        portBundlePtr->setName(inPort.getName());
        portBundlePtr->setIsExtern(inPort.getIsExtern());
        portBundlePtr->setParent(inPort.getParent());
        portBundlePtr->setParentCollection(inPort.getParentCollection());

        std::list < std::string > userData;
        inPort.getUserData(userData);
        portBundlePtr->setUserData(userData);

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

        portBundlePtr->setDirection(inPort.getDirection());
        portBundlePtr->setAttributes(inPort.getAttributes());
        portBundlePtr->setOriginalName(inPort.getOriginalName());
        std::vector<PortSharedPtr> children;
        inPort.getChildren(children);
        for(std::vector<PortSharedPtr>::iterator it = children.begin(); it != children.end();
            ++it) {
            PortSharedPtr clonedPort = clone(*it, inFactory);
            portBundlePtr->addChild(clonedPort);
        }
        //CONNECTIONS ARE NOT COPIED
        outPointer = portBundlePtr;
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

template<typename _PointerType >

void torc::generic::_impl::copyObject	(	PortBundleReference &	inPortRef,
		ObjectFactorySharedPtr &	inFactory,
		_PointerType &	outPointer
	)
throw	(	Error
	)

Definition at line 1359 of file Cloning.hpp.

                                                                               {
    try {
        PortBundleReferenceSharedPtr portBundleRefPtr;
        inFactory->create(portBundleRefPtr);
        portBundleRefPtr->setParent(inPortRef.getParent());
        portBundleRefPtr->setParentCollection(inPortRef.getParentCollection());
        std::vector<PortReferenceSharedPtr> children;
        inPortRef.getChildren(children);
        for(std::vector<PortReferenceSharedPtr>::iterator it = children.begin();
            it != children.end(); ++it) {
            PortReferenceSharedPtr clonedPortRef = clone(*it, inFactory);
            portBundleRefPtr->addChild(clonedPortRef);
        }
        portBundleRefPtr->bindToMasterPort(inPortRef.getMaster());

        //CONNECTIONS ARE NOT COPIED
        outPointer = portBundleRefPtr;
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

template<typename _PointerType >

void torc::generic::_impl::copyObject	(	SingleInstance &	inInstance,
		ObjectFactorySharedPtr &	inFactory,
		_PointerType &	outPointer
	)
throw	(	Error
	)

Definition at line 1416 of file Cloning.hpp.

                                                                               {
    try {
        SingleInstanceSharedPtr instPtr;
        inFactory->create(instPtr);
        instPtr->setComments(inInstance.getComments());
        instPtr->setName(inInstance.getName());
        instPtr->setOriginalName(inInstance.getOriginalName());
        instPtr->setParent(inInstance.getParent());

        std::vector<PortReferenceSharedPtr> outPortRefs;
        inInstance.getPortReferences(outPortRefs);
        for(std::vector<PortReferenceSharedPtr>::iterator it = outPortRefs.begin();
            it != outPortRefs.end(); ++it) {
            PortReferenceSharedPtr clonedRef = clone(*it, inFactory);
            instPtr->addPortReference(clonedRef);
        }
        instPtr->bindToMasterView(inInstance.getMaster());
        //THIS SHOULD BIND ALL THE CLONED PORTREFS TO THE MASTERS
        copyParams(inInstance, instPtr, inFactory);

        std::list < std::string > userData;
        inInstance.getUserData(userData);
        instPtr->setUserData(userData);

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

        if(NULL != inInstance.getTiming()) {
            TimingSharedPtr clonedTiming = clone(inInstance.getTiming(), inFactory);
            instPtr->setTiming(clonedTiming);
        }

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

Here is the call graph for this function:

template<typename _PointerType >

void torc::generic::_impl::copyObject	(	ScalarNet &	inNet,
		ObjectFactorySharedPtr &	inFactory,
		_PointerType &	outPointer
	)
throw	(	Error
	)

Definition at line 1500 of file Cloning.hpp.

                                                                               {
    try {
        ScalarNetSharedPtr netPtr;
        inFactory->create(netPtr);
        netPtr->setComments(inNet.getComments());
        netPtr->setName(inNet.getName());
        netPtr->setParent(inNet.getParent());
        netPtr->setOriginalName(inNet.getOriginalName());

        std::list < std::string > userData;
        inNet.getUserData(userData);
        netPtr->setUserData(userData);

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

        std::vector<NetSharedPtr> outNets;
        inNet.getSubnets(outNets);
        std::vector<NetSharedPtr>::iterator netIt = outNets.begin();
        for(; netIt != outNets.end(); ++netIt) {
            NetSharedPtr childNet = clone(*netIt, inFactory);
            netPtr->addSubnet(childNet);
        }
        //DO NOT CONNECT
        outPointer = netPtr;
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

template<typename _PointerType >

void torc::generic::_impl::copyObject	(	NetBundle &	inNet,
		ObjectFactorySharedPtr &	inFactory,
		_PointerType &	outPointer
	)
throw	(	Error
	)

Definition at line 1575 of file Cloning.hpp.

                                                                               {
    try {
        NetBundleSharedPtr netBundlePtr;
        inFactory->create(netBundlePtr);
        netBundlePtr->setComments(inNet.getComments());
        netBundlePtr->setName(inNet.getName());
        netBundlePtr->setParent(inNet.getParent());
        netBundlePtr->setOriginalName(inNet.getOriginalName());

        std::list < std::string > userData;
        inNet.getUserData(userData);
        netBundlePtr->setUserData(userData);

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

        std::vector<NetSharedPtr> outChildren;
        inNet.getChildren(outChildren);
        std::vector<NetSharedPtr>::iterator it = outChildren.begin();
        for(; it != outChildren.end(); ++it) {
            NetSharedPtr clonedChild = clone(*it, inFactory);
            netBundlePtr->addChild(clonedChild);
        }
        std::vector<NetSharedPtr> outNets;
        inNet.getSubnets(outNets);
        std::vector<NetSharedPtr>::iterator netIt = outNets.begin();
        for(; netIt != outNets.end(); ++netIt) {
            NetSharedPtr childNet = clone(*netIt, inFactory);
            netBundlePtr->addSubnet(childNet);
        }
        outPointer = netBundlePtr;
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

template<typename _PointerType >

void torc::generic::_impl::copyObject	(	VectorNet &	inNet,
		ObjectFactorySharedPtr &	inFactory,
		_PointerType &	outPointer
	)
throw	(	Error
	)

Definition at line 1656 of file Cloning.hpp.

                                                                               {
    try {
        VectorNetSharedPtr vectorNetPtr;
        inFactory->create(vectorNetPtr);
        vectorNetPtr->setComments(inNet.getComments());
        vectorNetPtr->setName(inNet.getName());
        vectorNetPtr->setParent(inNet.getParent());
        vectorNetPtr->setOriginalName(inNet.getOriginalName());

        std::list < std::string > userData;
        inNet.getUserData(userData);
        vectorNetPtr->setUserData(userData);

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

        //CREATE AND POPULATE CHILDREN
        std::vector < size_t > outLimits;
        inNet.getLimits(outLimits);
        vectorNetPtr->constructChildren(inFactory, outLimits);
        VectorNet::BaseType::List children;
        inNet.getCreatedChildren(children);
        for(VectorNet::BaseType::List::iterator it = children.begin(); it != children.end(); ++it) {
            NetSharedPtr child = *it;
            NetSharedPtr clonedChild = vectorNetPtr->get(IndexFinder<Net, VectorNetBit>()(child));
            clonedChild->setComments(child->getComments());
            clonedChild->setName(child->getName());
            clonedChild->setParent(child->getParent());
            clonedChild->setOriginalName(child->getOriginalName());

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

            std::vector<NetSharedPtr> outNets;
            child->getSubnets(outNets);
            std::vector<NetSharedPtr>::iterator netIt = outNets.begin();
            for(; netIt != outNets.end(); ++netIt) {
                NetSharedPtr clonedChildNet = clone(*netIt, inFactory);
                clonedChild->addSubnet(clonedChildNet);
            }
        }
        //CONNECTIONS ARE NOT COPIED
        std::vector<NetSharedPtr> outNets;
        inNet.getSubnets(outNets);
        std::vector<NetSharedPtr>::iterator netIt = outNets.begin();
        for(; netIt != outNets.end(); ++netIt) {
            NetSharedPtr childNet = clone(*netIt, inFactory);
            vectorNetPtr->addSubnet(childNet);
        }

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

Here is the call graph for this function:

template<typename _PointerType >

void torc::generic::_impl::copyObject	(	InstanceArray &	inInstanceArray,
		ObjectFactorySharedPtr &	inFactory,
		_PointerType &	outPointer
	)
throw	(	Error
	)

Definition at line 1767 of file Cloning.hpp.

                                                                               {
    try {
        InstanceArraySharedPtr instArrayPtr;
        inFactory->create(instArrayPtr);
        instArrayPtr->setComments(inInstanceArray.getComments());
        instArrayPtr->setName(inInstanceArray.getName());
        instArrayPtr->setParent(inInstanceArray.getParent());
        instArrayPtr->setOriginalName(inInstanceArray.getOriginalName());

        std::list < std::string > userData;
        inInstanceArray.getUserData(userData);
        instArrayPtr->setUserData(userData);

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

        //WE intentionally bind here
        //This will help when children are bound to different masters
        //The actual child binding will be done later
        instArrayPtr->bindToMasterView(inInstanceArray.getMaster());
        copyParams(inInstanceArray, instArrayPtr, inFactory);

        //CREATE AND POPULATE CHILDREN
        std::vector < size_t > outLimits;
        inInstanceArray.getLimits(outLimits);
        instArrayPtr->constructChildren(inFactory, outLimits);
        InstanceArray::BaseVectorType::List children;
        inInstanceArray.getChildren(children);
        for(InstanceArray::BaseVectorType::List::iterator it = children.begin();
            it != children.end(); ++it) {
            InstanceSharedPtr orig = *it;
            InstanceSharedPtr cloned = instArrayPtr->get(
                IndexFinder<Instance, InstanceArrayMember>()(orig));
            cloned->setComments(orig->getComments());
            cloned->setName(orig->getName());
            cloned->setOriginalName(orig->getOriginalName());
            cloned->setParent(orig->getParent());

            std::list < std::string > userData;
            orig->getUserData(userData);
            cloned->setUserData(userData);

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

            std::vector<PortReferenceSharedPtr> outPortRefs;
            orig->getPortReferences(outPortRefs);
            for(std::vector<PortReferenceSharedPtr>::iterator pit = outPortRefs.begin();
                pit != outPortRefs.end(); ++pit) {
                PortReferenceSharedPtr clonedRef = clone(*pit, inFactory);
                cloned->addPortReference(clonedRef);
            }
            cloned->bindToMasterView(orig->getMaster());
            copyParams(*orig, cloned, inFactory);
        }
        outPointer = instArrayPtr;
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

template<typename _PointerType >

void torc::generic::_impl::copyObject	(	SingleParameter &	inSingleParameter,
		ObjectFactorySharedPtr &	inFactory,
		_PointerType &	outPointer
	)
throw	(	Error
	)

Definition at line 1883 of file Cloning.hpp.

                                                                               {
    try {
        SingleParameterSharedPtr singleParameterPtr;
        inFactory->create(singleParameterPtr);
        singleParameterPtr->setName(inSingleParameter.getName());
        singleParameterPtr->setUnit(inSingleParameter.getUnit());
        singleParameterPtr->setValue(inSingleParameter.getValue());
        singleParameterPtr->setOriginalName(inSingleParameter.getOriginalName());
        outPointer = singleParameterPtr;
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

template<typename _PointerType >

void torc::generic::_impl::copyObject	(	ParameterArray &	inParamArray,
		ObjectFactorySharedPtr &	inFactory,
		_PointerType &	outPointer
	)
throw	(	Error
	)

Definition at line 1932 of file Cloning.hpp.

                                                                               {
    try {
        ParameterArraySharedPtr paramArrayPtr;
        inFactory->create(paramArrayPtr);
        paramArrayPtr->setName(inParamArray.getName());
        paramArrayPtr->setOriginalName(inParamArray.getOriginalName());

        std::vector < size_t > outLimits;
        inParamArray.getLimits(outLimits);
        paramArrayPtr->constructChildren(inFactory, outLimits);
        ParameterArray::BaseVectorType::List children;
        inParamArray.getChildren(children);
        ParameterArray::BaseVectorType::List::iterator it = children.begin();
        for(; it != children.end(); ++it) {
            ParameterSharedPtr orig = *it;
            ParameterSharedPtr cloned = paramArrayPtr->get(
                IndexFinder<Parameter, ParameterArrayElement>()(orig));
            cloned->setName(orig->getName());
            cloned->setUnit(orig->getUnit());
            cloned->setValue(orig->getValue());
        }
        outPointer = paramArrayPtr;
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function: