torc/generic/om/Net.cpp

// Torc - Copyright 2011 University of Southern California.  All Rights Reserved.
// $HeadURL: https://torc-isi.svn.sourceforge.net/svnroot/torc-isi/branches/staging/0.9/src/torc/generic/om/Net.cpp $
// $Id: Net.cpp 10 2011-10-12 18:40:16Z nsteiner $

// This program is free software: you can redistribute it and/or modify it under the terms of the 
// GNU General Public License as published by the Free Software Foundation, either version 3 of the 
// License, or (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; 
// without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See 
// the GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License along with this program.  If 
// not, see <http://www.gnu.org/licenses/>.

#include "torc/generic/om/DumpRestoreConfig.hpp"

#ifndef HAVE_CONFIG_H
#include "torc/generic/config.h"
#endif

//BOOST
#include <boost/bind.hpp>
#ifdef GENOM_SERIALIZATION
#include <boost/archive/binary_iarchive.hpp>
#include <boost/archive/binary_oarchive.hpp>
#include <boost/serialization/is_abstract.hpp>
#include <boost/serialization/base_object.hpp>
#include <boost/serialization/shared_ptr.hpp>
#include <boost/serialization/list.hpp>
#endif //GENOM_SERIALIZATION

#include "torc/generic/util/Log.hpp"
#include "torc/generic/om/Net.hpp"
#include "torc/generic/om/Port.hpp"
#include "torc/generic/om/PortReference.hpp"
#include "torc/generic/om/PortList.hpp"
#include "torc/generic/om/View.hpp"

#ifdef GENOM_SERIALIZATION
BOOST_IS_ABSTRACT( torc::generic::Composite< torc::generic::Net > )
#endif //GENOM_SERIALIZATION

namespace torc {

namespace generic {

Net::Net()
    : Composite<Net>(),
    Commentable(),
    Connectable(),
    Nameable(),
    PropertyContainer(),
    Renamable(),
    Visitable(),
    ParentedObject<View>(),
    UserDataContainer(),
    mAttributes() {
}

Net::~Net() throw() {
    try
    {
        disconnect();
    }
    catch( Error &e )
    {
        log("Cannot propagate received error\n");
    }
}

/**
 * Add a subnet to this net.
 *
 * @param[in] inSubnet Subnet to be added
 *
 * @exception Error Could not add subnet, because subnet name is empty
 * @exception Error Could not add subnet, because subnet name is already exists
 */
void
Net::addSubnet(
    const NetSharedPtr &inSubnet) throw(Error) {
    std::string name = inSubnet->getName();
    if( name.empty() )
    {
        Error e( eMessageIdErrorEmptyItemName,
            __FUNCTION__, __FILE__, __LINE__ );
        e.saveContextData("Subnet name", name);
        throw e;
    }
    if( false == mSubnets.set( name, inSubnet ) )
    {
        Error e( eMessageIdErrorItemAlreadyExists,
            __FUNCTION__, __FILE__, __LINE__ );
        e.saveContextData("Subnet name", name);
        throw e;
    }
    inSubnet->setParentNet( getSharedThis() );
    return;
}

/**
 * Find a subnet from belonging to this net.
 *
 * @param[in] inName Name of the subnet. If not found, empty pointer is returned
 *
 */
NetSharedPtr
Net::findSubnet(const std::string &inName) throw(Error) {
    NetSharedPtr subnet;
    mSubnets.get( inName, subnet );
    return subnet;
}

/**
 * Remove a subnet from this net.
 *
 * @param inName Name of the object to be delete
 *
 * @exception Error Could not remove subnet, because subnet name is empty
 * @exception Error Could not remove subnet, because subnet not present.
 */
void
Net::removeSubnet(const std::string &inName) throw(Error) {
    if( inName.empty() )
    {
        Error e( eMessageIdErrorEmptyItemName,
            __FUNCTION__, __FILE__, __LINE__ );
        e.saveContextData("Subnet name", inName);
        throw e;
    }
    if( false == mSubnets.remove( inName ) )
    {
        Error e( eMessageIdErrorItemNotFound,
            __FUNCTION__, __FILE__, __LINE__ );
        e.saveContextData("Subnet name", inName);
        throw e;
    }
    return;
}

void
Net::setParentNet( const NetSharedPtr &inParent ) throw() {
    mParentNet = inParent;
}

/**
 * Set the attributes of the net. Attributes include criticality, netDelay etc.
 *
 * @param[in] inSource Pointer to NetAttributes object.
 */
void
Net::setAttributes(
        const NetAttributesSharedPtr & inSource) throw() {
    mAttributes = inSource;
}

void
Net::setSubnets(
    const std::vector< NetSharedPtr > & inSource) throw(Error) {
    std::vector< NetSharedPtr >::const_iterator subnet
                                        = inSource.begin();
    std::vector< NetSharedPtr >::const_iterator subEnd
                                        = inSource.end();
    for(; subnet != subEnd; ++subnet )
    {
        try
        {
            addSubnet( *subnet );
        }
        catch( Error &e )
        {
            e.setCurrentLocation(
                __FUNCTION__, __FILE__, __LINE__ );
            throw;
        }
    }
}

/**
 * Connect a port to this net.
 *
 * @param[in] inPort port to be added. Empty pointer is ignored.
 *
 * @exception Error Could not add Port, because Port name is empty
 * @exception Error Could not add Port, because Port name is already exists
 */
void
Net::addConnectedPort(
    const PortSharedPtr &inPort) throw(Error) {
    if( !inPort )
    {
        return;
    }
    std::string name = inPort->getName();
    if( name.empty() )
    {
        Error e( eMessageIdErrorEmptyItemName,
            __FUNCTION__, __FILE__, __LINE__ );
        e.saveContextData("Port name", name);
        throw e;
    }
    mConnectedPorts.push_back( inPort );
    return;
}

/**
 * Find a port connected to this net.
 *
 * @param[in] inName Name of the port. If not found, empty pointer is returned
 */
PortSharedPtr
Net::findConnectedPort( const std::string &inName) throw(Error) {
    PortSharedPtr port;
    std::list< PortSharedPtr >::iterator it
        = find_if( mConnectedPorts.begin(), mConnectedPorts.end(),
            boost::bind<bool>( std::equal_to<std::string>(),
                boost::bind( boost::mem_fn( &Port::getName ), _1),
                                                    inName)); 
    if( it != mConnectedPorts.end() )
    {
        port = *it;
    }
    return port;
}

void
Net::getConnectedPorts(
    std::vector< PortSharedPtr > &outPorts,
    bool inSkipChildConnections ) const throw() {
    outPorts.insert( outPorts.end(),
            mConnectedPorts.begin(), mConnectedPorts.end() );
    return;
}


void
Net::removeConnectedPort( const PortSharedPtr &inPort) throw(Error) {
    std::list< PortSharedPtr >::iterator it
        = find( mConnectedPorts.begin(), mConnectedPorts.end(),
                inPort);
    if( it != mConnectedPorts.end() )
    {
        mConnectedPorts.erase( it );
    }
    else
    {
        Error e( eMessageIdErrorItemNotFound,
            __FUNCTION__, __FILE__, __LINE__ );
        e.saveContextData("Name", inPort->getName() );
        throw e;
    }
    return;

}

void
Net::setConnectedPorts(
    const std::vector< PortSharedPtr > &inSource) throw(Error) {
    std::vector< PortSharedPtr >::const_iterator port
                                = inSource.begin();
    std::vector< PortSharedPtr >::const_iterator portEnd
                                = inSource.end();
    for( ; port != portEnd; ++port )
    {
        try
        {
            addConnectedPort( *port );
        }
        catch( Error &e )
        {
            e.setCurrentLocation(
                __FUNCTION__, __FILE__, __LINE__ );
            throw;
        }
    }

}

void
Net::getConnectedPortLists(
    std::vector< PortListSharedPtr > &outPortList) const throw() {
    outPortList.insert( outPortList.end(),
            mConnectedPortLists.begin(), mConnectedPortLists.end() );
    return;
}

void
Net::addConnectedPortList(
    const PortListSharedPtr & inPortList) throw(Error) {
    if( !inPortList )
    {
        return;
    }
    mConnectedPortLists.push_back( inPortList );
    return;
}

void
Net::removeConnectedPortList(
        const PortListSharedPtr &inPortList) throw(Error) {
    std::list< PortListSharedPtr >::iterator it
        = find( mConnectedPortLists.begin(), mConnectedPortLists.end(),
                inPortList);
    if( it != mConnectedPortLists.end() )
    {
        mConnectedPortLists.erase( it );
    }
    else
    {
        Error e( eMessageIdErrorItemNotFound,
            __FUNCTION__, __FILE__, __LINE__ );
        e.saveContextData("Name", std::string("PortList") );
        throw e;
    }
    return;

    
}

/**
 * Connect a port reference to this net.
 *
 * @param[in] inPortRef Port reference to be added
 *
 * @exception Error Could not add port reference
 */
void
Net::addConnectedPortReference(
    const PortReferenceSharedPtr & inPortRef) throw(Error) {
    if( !inPortRef )
    {
        return;
    }
    std::string name = inPortRef->getName();
    if( name.empty() )
    {
        Error e( eMessageIdErrorEmptyItemName,
            __FUNCTION__, __FILE__, __LINE__ );
        e.saveContextData("PortReference name", name);
        throw e;
    }
    mConnectedPortRefs.push_back( inPortRef );
    return;
}

/**
 * Find a port reference connected to this net.
 *
 * @param[in] inName Name of the port reference. If not found, empty pointer is returned
 */
PortReferenceSharedPtr
Net::findConnectedPortReference(
                const std::string &inName) throw(Error) {
    PortReferenceSharedPtr portRef;
    std::list< PortReferenceSharedPtr >::iterator it
        = find_if(
            mConnectedPortRefs.begin(), mConnectedPortRefs.end(),
            boost::bind<bool>( std::equal_to<std::string>(),
                boost::bind(
                    boost::mem_fn(&PortReference::getName ), _1),
                    inName)); 
    if( it != mConnectedPortRefs.end() )
    {
        portRef = *it;
    }
    return portRef;
}

void
Net::getConnectedPortRefs(
    std::vector< PortReferenceSharedPtr > &outPortRefs,
    bool inSkipChildConnections ) const throw() {
    outPortRefs.insert( outPortRefs.end(),
            mConnectedPortRefs.begin(), mConnectedPortRefs.end() );
    return;
}

void
Net::removeConnectedPortReference(
                const PortReferenceSharedPtr &inPortRef) throw(Error) {
    std::list< PortReferenceSharedPtr >::iterator it
        = find( mConnectedPortRefs.begin(), mConnectedPortRefs.end(),
                inPortRef );
    if( it != mConnectedPortRefs.end() )
    {
        mConnectedPortRefs.erase(it);
    }
    else
    {
        Error e( eMessageIdErrorItemNotFound,
            __FUNCTION__, __FILE__, __LINE__ );
        e.saveContextData("PortReference name", inPortRef->getName());
        throw e;
    }
    return;
}

void
Net::setConnectedPortRefs(
    const std::vector< PortReferenceSharedPtr > & inSource) throw(Error) {
    std::vector< PortReferenceSharedPtr >::const_iterator portRef = inSource.begin();
    std::vector< PortReferenceSharedPtr >::const_iterator portRefEnd = inSource.end();
    for( ; portRef != portRefEnd; ++portRef )
    {
        try
        {
            addConnectedPortReference( *portRef );
        }
        catch( Error &e )
        {
            e.setCurrentLocation(
                __FUNCTION__, __FILE__, __LINE__ );
            throw;
        }
    }
}

void
Net::disconnect() throw(Error) {
    if( !getName().empty() )
    {
        log("Clearing net %s\n", getName().c_str() );
    }
    mSubnets.clear();
    //Don't try to optimize the following by using applyOnAll
    // it causes memory corruption as the SymTab itself changes
    // during disconnection
    std::vector< PortSharedPtr > ports;
    getConnectedPorts( ports, true );
    void (Connectable::*fp)(const NetSharedPtr & net)
                                = &Connectable::disconnect;
    std::for_each( ports.begin(), ports.end(),
                       boost::bind( fp, _1, getSharedThis()));
    std::vector< PortReferenceSharedPtr > portRefs;
    getConnectedPortRefs( portRefs, true );
    std::for_each( portRefs.begin(), portRefs.end(),
                       boost::bind( fp, _1, getSharedThis()));
    std::vector< PortListSharedPtr > portLists;
    getConnectedPortLists( portLists );
    std::for_each( portLists.begin(), portLists.end(),
                   boost::bind( fp, _1, getSharedThis()));
    Connectable::disconnect();
}

#ifdef GENOM_SERIALIZATION
template<class Archive> void
Net::serialize( Archive &ar, unsigned int ) {
    ar & boost::serialization::base_object< Commentable >( *this );
    ar & boost::serialization::base_object< Connectable >( *this );
    ar & boost::serialization::base_object< Nameable >( *this );
    ar & boost::serialization::base_object< PropertyContainer >(
                                                           *this );
    ar & boost::serialization::base_object< Renamable >( *this );
    ar & boost::serialization::base_object< Visitable >( *this );
    ar & boost::serialization::base_object<
                                        Composite<Net> >( *this );
    ar & mSubnets;
    ar & mConnectedPorts;
    ar & mConnectedPortRefs;
    ar & mConnectedPortLists;
}
//TO SATISFY THE LINKER
template void
Net::serialize<boost::archive::binary_iarchive>(
        boost::archive::binary_iarchive & ar, const unsigned int);

template void
Net::serialize<boost::archive::binary_oarchive>(
        boost::archive::binary_oarchive & ar, const unsigned int);

#endif //GENOM_SERIALIZATION

} // namespace torc::generic

} // namespace torc

---