torc/generic/om/InterfaceJoinedInfo.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/InterfaceJoinedInfo.cpp $
// $Id: InterfaceJoinedInfo.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/InterfaceJoinedInfo.hpp"
#include "torc/generic/om/Port.hpp"
#include "torc/generic/om/PortList.hpp"

namespace torc {

namespace generic {

/**
 * Create an interface joining information .
 *
 * @param[in] inPorts List of ports to this joining information.
 * @param[in] inPortLists List of portLists to this joining information.
 * @param[in] inViewPtr Pointer to parented(View) object.
 * @param[in] inParentJoinedInfo Pointer to parent joining information.
 *
 * @return Pointer to created interface joining information.
 */
InterfaceJoinedInfoSharedPtr
InterfaceJoinedInfo::Factory::newInterfaceJoinedInfoPtr( 
        const std::list< PortSharedPtr > & inPorts,
        const std::list< PortListSharedPtr > & inPortLists,
        const ViewSharedPtr & inViewPtr,
        const InterfaceJoinedInfoSharedPtr & inParentJoinedInfo ) throw(Error) {
    try
    {
        InterfaceJoinedInfoSharedPtr newInterfaceJoinedInfo;
        create( newInterfaceJoinedInfo );
        newInterfaceJoinedInfo->setPorts( inPorts );
        if( inParentJoinedInfo )
        {
            inParentJoinedInfo->addChildJoinedInfo( newInterfaceJoinedInfo );
        }
        else if( inViewPtr )
        {
            inViewPtr->addInterfaceJoinedInfo( newInterfaceJoinedInfo );
        }
        return newInterfaceJoinedInfo;
    }
    catch( Error &e )
    {
        e.setCurrentLocation(
            __FUNCTION__, __FILE__, __LINE__ );
        throw;
    }
}

/**
 * Set the interface joining type
 * @param[in] inSource Interface joining type
 */
void 
InterfaceJoinedInfo::setJoinedType(const JoinedType & value) throw() {
    mJoinedType = value;
}

/**
 * Add a port to the list of ports. Empty pointer is ignored.
 *
 * @param[in] inPort Pointer to port to be added.
 * @exception Error Could not add port, because Port name is empty   
 */
void
InterfaceJoinedInfo::addPort( 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;
    }
    mJoinedPorts.push_back( inPort );
}

/**
 * Add a portList to the list of portLists. Empty pointer is ignored.
 *
 * @param[in] inPortList Pointer to portList to be added.
*/
void
InterfaceJoinedInfo::addPortList( const PortListSharedPtr & inPortList ) throw() {
    if( !inPortList )
    {
        return;
    }
    mJoinedPortLists.push_back( inPortList );
}

/**
 * Set the list of joined ports of an interface
 *
 * @param[in] inSource List of ports to be joined to an interface
 */
void
InterfaceJoinedInfo::setPorts( 
        const std::list< PortSharedPtr > & inSource ) throw() {
    std::list< PortSharedPtr >::const_iterator port = inSource.begin();
    std::list< PortSharedPtr >::const_iterator end = inSource.end();
    for(;port != end; ++port)
    {
        try
        {
            addPort( *port );
        }
        catch( Error &e )
        {
            e.setCurrentLocation(
                __FUNCTION__, __FILE__, __LINE__ );
            throw;
        }
    }
}

/**
 * Set the list of joined portLists of an interface
 *
 * @param[in] inSource List of portLists to be joined to an interface
 */
void
InterfaceJoinedInfo::setPortLists( 
        const std::list< PortListSharedPtr > & inSource ) throw() {
    std::list< PortListSharedPtr >::const_iterator portList = inSource.begin();
    std::list< PortListSharedPtr >::const_iterator end = inSource.end();
    for(;portList != end; ++portList)
    {
        try
        {
            addPortList( *portList );
        }
        catch( Error &e )
        {
            e.setCurrentLocation(
                __FUNCTION__, __FILE__, __LINE__ );
            throw;
        }
    }
}

/**
 * Set the nested joining information
 *
 * @param[in] inSource Vector containing joining informations
 * @exception Error Could not add child joined info because
 * pointer to the joined info does not exist
 */
void 
InterfaceJoinedInfo::setChildren(
        const std::vector< InterfaceJoinedInfoSharedPtr > & inSource ) throw() {
    std::vector< InterfaceJoinedInfoSharedPtr >::const_iterator entry = inSource.begin();
    std::vector< InterfaceJoinedInfoSharedPtr >::const_iterator end = inSource.end();
    for(; entry != end; ++entry )
    {
        try
        {
            addChildJoinedInfo( *entry );
        }
        catch( Error &e )
        {
            e.setCurrentLocation(
                __FUNCTION__, __FILE__, __LINE__ );
            throw;
        }
    }
}

/**
 * Add a joined info to parent joined info
 *
 * @param[in] inChildJoinInfo Child interface joined info to be added to parent
 */
bool 
InterfaceJoinedInfo::addChildJoinedInfo(
        const InterfaceJoinedInfoSharedPtr & inChildJoinInfo) throw() {
    if( !inChildJoinInfo )
    {
        Error e( eMessageIdErrorPointerToItemDoesNotExist,
            __FUNCTION__, __FILE__, __LINE__ );
        e.saveContextData("Pointer to the joined info object does not exist", inChildJoinInfo);
        throw e;
    }
    if( inChildJoinInfo ) {
        mChildren.push_back( inChildJoinInfo );
        return true;
    }
    else {
        return false;
    }
}

void
InterfaceJoinedInfo::accept(BaseVisitor & visitor) throw(Error) {
    try
    {
        runVisitor( *this, visitor );
    }
    catch( Error &e )
    {
        e.setCurrentLocation(
            __FUNCTION__, __FILE__, __LINE__ );
        throw;
    }
}

/**
 * Set the relation type.
 *
 * @param[in] inSource RelationType
 */
void
InterfaceJoinedInfo::setRelationType(const RelationType & inSource) throw() {
    mRelationType = inSource;
}

/**
 * Get the total number of bits of the composition
 * @return Number of bits
 */
size_t
InterfaceJoinedInfo::getSize() const throw() {
    size_t size = 0;
    size_t pSize = 0;
    size_t cSize = 0;
    InterfaceJoinedInfo::RelationType rType = getRelationType();

    std::vector< InterfaceJoinedInfoSharedPtr > outJoinedInfos;
    getChildren( outJoinedInfos );
    std::vector< InterfaceJoinedInfoSharedPtr >::iterator joinedInfoIt 
                    = outJoinedInfos.begin();

    std::list< PortSharedPtr > outPorts;
    getPorts( outPorts );
    std::list< PortSharedPtr >::iterator portIt
                    = outPorts.begin();

    std::list< PortListSharedPtr > outPortLists;
    getPortLists( outPortLists );
    std::list< PortListSharedPtr >::iterator portListIt
                    = outPortLists.begin();

    if( InterfaceJoinedInfo::eRelationTypeParent == rType )
    {
        if( !outPorts.empty() )
        {
            pSize = (*portIt)->getSize();
        }
        else if( !outPortLists.empty() )
        {
            pSize = (*portListIt)->getSize();
        }
        else if( !outJoinedInfos.empty() )
        {
            for( ; joinedInfoIt != outJoinedInfos.end() ; joinedInfoIt ++ )
            {
                pSize += (*joinedInfoIt)->getSize();
                for( ; portIt != outPorts.end(); portIt ++ )
                {
                    pSize += (*portIt)->getSize();
                }
                for( ; portListIt != outPortLists.end(); portListIt ++ )
                {
                    pSize += (*portListIt)->getSize();
                } 
            }
        }    
        else
        {
            pSize = 0;
        }
    }
    else
    {
        if( !outPorts.empty() )
        {
            for( ; portIt != outPorts.end(); portIt ++ )
            {
                cSize += (*portIt)->getSize();
            } 
        }
        if( !outPortLists.empty() )
        {
            for( ; portListIt != outPortLists.end(); portListIt ++ )
            {
                cSize += (*portListIt)->getSize();
            } 
        }
        if( !outJoinedInfos.empty() )
        {
            for( ; joinedInfoIt != outJoinedInfos.end() ; joinedInfoIt ++ )
            {
                cSize += (*joinedInfoIt)->getSize();
            }
        }
    }
    size = pSize + cSize;
    return size;
}

InterfaceJoinedInfo::InterfaceJoinedInfo()
    : Visitable(),
    SelfReferencing<InterfaceJoinedInfo>(),
    mJoinedType(),
    mRelationType(),
    mJoinedPorts(),
    mJoinedPortLists(),
    mChildren() {
}

InterfaceJoinedInfo::~InterfaceJoinedInfo() throw() {
}


} // namespace torc::generic

} // namespace torc

---