riscv
/
coriolis
mirror of https://gitlab.lip6.fr/vlsi-eda/coriolis.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
coriolis/anabatic/src/AutoSegments.cpp

724 lines
22 KiB
C++
Raw Normal View History

Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
// -*- C++ -*-
//
// This file is part of the Coriolis Software.
// Copyright (c) UPMC 2008-2016, 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"
Apaired segments building for symmetric routing (step 1). * Change: In Hurricane::BaseFlags, store flags in uint64_t instead of unsigned int because we start to need more than 32 different flags in some tools. * New: In ::getString() & ::getRecord() templates, add support for std::array<>. * Change: In CRL::ToolEngine, add support for timer (time & memory measurements) displaced from Katabatic. This way all ToolEngine can use this feature. The _postCreate() method display the memory just after ToolEngine allocation. * Change: In Etesian::EtesianEngine, make use of the ToolEngine builtin timer (remove the local one). Forgot to call the base class _postCreate() and _preDestroy(). * Change: In Anabatic::AnabaticEngine, make use of the ToolEngine builtin timer (remove the local one). * New: In Anabatic, new AutoSegments_Connecteds() collection. This Collection allows a deterministic walkthough *all* the AutoSegments connected either to source or target of one AutoSegment. * New: In Anabatic::AutoContactTerminal::isEndPoint() to check if an AutoContactTerminal is the *only one* anchored on a RoutingPad, thus being a true "end point" and not a kind of feed-through. * New: In Katana::KatanaEngine, added support for symmetric nets. Created new class DataSymmetric to store symmetric information of a net (mainly the paired AutoSegments). Added KatanaEngine::runSymmetricRouter(), for now only build the DataSymmetric informations. More to come... * Change: In Katana::GraphicKatanaEngine::_runTest(), now perform symmetric information building the non-symmetric routing.
2017-03-12 13:34:12 -05:00
#include "hurricane/RoutingPad.h"
#include "anabatic/AutoContactTerminal.h"
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
#include "anabatic/AutoSegment.h"
namespace Anabatic {
using namespace std;
using Hurricane::tab;
using Hurricane::_TName;
using Hurricane::Error;
using Hurricane::ForEachIterator;
using Hurricane::Hook;
Apaired segments building for symmetric routing (step 1). * Change: In Hurricane::BaseFlags, store flags in uint64_t instead of unsigned int because we start to need more than 32 different flags in some tools. * New: In ::getString() & ::getRecord() templates, add support for std::array<>. * Change: In CRL::ToolEngine, add support for timer (time & memory measurements) displaced from Katabatic. This way all ToolEngine can use this feature. The _postCreate() method display the memory just after ToolEngine allocation. * Change: In Etesian::EtesianEngine, make use of the ToolEngine builtin timer (remove the local one). Forgot to call the base class _postCreate() and _preDestroy(). * Change: In Anabatic::AnabaticEngine, make use of the ToolEngine builtin timer (remove the local one). * New: In Anabatic, new AutoSegments_Connecteds() collection. This Collection allows a deterministic walkthough *all* the AutoSegments connected either to source or target of one AutoSegment. * New: In Anabatic::AutoContactTerminal::isEndPoint() to check if an AutoContactTerminal is the *only one* anchored on a RoutingPad, thus being a true "end point" and not a kind of feed-through. * New: In Katana::KatanaEngine, added support for symmetric nets. Created new class DataSymmetric to store symmetric information of a net (mainly the paired AutoSegments). Added KatanaEngine::runSymmetricRouter(), for now only build the DataSymmetric informations. More to come... * Change: In Katana::GraphicKatanaEngine::_runTest(), now perform symmetric information building the non-symmetric routing.
2017-03-12 13:34:12 -05:00
using Hurricane::RoutingPad;
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
// -------------------------------------------------------------------
// Class : "Anabatic::AutoSegmentStack".
void AutoSegmentStack::push ( AutoContact* contact, AutoSegment* segment )
{
cdebug_log(145,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 ()
{
cdebug_log(145,0) << "AutoSegments_OnContact::Locator::progress()" << endl;
while (_hook and not _hook->isMaster()) {
_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;
}
Apaired segments building for symmetric routing (step 1). * Change: In Hurricane::BaseFlags, store flags in uint64_t instead of unsigned int because we start to need more than 32 different flags in some tools. * New: In ::getString() & ::getRecord() templates, add support for std::array<>. * Change: In CRL::ToolEngine, add support for timer (time & memory measurements) displaced from Katabatic. This way all ToolEngine can use this feature. The _postCreate() method display the memory just after ToolEngine allocation. * Change: In Etesian::EtesianEngine, make use of the ToolEngine builtin timer (remove the local one). Forgot to call the base class _postCreate() and _preDestroy(). * Change: In Anabatic::AnabaticEngine, make use of the ToolEngine builtin timer (remove the local one). * New: In Anabatic, new AutoSegments_Connecteds() collection. This Collection allows a deterministic walkthough *all* the AutoSegments connected either to source or target of one AutoSegment. * New: In Anabatic::AutoContactTerminal::isEndPoint() to check if an AutoContactTerminal is the *only one* anchored on a RoutingPad, thus being a true "end point" and not a kind of feed-through. * New: In Katana::KatanaEngine, added support for symmetric nets. Created new class DataSymmetric to store symmetric information of a net (mainly the paired AutoSegments). Added KatanaEngine::runSymmetricRouter(), for now only build the DataSymmetric informations. More to come... * Change: In Katana::GraphicKatanaEngine::_runTest(), now perform symmetric information building the non-symmetric routing.
2017-03-12 13:34:12 -05:00
// -------------------------------------------------------------------
// 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".
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
AutoSegments_Connecteds::Locator::Locator ( AutoSegment* segment, Flags flags )
Apaired segments building for symmetric routing (step 1). * Change: In Hurricane::BaseFlags, store flags in uint64_t instead of unsigned int because we start to need more than 32 different flags in some tools. * New: In ::getString() & ::getRecord() templates, add support for std::array<>. * Change: In CRL::ToolEngine, add support for timer (time & memory measurements) displaced from Katabatic. This way all ToolEngine can use this feature. The _postCreate() method display the memory just after ToolEngine allocation. * Change: In Etesian::EtesianEngine, make use of the ToolEngine builtin timer (remove the local one). Forgot to call the base class _postCreate() and _preDestroy(). * Change: In Anabatic::AnabaticEngine, make use of the ToolEngine builtin timer (remove the local one). * New: In Anabatic, new AutoSegments_Connecteds() collection. This Collection allows a deterministic walkthough *all* the AutoSegments connected either to source or target of one AutoSegment. * New: In Anabatic::AutoContactTerminal::isEndPoint() to check if an AutoContactTerminal is the *only one* anchored on a RoutingPad, thus being a true "end point" and not a kind of feed-through. * New: In Katana::KatanaEngine, added support for symmetric nets. Created new class DataSymmetric to store symmetric information of a net (mainly the paired AutoSegments). Added KatanaEngine::runSymmetricRouter(), for now only build the DataSymmetric informations. More to come... * Change: In Katana::GraphicKatanaEngine::_runTest(), now perform symmetric information building the non-symmetric routing.
2017-03-12 13:34:12 -05:00
: 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;
}
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
// -------------------------------------------------------------------
// Class : "AutoSegments_Aligneds".
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
AutoSegments_Aligneds::Locator::Locator ( AutoSegment* segment, Flags flags )
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
: AutoSegmentHL()
, _flags (flags)
, _master(segment)
, _stack ()
{
if (not _master) return;
_flags |= (_master->isHorizontal()) ? Flags::Horizontal : Flags::Vertical;
cdebug_log(145,0) << "AutoSegments_Aligneds::Locator::Locator() - _flags:" << _flags << endl;
AutoContact* contact = segment->getAutoSource();
if (contact) _stack.push( contact, segment );
contact = segment->getAutoTarget();
if (contact) _stack.push( contact, segment );
Anabatic transient commit 18. Port of Kite (Katana), Yeah, Baby! Yeah! * Bug: In Hurricane, in StaticObservable::getObserver(), if the slot pointer is NULL, do not try to access the owner. Returns NULL, so the caller can be aware of the situation... * Change: In Hurricane, in BreakpointWidget & ExceptionWidget some cosmetic changes (fonts and window sizes). * Bug: In Anabatic, In AutoHorizontal::getConstraints(), take into account the constraints from the source AutoContact, as it holds the constraints transmitted by the RoutingPads and sets up by propageConstraintsFromRp(). It is likely to be a bug affecting the original Katabatic as well. * Change: In Anabatic, in RawGCellsUnder(), check that the segment is not completly oustside the cell abutment box and truncate the coordinates to the part that is inside. Use the "shrink" if we reach the east/north border. * Change: In Anabatic, in Configuration, no more decorator because we will use a true derived relationship. Katana *derives* from *Anabatic* and do not *decorate* it, so the Configuration can do the same. It also implies that we directly create a Katana engine, not an Anabatic one. * Change: In Anabatic, in Session, do not allow the opening of the Session in a standalone fashion (with a static method). Instead it must be opened using the relevant method of the Anabatic/Katana engine. This ensure we are opening the right Session type. * Change: In Anabatic, in AutoSegment_Aligneds() collection the seed segment is not part of the collection by default, but will be included if the Flags::WithSelf is set. * Change: In Configuration, all the flags value are now defined in two steps. Declared in the header and initialized in the module. This is to prevent the fact that on some cases, in relation with the Python "extern C" part modules, we need a true allocated variable. It was causing weird linking problems. A side effect is that they can no longer be used as entry is switches, have to replace them by if/else. * New: In Anabatic, new GCell::getNeighborAt() utility function. * Bug: In Anabatic, in GCell::doGrid(), tag all the GCells of the grid with the grid type... Back annote all the edges capacity (north & east) with the reserved local capacity. * New: Complete portage of Kite over Anabatic. The new engine is christened "Katana" for Kite-Analogic. When it's capabilities and performances will be on a part with Kite, it is to completly replace it (and take back the "Kite" name). Preliminary tests seems to show that, contrary to intuition (because built on a more complex/slower grid), it is even slightly faster than Kite 8-).
2016-08-15 09:30:13 -05:00
if (not (_flags & Flags::WithSelf)) progress();
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
}
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(145,0) << "AutoSegments_Aligneds::Locator::progress()" << endl;
while (not _stack.isEmpty()) {
AutoContact* sourceContact = _stack.getAutoContact ();
AutoSegment* sourceSegment = _stack.getAutoSegment ();
_stack.pop ();
LocatorHelper helper (sourceContact, _flags);
for ( ; helper.isValid() ; helper.progress() ) {
AutoSegment* currentSegment = helper.getSegment();
cdebug_log(145,0) << "Looking at: " << currentSegment << endl;
if (currentSegment == sourceSegment) continue;
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 );
}
if (_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".
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
AutoSegments_Perpandiculars::Locator::Locator ( AutoSegment* master, Flags flags )
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
: AutoSegmentHL()
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
//, _flags (Flags::WithPerpands|Flags::WithDoglegs)
, _flags (Flags::WithPerpands|flags)
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
, _master (master)
, _stack ()
, _perpandiculars()
{
cdebug_log(145,0) << "AutoSegments_Perpandiculars::Locator::Locator()" << endl;
cdebug_log(145,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 ()
{
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
cdebug_log(145,1) << "AutoSegments_Perpandiculars::Locator::progress()" << endl;
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
if (not _perpandiculars.empty()) _perpandiculars.pop_back();
if (not _perpandiculars.empty()) return;
while ( not _stack.isEmpty() ) {
AutoContact* sourceContact = _stack.getAutoContact();
AutoSegment* sourceSegment = _stack.getAutoSegment();
_stack.pop();
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
cdebug_log(145,0) << "Iterate over: " << sourceContact << endl;
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
LocatorHelper helper (sourceContact, _flags);
for ( ; helper.isValid() ; helper.progress() ) {
AutoSegment* currentSegment = helper.getSegment();
if (currentSegment == sourceSegment) continue;
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
cdebug_log(145,0) << "| " << currentSegment << endl;
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
if (AutoSegment::areAligneds(currentSegment,_master)) {
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
AutoContact* targetContact = currentSegment->getOppositeAnchor( sourceContact );
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
if (targetContact) {
if (_master->getLayer() != currentSegment->getLayer()) {
continue;
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
}
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
cdebug_log(145,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(145,0) << "Stacking target. " << endl;
// _stack.push( targetContact, currentSegment );
// }
} else {
cdebug_log(145,0) << "No opposite anchor to: " << sourceContact << endl;
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
}
} else {
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
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(145,0) << "Global aligned though dogleg:" << targetGlobal << endl;
Interval masterConstraints;
Interval targetConstraints;
_master ->getConstraints( masterConstraints );
targetGlobal->getConstraints( targetConstraints );
if (targetConstraints.intersect(masterConstraints)) {
cdebug_log(145,0) << "Stacking dogleg global. " << endl;
_stack.push( targetContact, currentSegment );
continue;
}
}
}
}
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
_perpandiculars.push_back( currentSegment );
}
}
if (_stack.isEmpty()) break;
if (_stack.getAutoSegment() == _master) continue;
if (not _perpandiculars.empty()) break;
}
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
cdebug_tabw(145,-1);
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
}
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
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
{ return new Locator(_master,_flags); }
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
string AutoSegments_Perpandiculars::Locator::_getString () const
{
string s = "<" + _TName("AutoSegments_Perpandiculars::Locator") + ">";
return s;
}
string AutoSegments_Perpandiculars::_getString () const
{
string s = "<" + _TName("AutoSegments_Perpandiculars") + " "
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
+ getString(_master)
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
+ ">";
return s;
}
// -------------------------------------------------------------------
// Class : "AutoSegments_AnchorOnGCell".
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
AutoSegments_AnchorOnGCell::Locator::Locator ( GCell* fcell, Flags flags )
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
: 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".
Replace "unsigned int" by "Flags" in all AutoSegments collections. * Change: In Anabatic::AutoSegments collections, change the type of all the flags that where in "unsigned int" (32 bits) to Flags (uint64_t) as there is now more than 32 flags for functions. * New: In Ababatic::Constants, added new flag Flags::WithPerpands, which makes the number of flags tip over 32 bits, thus making mandatory to uses Flags and not unsigned int. * New: In Anabatic::AutoSegments_Perpandiculars, manage a new flag Flags::WithDoglegs to allow to propagate through global segments that are connecteds via doglegs on local segments. Meaning that there is a good chance that they could be aligned. Slighly change the way we propagate on aligned segments: no longer check for VTee or HTee, but only for same direction and layer as master. * New: In Anabatic & Katana, replace all the "int", "long" and their variants by the less implementation ambiguous "int32_t", "int64_t" (and variant). This should help to better detect bit trucation in flags. Use the type to give a hint about the flags kind: - Type "Flags", for flags shared among Anabatic & Katana functions/methods (may also appear in some objects states). - Type "uint32_t" for flags belonging to an object internal state of from Hurricane functions flags (those should be grouped in a Flag subclass in a perfect world).
2017-05-16 07:53:33 -05:00
AutoSegments_CachedOnContact::Locator::Locator ( AutoContact* sourceContact, Flags direction )
Anabatic transient commit 11. Merge Katabatic into Anabatic. * New: In Anabatic, merge in the Katabatic tool. The merge is not complete yet. Only basic capabilities have been moved.
2016-07-18 07:48:37 -05:00
: 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.