torc::generic::Permutable Class Reference

Permutable is used to describe a relationship in which ports are interchangeable. More...

#include <Permutable.hpp>

Inheritance diagram for torc::generic::Permutable:

Collaboration diagram for torc::generic::Permutable:

Data Structures
class	Factory

Public Types
enum	PermutableType { ePermutableParent = 0, ePermutableChild }
typedef VisitorType< Permutable >	Visitor
typedef Permutable	Type
typedef boost::shared_ptr< Type >	Pointer
typedef boost::weak_ptr< Type >	WeakPointer

Public Member Functions
void	getPorts (std::vector< PortSharedPtr > &outPorts) const
void	setPorts (const std::vector< PortSharedPtr > &inSource) throw (Error)
void	addPort (const PortSharedPtr &inPort) throw (Error)
void	getChildren (std::vector< PermutableSharedPtr > &outPermutables) const
template<typename _Action >
void	applyOnAllChildren (const _Action &action) throw (Error)
void	setChildren (const std::vector< PermutableSharedPtr > &inSource) throw (Error)
bool	addChildPermutable (const PermutableSharedPtr &inPermutable) throw (Error)
const bool	getIsNonPermutable () const
void	setIsNonPermutable (const bool &value)
const PermutableType	getPermutableType () const
void	setPermutableType (const PermutableType &inSource)
size_t	getSize () const
virtual	~Permutable () throw ()
virtual void	accept (BaseVisitor &visitor) throw (Error)
void	setWeakThis (const WeakPointer &inWeakThis)
Pointer	getSharedThis () const

Protected Member Functions
	Permutable ()

Private Attributes
std::vector< PortSharedPtr >	mPorts
std::vector< PermutableSharedPtr >	mChildren
bool	mIsNonPermutable
PermutableType	mPermutableType

Friends
class	FactoryType< Permutable >

Detailed Description

Permutable is used to describe a relationship in which ports are interchangeable.

It may reference individual ports, arrayed ports, bundled ports, permutable and nonpermutable statements.

Definition at line 40 of file Permutable.hpp.

Member Typedef Documentation

typedef boost::shared_ptr<Type> torc::generic::SelfReferencing< Permutable >::Pointer

inherited

Definition at line 36 of file SelfReferencing.hpp.

typedef Permutable torc::generic::SelfReferencing< Permutable >::Type

inherited

Definition at line 35 of file SelfReferencing.hpp.

typedef VisitorType<Permutable> torc::generic::Permutable::Visitor

Convenience class to visit a permutable.

Definition at line 58 of file Permutable.hpp.

typedef boost::weak_ptr<Type> torc::generic::SelfReferencing< Permutable >::WeakPointer

inherited

Definition at line 37 of file SelfReferencing.hpp.

Member Enumeration Documentation

enum torc::generic::Permutable::PermutableType

Type of the permutable, Is it parent or child.

Enumerator
ePermutableParent
ePermutableChild

Definition at line 51 of file Permutable.hpp.

                        {
        ePermutableParent = 0, ePermutableChild
    };

Constructor & Destructor Documentation

torc::generic::Permutable::~Permutable ( ) throw ( )

virtual

Definition at line 200 of file Permutable.cpp.

{}

torc::generic::Permutable::Permutable ( )

protected

Definition at line 197 of file Permutable.cpp.

                       : Visitable(), SelfReferencing<Permutable>(), mPorts(), mChildren(),
    mIsNonPermutable(false), mPermutableType() {}

Member Function Documentation

void torc::generic::Permutable::accept ( BaseVisitor &  visitor ) throw ( Error )

virtual

Receive a visitor to this class. The visit method of the visitor is called and a reference to this object is passed as a parameter. It has to be noted however, that a dynamic_cast is performed inside this method. If the cast fails, an appropriate exception is thrown by this method. This situation can arise when the passed Visitor object does not inherit from the appropriate visitor specialization. See Visitor documentation for more details.

Parameters

[in,out]

visitor

A reference to the visitor object

Exceptions

Error

Visitor type inappropriate for visiting this object or any other error thrown by the Visitor::throw() method.

Implements torc::generic::Visitable.

Definition at line 132 of file Permutable.cpp.

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

Here is the call graph for this function:

bool torc::generic::Permutable::addChildPermutable	(	const PermutableSharedPtr &	inPermutable	)
throw	(	Error
	)

Add a nested permutable/nonpermutable to parent permutable.

Parameters

[in]

inPermutable

Nested permutable/nonpermutable

Add a nested permutable/nonpermutable to this permutable.

Parameters

[in]

inPermutable

Nested permutable/nonpermutable

Exceptions

Error

Could not add permutable because pointer to the permutable does not exist

Definition at line 114 of file Permutable.cpp.

                                                                                         {
    if(!inPermutable) {
        Error e(eMessageIdErrorPointerToItemDoesNotExist, __FUNCTION__, __FILE__, __LINE__);
        e.saveContextData("Pointer to the permutable object does not exist", inPermutable);
        throw e;
    }
    if(inPermutable) {
        mChildren.push_back(inPermutable);
        return true;
    } else {
        return false;
    }
}

Here is the call graph for this function:

void torc::generic::Permutable::addPort	(	const PortSharedPtr &	inPort	)
throw	(	Error
	)

Add a port to the list of ports. Empty pointer is ignored.

Parameters

[in]

inPort

Pointer to port to be added.

Exceptions

Error

Could not add port, because Port name is empty

Definition at line 76 of file Permutable.cpp.

                                                                  {
    if(!inPort) {
        return;
    }
    std::string name = inPort->getName();
    if(name.empty()) {
        Error e(eMessageIdErrorEmptyItemName, __FUNCTION__, __FILE__, __LINE__);
        e.saveContextData("Port name", name);
        throw e;
    }
    mPorts.push_back(inPort);
}

Here is the call graph for this function:

template<typename _Action >

void torc::generic::Permutable::applyOnAllChildren ( const _Action &  action ) throw ( Error )

inline

Apply action on all children.

Parameters

[in]

action

Action to be applied

Definition at line 212 of file Permutable.hpp.

                  {
    try {
        std::vector<PermutableSharedPtr>::iterator it = mChildren.begin();
        for(; it != mChildren.end(); ++it) {
            action(*it);
        }
    } catch(Error& e) {
        e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
        throw;
    }
}

Here is the call graph for this function:

void torc::generic::Permutable::getChildren ( std::vector< PermutableSharedPtr > &  outPermutables ) const

inline

Get the nested permutable.

Parameters

[out]

outPermutables

Vector of permutable to be appended to

Definition at line 203 of file Permutable.hpp.

                                                                                        {
    outPermutables.insert(outPermutables.end(), mChildren.begin(), mChildren.end());
}

Here is the caller graph for this function:

const bool torc::generic::Permutable::getIsNonPermutable ( ) const

inline

Get the boolean flag whether the current object is permutable/nonpermutable.

Returns

Boolean flag

Definition at line 229 of file Permutable.hpp.

                                                       {
    return mIsNonPermutable;
}

const Permutable::PermutableType torc::generic::Permutable::getPermutableType ( ) const

inline

Get the permutable type.

Returns

PermutableType

Definition at line 238 of file Permutable.hpp.

                                                                          {
    return mPermutableType;
}

Here is the caller graph for this function:

void torc::generic::Permutable::getPorts ( std::vector< PortSharedPtr > &  outValues ) const

inline

Get the list of ports for this permutable.

Parameters

[out]

outPorts

Vector of ports to be appended to

Definition at line 194 of file Permutable.hpp.

                                                                          {
    outValues.insert(outValues.end(), mPorts.begin(), mPorts.end());
}

Here is the caller graph for this function:

Pointer torc::generic::SelfReferencing< Permutable >::getSharedThis ( ) const

inlineinherited

Get a shared pointer to this object. A valid pointer is returned if weakThis was set. Otherwise this returns a NULL pointer. For Vector types, the second scenario is an exception condition and should be treated as such.

Returns

A shared pointer to this object

Get a shared pointer to this object. A valid pointer is returned if weakThis was set. Otherwise this returns a NULL pointer. For Vector types, the second scenario is an exception condition and should be treated as such.

Parameters

[out]

ptr

Set to a shared pointer to this object

size_t torc::generic::Permutable::getSize

(

void

)

const

Get the total number of bits of the composition

Returns

Number of bits

Definition at line 145 of file Permutable.cpp.

                                 {
    size_t size = 0;
    size_t pSize = 0;
    size_t cSize = 0;
    Permutable::PermutableType pType = getPermutableType();

    std::vector<PermutableSharedPtr> outPermutables;
    getChildren(outPermutables);
    std::vector<PermutableSharedPtr>::iterator permutableIt = outPermutables.begin();

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

    if(Permutable::ePermutableParent == pType) {
        if(!outPorts.empty()) {
            pSize = (*portIt)->getSize();
        } else if(!outPermutables.empty()) {
            for(; permutableIt != outPermutables.end(); permutableIt++) {
                pSize += (*permutableIt)->getSize();
                for(; portIt != outPorts.end(); portIt++) {
                    pSize += (*portIt)->getSize();
                }
            }
        } else {
            pSize = 0;
        }
    } else {
        if(!outPorts.empty()) {
            for(; portIt != outPorts.end(); portIt++) {
                cSize += (*portIt)->getSize();
            }
        }
        if(!outPermutables.empty()) {
            for(; permutableIt != outPermutables.end(); permutableIt++) {
                cSize += (*permutableIt)->getSize();
            }
        }
    }
    size = pSize + cSize;
    return size;
}

Here is the call graph for this function:

void torc::generic::Permutable::setChildren	(	const std::vector< PermutableSharedPtr > &	inSource	)
throw	(	Error
	)

Set the nested permutable.

Parameters

[in]

inSource

Vector containing permutables

Set the nested permutable.

Parameters

[in]

inSource

Vector containing permutables

Exceptions

Error

Could not add permutable because pointer to the permutable does not exist

Definition at line 95 of file Permutable.cpp.

                                                                                         {
    std::vector<PermutableSharedPtr>::const_iterator entry = inSource.begin();
    std::vector<PermutableSharedPtr>::const_iterator end = inSource.end();
    for(; entry != end; ++entry) {
        try {
            addChildPermutable(*entry);
        } catch(Error& e) {
            e.setCurrentLocation(__FUNCTION__, __FILE__, __LINE__);
            throw;
        }
    }
}

Here is the call graph for this function:

void torc::generic::Permutable::setIsNonPermutable

(

const bool &

value

)

Definition at line 128 of file Permutable.cpp.

                                                     {
    mIsNonPermutable = value;
}

void torc::generic::Permutable::setPermutableType

(

const PermutableType &

inSource

)

Set the permutable type.

Parameters

[in]

inSource

PermutableType

Definition at line 193 of file Permutable.cpp.

                                                                 {
    mPermutableType = inSource;
}

void torc::generic::Permutable::setPorts	(	const std::vector< PortSharedPtr > &	inSource	)
throw	(	Error
	)

Set the list of ports to this permutable. It will lead to a linear traversal on the list. So usage of this API is not recommended.

Parameters

[in]

inSource

Vector of ports

Definition at line 56 of file Permutable.cpp.

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

Here is the call graph for this function:

void torc::generic::SelfReferencing< Permutable >::setWeakThis ( const WeakPointer &  inWeakThis )

inlineinherited

Set a weak pointer to this object. This will be used later to get a shared pointer to this object from within other member methods if required. This should be called by the Factory creating the object.

Parameters

[in]

weakThis

A weak pointer to this object

Friends And Related Function Documentation

friend class FactoryType< Permutable >

friend

Definition at line 42 of file Permutable.hpp.

Field Documentation

std::vector<PermutableSharedPtr> torc::generic::Permutable::mChildren

private

Definition at line 183 of file Permutable.hpp.

bool torc::generic::Permutable::mIsNonPermutable

private

Definition at line 184 of file Permutable.hpp.

PermutableType torc::generic::Permutable::mPermutableType

private

Definition at line 185 of file Permutable.hpp.

std::vector<PortSharedPtr> torc::generic::Permutable::mPorts

private

Definition at line 182 of file Permutable.hpp.

---

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

• Permutable.hpp
• Permutable.cpp