Hurricane::Component Class Reference

Component description (API) More...

Inheritance diagram for Hurricane::Component:

Classes
class	BodyHook

Public Types
typedef Go	Inherit

Public Member Functions
Net *	getNet () const
Rubber *	getRubber () const
Hook *	getBodyHook ()
virtual Hooks	getHooks () const
virtual DbU::Unit	getX () const =0
virtual DbU::Unit	getY () const =0
virtual Point	getPosition () const
virtual const Layer *	getLayer () const =0
virtual Box	getBoundingBox (const BasicLayer *) const =0
Components	getConnexComponents () const
Components	getSlaveComponents () const
Public Member Functions inherited from Hurricane::Go
bool	isMaterialized () const
virtual void	translate (const DbU::Unit &dx, const DbU::Unit &dy)=0
Public Member Functions inherited from Hurricane::DBo
virtual void	destroy ()
Property *	getProperty (const Name &) const
Properties	getProperties () const
bool	hasProperty () const
void	put (Property *)
void	remove (Property *)
void	removeProperty (const Name &)
void	clearProperties ()

Static Public Member Functions
static ComponentFilter	getIsUnderFilter (const Box &area)
Static Public Member Functions inherited from Hurricane::Go
static bool	autoMaterializationIsDisabled ()
static void	enableAutoMaterialization ()
static void	disableAutoMaterialization ()

Detailed Description

Component description (API)

Introduction

Components are the abstract objects representing the category of net components (segments, contacts, pads, plugs,...). Each component knows its net, its layer and has a "body".

Concept of Location

Some components (for instance the segments) bear on contacts or other segments, more precisely they bear an extremity (the origin or the extremity), possibly through an offset on other components. The real location of the concerned part is therefore relative to the location of the component on which this part bears.

For that purpose each components must be able to return a location from which a relative calculations can be done. The methods getX() and getY() provide this information and must be overloaded for each sub-type of component in oder to get the desired effect.

Remarks

The fact that a null value is systematically returned by one of this methods means that the locations are computed relative to a null value, which is equivalent to say they are absolute values (see for instance the Horizontal segment whose getX() returns always null, while getY() return the ordinate of its axis).

Destruction

When a component is destroyed, all components which are anchored on its body (through the body hook) are also destroyed. This may recursively propagate to other components anchored on the body of those last ones.

Rings are reorganized such that the connectivity remains invariant.

Predefined filters

Component::getIsUnderFilter

Member Typedef Documentation

Inherit

Hurricane::Component::Inherit

Useful for calling upon methods of the base class without knowing it.

Member Function Documentation

getNet()

Net * Hurricane::Component::getNet ( ) const

inline

Returns: the net owning the component.

Referenced by Hurricane::Plug::isConnected().

getRubber()

Rubber * Hurricane::Component::getRubber ( ) const

inline

Returns: the rubber associated to the component (may be NULL).

getBodyHook()

Net::BodyHook * Hurricane::Component::getBodyHook ( )

inline

Returns: the hook representing the component body.

getHooks()

Hooks Hurricane::Component::getHooks ( ) const

virtual

Returns: the collection of component hooks, that is the collection of nested hooks within the component, each of them representing a part of the component.

getX()

Unit Hurricane::Component::getX ( ) const

pure virtual

Returns: the abscissa of the component's body. This abscissa is a reference base for the components anchored, through an offset, on the component's body.

Implemented in Hurricane::RoutingPad.

Referenced by getPosition().

getY()

Unit Hurricane::Component::getY ( ) const

pure virtual

Returns: the ordinate of the component's body. This ordinate is a reference base for the components anchored, through an offset, on the component's body.

Implemented in Hurricane::RoutingPad.

Referenced by getPosition().

getPosition()

Point Hurricane::Component::getPosition ( ) const

inlinevirtual

Returns: the location of the component's body.

This method returns, in principle, a point built from the two previous methods. As far as some similar calculations are done in both methods, it is wise to redefine the method as shown below for the Contact :

DbU::Unit Contact::getX() const
{
  Component* anchor = getAnchor();
  return (not anchor) ? _dx : anchor->getX() + _dx;
}
 
 
DbU::Unit Contact::getY() const
{
  Component* anchor = getAnchor();
  return (not anchor) ? _dy : anchor->getY() + _dy;
}
 
 
Point Contact::getPosition() const
{
  Component* anchor = getAnchor();
  return (not anchor) ? Point(_dx, _dy)
                      : anchor->getPosition().Translate(_dx, _dy);
}

Indeed, contacts can possibly bear on other components through an offset defined by two attributes _dx and _dy. In order to compute the abscissa of a contact the component on which it bears must be found. This component named the anchor is returned by the call to getAnchor(). If the component has no anchor, its coordinates are considered as absolute and the attribute _dx gives directly its abscissa.

The method getAnchor() must loop through a ring in order to find the contact anchor. By overloading the function getPosition(), only one loop will be needed. Furtermore we call directly anchor->getPosition() and not both anchor->getX() and anchor->getY(), this will be faster (this anchor may be anchored itself on an other component).

References getX(), and getY().

getLayer()

Layer * Hurricane::Component::getLayer ( ) const

pure virtual

Returns: the layer on which the component is located (may return NULL for some component types like the plugs).

Implemented in Hurricane::RoutingPad.

getBoundingBox()

Box Hurricane::Component::getBoundingBox ( const BasicLayer *  basicLayer ) const

pure virtual

Returns: the envelope of the component for the <basicLayer>, that is the smallest box enclosing all layout elements located on the specified basic layer.

Returns: an empty box for objects which are not physical layout ones (i.e. plugs) or for those which have no layout on the specified basic layer.

getConnexComponents()

Components Hurricane::Component::getConnexComponents

(

)

const

Returns: the collection of "connex components" to the component <this> (which includes at least this one).

Remarks

A componnent is said connex to an other one if it is attached directly or indirectly through hyper-hooks, that is if there exist a sequence of components whose parts (extremities or body) are either sharing the same anchor or anchored one upon the other.

If the layout elements are correctly assembled and on the proper layers, this "connex components collection" represents an geometrically and electrically connected subset of layout elements

On the other hand, if layout anchored objects don't overlap on the same conducting layers (either by a wrong contact layer or by an offset which forbids layout intersection) electrical continuity will not be ensured.

getSlaveComponents()

Components Hurricane::Component::getSlaveComponents

(

)

const

Returns: the collection of components whose existence depends directly or indirectly of the existence of the component <this> (a segment can't survive to the destruction of a contact on which it is anchored).

getIsUnderFilter()

ComponentFilter Hurricane::Component::getIsUnderFilter ( const Box &  area )

static

Returns: the filter allowing to select only components which intersect the rectangular <area>.

---

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

• Component.h
• Component.dox