775 lines
24 KiB
C++
775 lines
24 KiB
C++
// -*- C++ -*-
|
|
//
|
|
// This file is part of the Coriolis Software.
|
|
// Copyright (c) UPMC 2008-2018, All Rights Reserved
|
|
//
|
|
// +-----------------------------------------------------------------+
|
|
// | C O R I O L I S |
|
|
// | A n a b a t i c - Routing Toolbox |
|
|
// | |
|
|
// | Author : Jean-Paul CHAPUT |
|
|
// | E-mail : Jean-Paul.Chaput@lip6.fr |
|
|
// | =============================================================== |
|
|
// | C++ Module : "./AutoSegments.cpp" |
|
|
// +-----------------------------------------------------------------+
|
|
|
|
|
|
#include "hurricane/Error.h"
|
|
#include "hurricane/RoutingPad.h"
|
|
#include "anabatic/AutoContactTerminal.h"
|
|
#include "anabatic/AutoSegment.h"
|
|
|
|
|
|
namespace {
|
|
|
|
using namespace Anabatic;
|
|
|
|
|
|
AutoContact* isLocalDogleg ( AutoSegment* current, AutoContact* from, AutoSegment* master )
|
|
{
|
|
if (not current->isLocal() or not from->isTurn()) return NULL;
|
|
|
|
AutoContact* to = current->getOppositeAnchor( from );
|
|
if (not to->isTurn()) return NULL;
|
|
|
|
AutoSegment* targetGlobal = to->getPerpandicular( current );
|
|
if (not targetGlobal->isGlobal() or (master->getLayer() != targetGlobal->getLayer())) return NULL;
|
|
|
|
cdebug_log(144,0) << "Global aligned though dogleg:" << targetGlobal << endl;
|
|
|
|
Interval masterConstraints;
|
|
Interval targetConstraints;
|
|
master ->getConstraints( masterConstraints );
|
|
targetGlobal->getConstraints( targetConstraints );
|
|
if (not targetConstraints.intersect(masterConstraints)) return NULL;
|
|
|
|
return to;
|
|
}
|
|
|
|
|
|
} // Anonymous namespace.
|
|
|
|
|
|
namespace Anabatic {
|
|
|
|
using namespace std;
|
|
using Hurricane::tab;
|
|
using Hurricane::_TName;
|
|
using Hurricane::Error;
|
|
using Hurricane::ForEachIterator;
|
|
using Hurricane::Hook;
|
|
using Hurricane::RoutingPad;
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Class : "Anabatic::AutoSegmentStack".
|
|
|
|
void AutoSegmentStack::push ( AutoContact* contact, AutoSegment* segment )
|
|
{
|
|
cdebug_log(144,0) << "Stacking " << contact << " + " << segment << endl;
|
|
push_back( make_pair(contact,segment) );
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Class : "Anabatic::AutoSegments_OnContact".
|
|
|
|
AutoSegments_OnContact::Locator::Locator ( AutoSegment* master, Contact* contact )
|
|
: AutoSegmentHL()
|
|
, _master (master)
|
|
, _element (NULL)
|
|
{
|
|
_hook = contact->getBodyHook()->getPreviousMasterHook();
|
|
progress();
|
|
}
|
|
|
|
|
|
AutoSegmentHL* AutoSegments_OnContact::Locator::getClone () const
|
|
{ return new Locator(*this); }
|
|
|
|
|
|
AutoSegment* AutoSegments_OnContact::Locator::getElement () const
|
|
{ return _element; }
|
|
|
|
|
|
bool AutoSegments_OnContact::Locator::isValid () const
|
|
{ return _hook; }
|
|
|
|
|
|
void AutoSegments_OnContact::Locator::progress ()
|
|
{
|
|
while (_hook) {
|
|
_hook = _hook->getNextHook();
|
|
_element = NULL;
|
|
|
|
if ( _hook->isMaster() ) { _hook = NULL; break; }
|
|
|
|
Segment* segment = dynamic_cast<Segment*>( _hook->getComponent() );
|
|
if (segment) _element = Session::lookup( segment );
|
|
if (not _element or (_element == _master)) continue;
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
string AutoSegments_OnContact::Locator::_getString () const
|
|
{
|
|
string s = "<" + _TName("AutoSegments_OnContact::Locator")
|
|
+ getString(_element)
|
|
+ ">";
|
|
return s;
|
|
}
|
|
|
|
|
|
AutoSegmentHC* AutoSegments_OnContact::getClone () const
|
|
{ return new AutoSegments_OnContact(*this); }
|
|
|
|
|
|
AutoSegmentHL* AutoSegments_OnContact::getLocator () const
|
|
{ return new Locator(_master,_contact); }
|
|
|
|
|
|
string AutoSegments_OnContact::_getString () const
|
|
{
|
|
string s = "<" + _TName("AutoSegments_OnContact") + " "
|
|
+ getString(_master)
|
|
+ ">";
|
|
return s;
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Class : "Anabatic::AutoSegments_OnRoutingPad".
|
|
|
|
AutoSegments_OnRoutingPad::Locator::Locator ( RoutingPad* rp, const AutoContactTerminal* contact )
|
|
: AutoSegmentHL()
|
|
, _elements ({{NULL,NULL,NULL,NULL}})
|
|
, _index (0)
|
|
{
|
|
if (rp) {
|
|
for ( Component* component : rp->getSlaveComponents() ) {
|
|
AutoSegment* segment = Session::lookup( dynamic_cast<Segment*>(component) );
|
|
if (not segment) continue;
|
|
|
|
size_t offset = 2;
|
|
if (contact and (contact->getSegment() == segment)) offset = 0;
|
|
|
|
if (segment->isHorizontal()) _elements[offset ] = segment;
|
|
else _elements[offset+1] = segment;
|
|
}
|
|
}
|
|
|
|
while ( (_index < 4) and not _elements[_index] ) ++_index;
|
|
}
|
|
|
|
|
|
AutoSegmentHL* AutoSegments_OnRoutingPad::Locator::getClone () const
|
|
{ return new Locator(*this); }
|
|
|
|
|
|
AutoSegment* AutoSegments_OnRoutingPad::Locator::getElement () const
|
|
{ return (_index < 4) ? _elements[_index] : NULL; }
|
|
|
|
|
|
bool AutoSegments_OnRoutingPad::Locator::isValid () const
|
|
{ return (_index < 4); }
|
|
|
|
|
|
void AutoSegments_OnRoutingPad::Locator::progress ()
|
|
{
|
|
cdebug_log(145,0) << "AutoSegments_OnRoutingPad::Locator::progress()" << endl;
|
|
++_index;
|
|
while ( (_index < 4) and not _elements[_index] ) ++_index;
|
|
}
|
|
|
|
|
|
string AutoSegments_OnRoutingPad::Locator::_getString () const
|
|
{
|
|
string s = "<" + _TName("AutoSegments_OnRoutingPad::Locator")
|
|
+ getString(_index)
|
|
+ ">";
|
|
return s;
|
|
}
|
|
|
|
|
|
AutoSegments_OnRoutingPad::AutoSegments_OnRoutingPad ( const AutoContact* contact )
|
|
: AutoSegmentHC()
|
|
, _routingPad(NULL)
|
|
, _contact (dynamic_cast<const AutoContactTerminal*>(contact))
|
|
{
|
|
if (_contact)
|
|
_routingPad = dynamic_cast<RoutingPad*>(_contact->getAnchor());
|
|
}
|
|
|
|
|
|
AutoSegmentHC* AutoSegments_OnRoutingPad::getClone () const
|
|
{ return new AutoSegments_OnRoutingPad(*this); }
|
|
|
|
|
|
AutoSegmentHL* AutoSegments_OnRoutingPad::getLocator () const
|
|
{ return new Locator(_routingPad,_contact); }
|
|
|
|
|
|
string AutoSegments_OnRoutingPad::_getString () const
|
|
{
|
|
string s = "<" + _TName("AutoSegments_OnRoutingPad") + " "
|
|
+ getString(_routingPad)
|
|
+ ">";
|
|
return s;
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Class : "AutoSegments_Connecteds".
|
|
|
|
AutoSegments_Connecteds::Locator::Locator ( AutoSegment* segment, Flags flags )
|
|
: AutoSegmentHL()
|
|
, _stack ()
|
|
{
|
|
cdebug_log(145,0) << "AutoSegments_Connecteds::Locator::Locator()" << endl;
|
|
|
|
if (flags & Flags::Source) {
|
|
AutoContact* contact = segment->getAutoSource();
|
|
if (contact) _stack.push( contact, segment );
|
|
}
|
|
|
|
if (flags & Flags::Target) {
|
|
AutoContact* contact = segment->getAutoTarget();
|
|
if (contact) _stack.push( contact, segment );
|
|
}
|
|
}
|
|
|
|
|
|
AutoSegmentHL* AutoSegments_Connecteds::Locator::getClone () const
|
|
{ return new Locator(*this); }
|
|
|
|
|
|
bool AutoSegments_Connecteds::Locator::isValid () const
|
|
{ return not _stack.isEmpty(); }
|
|
|
|
|
|
void AutoSegments_Connecteds::Locator::progress ()
|
|
{
|
|
cdebug_log(145,0) << "AutoSegments_Connecteds::Locator::progress()" << endl;
|
|
|
|
while (not _stack.isEmpty()) {
|
|
AutoContact* sourceContact = _stack.getAutoContact ();
|
|
AutoSegment* sourceSegment = _stack.getAutoSegment ();
|
|
|
|
_stack.pop ();
|
|
|
|
AutoContactTerminal* sourceTerminal = dynamic_cast<AutoContactTerminal*>( sourceContact );
|
|
if (sourceTerminal) {
|
|
for ( AutoSegment* currentSegment : sourceTerminal->getRpConnecteds() ) {
|
|
cdebug_log(145,0) << "Looking at: " << currentSegment << endl;
|
|
if (currentSegment == sourceSegment) continue;
|
|
|
|
AutoContact* targetContact = currentSegment->getAutoSource();
|
|
if (not targetContact->isTerminal()) _stack.push( targetContact, currentSegment );
|
|
|
|
targetContact = currentSegment->getAutoTarget();
|
|
if (not targetContact->isTerminal()) _stack.push( targetContact, currentSegment );
|
|
}
|
|
} else {
|
|
LocatorHelper helper (sourceContact,Flags::WithPerpands);
|
|
for ( ; helper.isValid() ; helper.progress() ) {
|
|
AutoSegment* currentSegment = helper.getSegment();
|
|
cdebug_log(145,0) << "Looking at: " << currentSegment << endl;
|
|
|
|
if (currentSegment == sourceSegment) continue;
|
|
|
|
AutoContact* targetContact = currentSegment->getOppositeAnchor( sourceContact );
|
|
if (targetContact) _stack.push( targetContact, currentSegment );
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
string AutoSegments_Connecteds::Locator::_getString () const
|
|
{
|
|
string s = "<" + _TName("AutoSegments_Connecteds::Locator") + ">";
|
|
return s;
|
|
}
|
|
|
|
|
|
AutoSegmentHC* AutoSegments_Connecteds::getClone () const
|
|
{ return new AutoSegments_Connecteds(*this); }
|
|
|
|
|
|
AutoSegmentHL* AutoSegments_Connecteds::getLocator () const
|
|
{ return new Locator(_segment,_flags); }
|
|
|
|
|
|
AutoSegment* AutoSegments_Connecteds::Locator::getElement () const
|
|
{ return _stack.getAutoSegment(); }
|
|
|
|
|
|
string AutoSegments_Connecteds::_getString () const
|
|
{
|
|
string s = "<" + _TName("AutoSegments_Connecteds") + " "
|
|
+ getString(_segment)
|
|
+ ">";
|
|
return s;
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Class : "AutoSegments_Aligneds".
|
|
|
|
AutoSegments_Aligneds::Locator::Locator ( AutoSegment* segment, Flags flags )
|
|
: AutoSegmentHL()
|
|
, _flags (flags)
|
|
, _master(segment)
|
|
, _stack ()
|
|
{
|
|
if (not _master) return;
|
|
if (not _flags.intersect(Flags::Source|Flags::Target))
|
|
_flags |= Flags::Source | Flags::Target;
|
|
|
|
_flags |= (_master->isHorizontal()) ? Flags::Horizontal : Flags::Vertical;
|
|
if (_flags & Flags::WithDoglegs) _flags |= Flags::WithPerpands;
|
|
|
|
cdebug_log(144,0) << "AutoSegments_Aligneds::Locator::Locator() _flags:" << _flags.asString(FlagsFunction) << endl;
|
|
|
|
if (_flags & Flags::Source) {
|
|
AutoContact* contact = segment->getAutoSource();
|
|
if (contact) _stack.push( contact, segment );
|
|
}
|
|
|
|
if (_flags & Flags::Target) {
|
|
AutoContact* contact = segment->getAutoTarget();
|
|
if (contact) _stack.push( contact, segment );
|
|
}
|
|
|
|
if (not (_flags & Flags::WithSelf)) progress();
|
|
}
|
|
|
|
|
|
AutoSegmentHL* AutoSegments_Aligneds::Locator::getClone () const
|
|
{ return new Locator(*this); }
|
|
|
|
|
|
bool AutoSegments_Aligneds::Locator::isValid () const
|
|
{ return not _stack.isEmpty(); }
|
|
|
|
|
|
void AutoSegments_Aligneds::Locator::progress ()
|
|
{
|
|
cdebug_log(144,0) << "AutoSegments_Aligneds::Locator::progress()" << endl;
|
|
|
|
while (not _stack.isEmpty()) {
|
|
AutoContact* sourceContact = _stack.getAutoContact ();
|
|
AutoSegment* sourceSegment = _stack.getAutoSegment ();
|
|
|
|
_stack.pop ();
|
|
cdebug_log(144,1) << "Iterate over: " << sourceContact << endl;
|
|
|
|
LocatorHelper helper (sourceContact, _flags);
|
|
for ( ; helper.isValid() ; helper.progress() ) {
|
|
AutoSegment* currentSegment = helper.getSegment();
|
|
cdebug_log(144,0) << "| " << currentSegment << endl;
|
|
|
|
if (currentSegment == sourceSegment) continue;
|
|
|
|
if (AutoSegment::areAligneds(currentSegment,_master)) {
|
|
if ( (not (_flags & Flags::NoCheckLayer))
|
|
and AutoSegment::areAlignedsAndDiffLayer(currentSegment,_master)) {
|
|
cerr << Error( "Aligned segments not in same layer (aligneds locator)\n"
|
|
" %s\n"
|
|
" %s."
|
|
,getString(_master).c_str()
|
|
,getString(currentSegment).c_str() ) << endl;
|
|
continue;
|
|
}
|
|
|
|
AutoContact* targetContact = currentSegment->getOppositeAnchor( sourceContact );
|
|
if (targetContact) _stack.push( targetContact, currentSegment );
|
|
} else {
|
|
if (_flags & Flags::WithDoglegs) {
|
|
AutoContact* targetContact = isLocalDogleg( currentSegment, sourceContact, _master );
|
|
|
|
if (targetContact) {
|
|
cdebug_log(144,0) << "Stacking dogleg global. " << endl;
|
|
_stack.push( targetContact, currentSegment );
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
cdebug_tabw(144,-1);
|
|
|
|
if (_stack.getAutoSegment() == _master) continue;
|
|
if (not AutoSegment::areAligneds(_stack.getAutoSegment(),_master)) continue;
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
string AutoSegments_Aligneds::Locator::_getString () const
|
|
{
|
|
string s = "<" + _TName("AutoSegments_Aligneds::Locator") + ">";
|
|
return s;
|
|
}
|
|
|
|
|
|
AutoSegmentHC* AutoSegments_Aligneds::getClone () const
|
|
{ return new AutoSegments_Aligneds(*this); }
|
|
|
|
|
|
AutoSegmentHL* AutoSegments_Aligneds::getLocator () const
|
|
{ return new Locator(_segment,_flags); }
|
|
|
|
|
|
AutoSegment* AutoSegments_Aligneds::Locator::getElement () const
|
|
{ return _stack.getAutoSegment(); }
|
|
|
|
|
|
string AutoSegments_Aligneds::_getString () const
|
|
{
|
|
string s = "<" + _TName("AutoSegments_Aligneds") + " "
|
|
+ getString(_segment)
|
|
+ ">";
|
|
return s;
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Class : "AutoSegments_Perpandiculars".
|
|
|
|
AutoSegments_Perpandiculars::Locator::Locator ( AutoSegment* master, Flags flags )
|
|
: AutoSegmentHL()
|
|
//, _flags (Flags::WithPerpands|Flags::WithDoglegs)
|
|
, _flags (Flags::WithPerpands|flags)
|
|
, _master (master)
|
|
, _stack ()
|
|
, _perpandiculars()
|
|
{
|
|
cdebug_log(144,0) << "AutoSegments_Perpandiculars::Locator::Locator(): _flags:" << _flags.asString(FlagsFunction) << endl;
|
|
cdebug_log(144,0) << " " << _master << endl;
|
|
|
|
if (not _master) return;
|
|
if (_master->isHorizontal()) _flags |= Flags::Horizontal;
|
|
else _flags |= Flags::Vertical;
|
|
|
|
AutoContact* contact = _master->getAutoSource();
|
|
if ( contact ) _stack.push( contact, _master );
|
|
|
|
contact = _master->getAutoTarget();
|
|
if ( contact ) _stack.push( contact, _master );
|
|
|
|
progress();
|
|
}
|
|
|
|
|
|
AutoSegment* AutoSegments_Perpandiculars::Locator::getElement () const
|
|
{
|
|
if (_perpandiculars.empty()) return NULL;
|
|
return _perpandiculars.back();
|
|
}
|
|
|
|
|
|
void AutoSegments_Perpandiculars::Locator::progress ()
|
|
{
|
|
cdebug_log(144,1) << "AutoSegments_Perpandiculars::Locator::progress()" << endl;
|
|
|
|
if (not _perpandiculars.empty()) _perpandiculars.pop_back();
|
|
if (not _perpandiculars.empty()) { cdebug_tabw(144,-1); return; }
|
|
|
|
while ( not _stack.isEmpty() ) {
|
|
AutoContact* sourceContact = _stack.getAutoContact();
|
|
AutoSegment* sourceSegment = _stack.getAutoSegment();
|
|
|
|
_stack.pop();
|
|
cdebug_log(144,0) << "Iterate over: " << sourceContact << endl;
|
|
|
|
LocatorHelper helper (sourceContact, _flags);
|
|
for ( ; helper.isValid() ; helper.progress() ) {
|
|
AutoSegment* currentSegment = helper.getSegment();
|
|
if (currentSegment == sourceSegment) continue;
|
|
|
|
cdebug_log(144,0) << "| " << currentSegment << endl;
|
|
|
|
if (AutoSegment::areAligneds(currentSegment,_master)) {
|
|
AutoContact* targetContact = currentSegment->getOppositeAnchor( sourceContact );
|
|
|
|
if (targetContact) {
|
|
if (_master->getLayer() != currentSegment->getLayer()) {
|
|
continue;
|
|
}
|
|
cdebug_log(144,0) << "Stacking target. " << endl;
|
|
_stack.push( targetContact, currentSegment );
|
|
|
|
// if ( (_master->isHorizontal() and sourceContact->isHTee())
|
|
// or (_master->isVertical () and sourceContact->isVTee()) ) {
|
|
// if (AutoSegment::areAlignedsAndDiffLayer(currentSegment,_master)) {
|
|
// cerr << Error("Aligned segments not in same layer (perpandicular locator)\n"
|
|
// " %s\n"
|
|
// " %s."
|
|
// ,getString(_master).c_str()
|
|
// ,getString(currentSegment).c_str()) << endl;
|
|
// continue;
|
|
// }
|
|
|
|
// cdebug_log(144,0) << "Stacking target. " << endl;
|
|
// _stack.push( targetContact, currentSegment );
|
|
// }
|
|
} else {
|
|
cdebug_log(144,0) << "No opposite anchor to: " << sourceContact << endl;
|
|
}
|
|
} else {
|
|
if ( (_flags & Flags::WithDoglegs) and currentSegment->isLocal() and sourceContact->isTurn() ) {
|
|
AutoContact* targetContact = currentSegment->getOppositeAnchor( sourceContact );
|
|
if (targetContact->isTurn()) {
|
|
AutoSegment* targetGlobal = targetContact->getPerpandicular( currentSegment );
|
|
if (targetGlobal->isGlobal() and (_master->getLayer() == targetGlobal->getLayer())) {
|
|
cdebug_log(144,0) << "Global aligned though dogleg:" << targetGlobal << endl;
|
|
Interval masterConstraints;
|
|
Interval targetConstraints;
|
|
_master ->getConstraints( masterConstraints );
|
|
targetGlobal->getConstraints( targetConstraints );
|
|
if (targetConstraints.intersect(masterConstraints)) {
|
|
cdebug_log(144,0) << "Stacking dogleg global. " << endl;
|
|
_stack.push( targetContact, currentSegment );
|
|
continue;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
_perpandiculars.push_back( currentSegment );
|
|
}
|
|
}
|
|
|
|
if (_stack.isEmpty()) break;
|
|
if (_stack.getAutoSegment() == _master) continue;
|
|
if (not _perpandiculars.empty()) break;
|
|
}
|
|
|
|
cdebug_tabw(144,-1);
|
|
}
|
|
|
|
|
|
AutoSegmentHL* AutoSegments_Perpandiculars::Locator::getClone () const
|
|
{ return new Locator(*this); }
|
|
|
|
|
|
bool AutoSegments_Perpandiculars::Locator::isValid () const
|
|
{ return not _perpandiculars.empty(); }
|
|
|
|
|
|
AutoSegmentHC* AutoSegments_Perpandiculars::getClone () const
|
|
{ return new AutoSegments_Perpandiculars(*this); }
|
|
|
|
|
|
AutoSegmentHL* AutoSegments_Perpandiculars::getLocator () const
|
|
{ return new Locator(_master,_flags); }
|
|
|
|
|
|
string AutoSegments_Perpandiculars::Locator::_getString () const
|
|
{
|
|
string s = "<" + _TName("AutoSegments_Perpandiculars::Locator") + ">";
|
|
return s;
|
|
}
|
|
|
|
|
|
string AutoSegments_Perpandiculars::_getString () const
|
|
{
|
|
string s = "<" + _TName("AutoSegments_Perpandiculars") + " "
|
|
+ getString(_master)
|
|
+ ">";
|
|
return s;
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Class : "AutoSegments_AnchorOnGCell".
|
|
|
|
AutoSegments_AnchorOnGCell::Locator::Locator ( GCell* fcell, Flags flags )
|
|
: AutoSegmentHL()
|
|
, _flags (flags)
|
|
, _itContact (fcell->getContacts().begin())
|
|
, _itEnd (fcell->getContacts().end())
|
|
, _hookLocator(NULL)
|
|
, _element (NULL)
|
|
{ progress(); }
|
|
|
|
|
|
AutoSegments_AnchorOnGCell::Locator::~Locator ()
|
|
{ if (_hookLocator) delete _hookLocator; }
|
|
|
|
|
|
AutoSegment* AutoSegments_AnchorOnGCell::Locator::getElement () const
|
|
{ return _element; }
|
|
|
|
|
|
AutoSegmentHL* AutoSegments_AnchorOnGCell::Locator::getClone () const
|
|
{ return new Locator(*this); }
|
|
|
|
|
|
bool AutoSegments_AnchorOnGCell::Locator::isValid () const
|
|
{ return _element != NULL; }
|
|
|
|
|
|
void AutoSegments_AnchorOnGCell::Locator::progress ()
|
|
{
|
|
cdebug_log(145,1) << "AutoSegments_AnchorOnGCell::Locator::progress()" << endl;
|
|
|
|
while ( true ) {
|
|
if (_hookLocator == NULL) {
|
|
if (_itContact == _itEnd) {
|
|
cdebug_log(145,0) << "No more AutoContacts" << endl;
|
|
cdebug_tabw(145,-1);
|
|
return;
|
|
}
|
|
|
|
cdebug_log(145,0) << *_itContact << endl;
|
|
|
|
_hookLocator = (*_itContact)->getBodyHook()->getSlaveHooks().getLocator();
|
|
_itContact++;
|
|
} else {
|
|
_hookLocator->progress();
|
|
}
|
|
|
|
while ( _hookLocator->isValid() ) {
|
|
cdebug_log(145,0) << _hookLocator->getElement() << endl;
|
|
Hook* hook = dynamic_cast<Segment::SourceHook*>(_hookLocator->getElement());
|
|
if (hook) {
|
|
if ( ((_flags & Flags::Source) and (dynamic_cast<Segment::SourceHook*>(hook)))
|
|
or ((_flags & Flags::Target) and (dynamic_cast<Segment::TargetHook*>(hook))) ) {
|
|
_element = Session::lookup( static_cast<Segment*>(hook->getComponent()) );
|
|
|
|
if (_element->isHorizontal()) {
|
|
if (_flags & Flags::Horizontal) { cdebug_tabw(145,-1); return; }
|
|
} else
|
|
if (_flags & Flags::Vertical) { cdebug_tabw(145,-1); return; }
|
|
}
|
|
}
|
|
_hookLocator->progress();
|
|
}
|
|
_hookLocator = NULL;
|
|
_element = NULL;
|
|
}
|
|
|
|
cdebug_tabw(145,-1);
|
|
}
|
|
|
|
|
|
string AutoSegments_AnchorOnGCell::Locator::_getString () const
|
|
{
|
|
string s = "<" + _TName("AutoSegments_AnchorOnGCell::Locator") + ">";
|
|
return s;
|
|
}
|
|
|
|
|
|
AutoSegmentHC* AutoSegments_AnchorOnGCell::getClone () const
|
|
{ return new AutoSegments_AnchorOnGCell(*this); }
|
|
|
|
|
|
AutoSegmentHL* AutoSegments_AnchorOnGCell::getLocator () const
|
|
{ return new Locator(_fcell,_flags); }
|
|
|
|
|
|
string AutoSegments_AnchorOnGCell::_getString () const
|
|
{
|
|
string s = "<" + _TName("AutoSegments_AnchorOnGCell") + " "
|
|
+ getString(_fcell)
|
|
+ ">";
|
|
return s;
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Class : "Anabatic::AutoSegments_CachedOnContact".
|
|
|
|
AutoSegments_CachedOnContact::Locator::Locator ( AutoContact* sourceContact, Flags direction )
|
|
: AutoSegmentHL()
|
|
, _helper(new LocatorHelper(sourceContact,direction))
|
|
{ }
|
|
|
|
|
|
AutoSegments_CachedOnContact::Locator::~Locator ()
|
|
{ delete _helper; }
|
|
|
|
|
|
AutoSegment* AutoSegments_CachedOnContact::Locator::getElement () const
|
|
{ return _helper->getSegment(); }
|
|
|
|
|
|
AutoSegmentHL* AutoSegments_CachedOnContact::Locator::getClone () const
|
|
{ return new Locator(*this); }
|
|
|
|
|
|
bool AutoSegments_CachedOnContact::Locator::isValid () const
|
|
{ return _helper->isValid(); }
|
|
|
|
|
|
void AutoSegments_CachedOnContact::Locator::progress ()
|
|
{
|
|
cdebug_log(145,0) << "AutoSegments_CachedOnContact::Locator::progress()" << endl;
|
|
_helper->progress();
|
|
}
|
|
|
|
|
|
AutoSegmentHL* AutoSegments_CachedOnContact::getLocator () const
|
|
{ return new Locator(_sourceContact,_direction); }
|
|
|
|
|
|
AutoSegmentHC* AutoSegments_CachedOnContact::getClone () const
|
|
{ return new AutoSegments_CachedOnContact(*this); }
|
|
|
|
|
|
string AutoSegments_CachedOnContact::Locator::_getString () const
|
|
{
|
|
string s = "<" + _TName("AutoSegments_CachedOnContact::Locator") + ">";
|
|
return s;
|
|
}
|
|
|
|
|
|
string AutoSegments_CachedOnContact::_getString () const
|
|
{
|
|
string s = "<" + _TName("AutoSegments_CachedOnContact") + " "
|
|
+ getString(_sourceContact)
|
|
+ ">";
|
|
return s;
|
|
}
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Class : "AutoSegments_IsAccountable".
|
|
|
|
AutoSegmentHF* AutoSegments_IsAccountable::getClone () const
|
|
{ return new AutoSegments_IsAccountable(); }
|
|
|
|
|
|
bool AutoSegments_IsAccountable::accept ( AutoSegment* segment ) const
|
|
{ return segment->isCanonical(); }
|
|
|
|
|
|
string AutoSegments_IsAccountable::_getString () const
|
|
{ return "<AutoSegments_IsAccountable>"; }
|
|
|
|
|
|
// -------------------------------------------------------------------
|
|
// Class : "AutoSegments_InDirection".
|
|
|
|
|
|
AutoSegmentHF* AutoSegments_InDirection::getClone () const
|
|
{ return new AutoSegments_InDirection(_direction); }
|
|
|
|
|
|
bool AutoSegments_InDirection::accept ( AutoSegment* segment ) const
|
|
{
|
|
return ( segment->isHorizontal() and (_direction & Flags::Horizontal) )
|
|
or ( segment->isVertical () and (_direction & Flags::Vertical ) );
|
|
}
|
|
|
|
|
|
string AutoSegments_InDirection::_getString () const
|
|
{ return "<AutoSegments_InDirection>"; }
|
|
|
|
|
|
} // Anabatic namespace.
|