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

still cleaning

This commit is contained in:
Christophe Alexandre 2008-03-19 10:02:56 +00:00
parent 6aba9ac985
commit 9a6415ae4d
84 changed files with 647 additions and 690 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
hurricane/src/hurricane/BasicLayer.cpp
View File

@ -40,9 +40,9 @@ class BasicLayer_BasicLayers : public Collection<BasicLayer*> {
public: virtual BasicLayer* getElement() const; public: virtual BasicLayer* getElement() const;
public: virtual Hurricane::Locator<BasicLayer*>* getClone() const; public: virtual Hurricane::Locator<BasicLayer*>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
@ -288,13 +288,13 @@ Locator<BasicLayer*>* BasicLayer_BasicLayers::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool BasicLayer_BasicLayers::Locator::IsValid() const bool BasicLayer_BasicLayers::Locator::isValid() const
// ************************************************** // **************************************************
{ {
return (_basicLayer != NULL); return (_basicLayer != NULL);
} }
void BasicLayer_BasicLayers::Locator::Progress() void BasicLayer_BasicLayers::Locator::progress()
// ********************************************* // *********************************************
{ {
_basicLayer = NULL; _basicLayer = NULL;

4
hurricane/src/hurricane/BasicLayers.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<BasicLayer*> BasicLayerFilter;
/****************************************************/\ /****************************************************/\
{\ {\
BasicLayerLocator _locator = basicLayers.getLocator();\ BasicLayerLocator _locator = basicLayers.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
BasicLayer* basicLayer = _locator.getElement();\ BasicLayer* basicLayer = _locator.getElement();\
_locator.Progress(); _locator.progress();

4
hurricane/src/hurricane/Boxes.h
View File

@ -46,9 +46,9 @@ typedef GenericFilter<Box> BoxFilter;
/*******************************/\ /*******************************/\
{\ {\
BoxLocator _locator = boxes.getLocator();\ BoxLocator _locator = boxes.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Box box = _locator.getElement();\ Box box = _locator.getElement();\
_locator.Progress(); _locator.progress();

520
hurricane/src/hurricane/CellCollections.cpp
View File

File diff suppressed because it is too large Load Diff

4
hurricane/src/hurricane/Cells.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Cell*> CellFilter;
/*********************************/\ /*********************************/\
{\ {\
CellLocator _locator = cells.getLocator();\ CellLocator _locator = cells.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Cell* cell = _locator.getElement();\ Cell* cell = _locator.getElement();\
_locator.Progress(); _locator.progress();

90
hurricane/src/hurricane/Collection.h
View File

@ -68,9 +68,9 @@ template<class Type> class Collection : public NestedSlotAdapter {
unsigned size = 0; unsigned size = 0;
// we use a GenericLocator to delete the locator allocated by getLocator() // we use a GenericLocator to delete the locator allocated by getLocator()
GenericLocator<Type> locator = getLocator(); GenericLocator<Type> locator = getLocator();
while (locator.IsValid()) { while (locator.isValid()) {
size++; size++;
locator.Progress(); locator.progress();
} }
return size; return size;
} }
@ -108,7 +108,7 @@ template<class Type> class Collection : public NestedSlotAdapter {
// ************************* // *************************
{ {
// we use a GenericLocator to delete the locator allocated by getLocator() // we use a GenericLocator to delete the locator allocated by getLocator()
return !GenericLocator<Type>(getLocator()).IsValid(); return !GenericLocator<Type>(getLocator()).isValid();
} }
// Utilitarians // Utilitarians
@ -118,9 +118,9 @@ template<class Type> class Collection : public NestedSlotAdapter {
// ************************************** // **************************************
{ {
GenericLocator<Type> locator = getLocator(); GenericLocator<Type> locator = getLocator();
while (locator.IsValid()) { while (locator.isValid()) {
list.push_back(locator.getElement()); list.push_back(locator.getElement());
locator.Progress(); locator.progress();
} }
} }
@ -128,9 +128,9 @@ template<class Type> class Collection : public NestedSlotAdapter {
// ************************************ // ************************************
{ {
GenericLocator<Type> locator = getLocator(); GenericLocator<Type> locator = getLocator();
while (locator.IsValid()) { while (locator.isValid()) {
set.insert(locator.getElement()); set.insert(locator.getElement());
locator.Progress(); locator.progress();
} }
} }
@ -138,9 +138,9 @@ template<class Type> class Collection : public NestedSlotAdapter {
// ********************************************************************* // *********************************************************************
{ {
GenericLocator<Type> locator = getLocator(); GenericLocator<Type> locator = getLocator();
while (locator.IsValid()) { while (locator.isValid()) {
set.insert(locator.getElement()); set.insert(locator.getElement());
locator.Progress(); locator.progress();
} }
} }
@ -148,9 +148,9 @@ template<class Type> class Collection : public NestedSlotAdapter {
// ****************************************** // ******************************************
{ {
GenericLocator<Type> locator = getLocator(); GenericLocator<Type> locator = getLocator();
while (locator.IsValid()) { while (locator.isValid()) {
vector.push_back(locator.getElement()); vector.push_back(locator.getElement());
locator.Progress(); locator.progress();
} }
} }
@ -173,11 +173,11 @@ template<class Type> class Collection : public NestedSlotAdapter {
record = new Record(getString(this)); record = new Record(getString(this));
unsigned n = 1; unsigned n = 1;
GenericLocator<Type> locator = getLocator(); GenericLocator<Type> locator = getLocator();
while (locator.IsValid()) { while (locator.isValid()) {
string slotName = getString(n++); string slotName = getString(n++);
Type slotRecord = locator.getElement(); Type slotRecord = locator.getElement();
record->Add(getSlot(slotName, slotRecord)); record->Add(getSlot(slotName, slotRecord));
locator.Progress(); locator.progress();
} }
} }
return record; return record;
@ -343,8 +343,8 @@ template<class Type> class ElementCollection : public Collection<Type> {
// ********* // *********
public: virtual ElType getElement () const { return const_cast<ElType>(_element); }; public: virtual ElType getElement () const { return const_cast<ElType>(_element); };
public: virtual Locator<ElType>* getClone () const { return new Locator(*this); }; public: virtual Locator<ElType>* getClone () const { return new Locator(*this); };
public: virtual bool IsValid () const { return !_done; }; public: virtual bool isValid () const { return !_done; };
public: virtual void Progress () { _done = true; }; public: virtual void progress () { _done = true; };
// Hurricane Management // Hurricane Management
// ******************** // ********************
@ -461,8 +461,8 @@ template<class Type, class SubType> class SubTypeCollection : public Collection<
: Inherit(), : Inherit(),
_locator(collection.getLocator()) _locator(collection.getLocator())
{ {
while (_locator.IsValid() && !is_a<SubType>(_locator.getElement())) while (_locator.isValid() && !is_a<SubType>(_locator.getElement()))
_locator.Progress(); _locator.progress();
} }
public: Locator(const GenericLocator<Type>& genericLocator) public: Locator(const GenericLocator<Type>& genericLocator)
@ -470,8 +470,8 @@ template<class Type, class SubType> class SubTypeCollection : public Collection<
: Inherit(), : Inherit(),
_locator(genericLocator.getClone()) _locator(genericLocator.getClone())
{ {
while (_locator.IsValid() && !is_a<SubType>(_locator.getElement())) while (_locator.isValid() && !is_a<SubType>(_locator.getElement()))
_locator.Progress(); _locator.progress();
} }
// Accessors // Accessors
@ -480,7 +480,7 @@ template<class Type, class SubType> class SubTypeCollection : public Collection<
public: virtual SubType getElement() const public: virtual SubType getElement() const
// *************************************** // ***************************************
{ {
return (_locator.IsValid()) ? (SubType)_locator.getElement() : SubType(); return (_locator.isValid()) ? (SubType)_locator.getElement() : SubType();
} }
public: virtual Hurricane::Locator<SubType>* getClone() const public: virtual Hurricane::Locator<SubType>* getClone() const
@ -500,22 +500,22 @@ template<class Type, class SubType> class SubTypeCollection : public Collection<
// Predicates // Predicates
// ********** // **********
public: virtual bool IsValid() const public: virtual bool isValid() const
// ********************************* // *********************************
{ {
return _locator.IsValid(); return _locator.isValid();
} }
// Updators // Updators
// ******** // ********
public: virtual void Progress() public: virtual void progress()
// **************************** // ****************************
{ {
if (_locator.IsValid()) { if (_locator.isValid()) {
do { do {
_locator.Progress(); _locator.progress();
} while (_locator.IsValid() && !is_a<SubType>(_locator.getElement())); } while (_locator.isValid() && !is_a<SubType>(_locator.getElement()));
} }
} }
@ -630,8 +630,8 @@ template<class Type> class SubSetCollection : public Collection<Type> {
_locator(collection.getLocator()), _locator(collection.getLocator()),
_filter(filter) _filter(filter)
{ {
while (_locator.IsValid() && !_filter.Accept(_locator.getElement())) while (_locator.isValid() && !_filter.accept(_locator.getElement()))
_locator.Progress(); _locator.progress();
} }
public: Locator(const Collection<Type>& collection, const Filter<Type>& filter) public: Locator(const Collection<Type>& collection, const Filter<Type>& filter)
@ -640,8 +640,8 @@ template<class Type> class SubSetCollection : public Collection<Type> {
_locator(collection.getLocator()), _locator(collection.getLocator()),
_filter(filter) _filter(filter)
{ {
while (_locator.IsValid() && !_filter.Accept(_locator.getElement())) while (_locator.isValid() && !_filter.accept(_locator.getElement()))
_locator.Progress(); _locator.progress();
} }
public: Locator(const GenericCollection<Type>& genericCollection, const Filter<Type>& filter) public: Locator(const GenericCollection<Type>& genericCollection, const Filter<Type>& filter)
@ -650,8 +650,8 @@ template<class Type> class SubSetCollection : public Collection<Type> {
_locator(genericCollection.getLocator()), _locator(genericCollection.getLocator()),
_filter(filter) _filter(filter)
{ {
while (_locator.IsValid() && !_filter.Accept(_locator.getElement())) while (_locator.isValid() && !_filter.accept(_locator.getElement()))
_locator.Progress(); _locator.progress();
} }
public: Locator(const GenericLocator<Type>& genericLocator, const Filter<Type>& filter) public: Locator(const GenericLocator<Type>& genericLocator, const Filter<Type>& filter)
@ -660,8 +660,8 @@ template<class Type> class SubSetCollection : public Collection<Type> {
_locator(genericLocator), _locator(genericLocator),
_filter(filter) _filter(filter)
{ {
while (_locator.IsValid() && !_filter.Accept(_locator.getElement())) while (_locator.isValid() && !_filter.accept(_locator.getElement()))
_locator.Progress(); _locator.progress();
} }
// Accessors // Accessors
@ -670,7 +670,7 @@ template<class Type> class SubSetCollection : public Collection<Type> {
public: virtual Type getElement() const public: virtual Type getElement() const
// ************************************ // ************************************
{ {
return (_locator.IsValid()) ? _locator.getElement() : Type(); return (_locator.isValid()) ? _locator.getElement() : Type();
} }
public: virtual Hurricane::Locator<Type>* getClone() const public: virtual Hurricane::Locator<Type>* getClone() const
@ -688,22 +688,22 @@ template<class Type> class SubSetCollection : public Collection<Type> {
// Predicates // Predicates
// ********** // **********
public: virtual bool IsValid() const public: virtual bool isValid() const
// ********************************* // *********************************
{ {
return _locator.IsValid(); return _locator.isValid();
} }
// Updators // Updators
// ******** // ********
public: virtual void Progress() public: virtual void progress()
// **************************** // ****************************
{ {
if (_locator.IsValid()) { if (_locator.isValid()) {
do { do {
_locator.Progress(); _locator.progress();
} while (_locator.IsValid() && !_filter.Accept(_locator.getElement())); } while (_locator.isValid() && !_filter.accept(_locator.getElement()));
} }
} }
@ -800,17 +800,17 @@ template<class Type> class SubSetCollection : public Collection<Type> {
/*************************************************/\ /*************************************************/\
{\ {\
GenericLocator<Type> _locator = collection.getLocator();\ GenericLocator<Type> _locator = collection.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Type element = _locator.getElement();\ Type element = _locator.getElement();\
_locator.Progress(); _locator.progress();
#define for_each_element(Type, element, collection)\ #define for_each_element(Type, element, collection)\
/*************************************************/\ /*************************************************/\
{\ {\
ElementCollection<Type>::Locator<Type>* _locator = collection.getLocator();\ ElementCollection<Type>::Locator<Type>* _locator = collection.getLocator();\
while (_locator->IsValid()) {\ while (_locator->isValid()) {\
Type element = _locator->getElement();\ Type element = _locator->getElement();\
_locator->Progress(); _locator->progress();
template<typename T> template<typename T>

44
hurricane/src/hurricane/Commons.h
View File

@ -26,21 +26,21 @@
# ifndef __HURRICANE_COMMONS__ #ifndef __HURRICANE_COMMONS__
# define __HURRICANE_COMMONS__ #define __HURRICANE_COMMONS__
# include <stdio.h> #include <stdio.h>
# include <assert.h> #include <assert.h>
# include <string> #include <string>
# include <list> #include <list>
# include <set> #include <set>
# include <map> #include <map>
# include <stack> #include <stack>
# include <vector> #include <vector>
# include <iostream> #include <iostream>
# include <fstream> #include <fstream>
@ -50,13 +50,13 @@
// x-----------------------------------------------------------------x // x-----------------------------------------------------------------x
# define Hurricane H #define Hurricane H
# define BEGIN_NAMESPACE_HURRICANE namespace Hurricane { #define BEGIN_NAMESPACE_HURRICANE namespace Hurricane {
# define END_NAMESPACE_HURRICANE } #define END_NAMESPACE_HURRICANE }
# define USING_NAMESPACE_HURRICANE using namespace std; using namespace Hurricane; #define USING_NAMESPACE_HURRICANE using namespace std; using namespace Hurricane;
# define is_a (bool)dynamic_cast #define is_a (bool)dynamic_cast
using namespace std; using namespace std;
@ -91,8 +91,8 @@ namespace Hurricane {
void ltracein ( unsigned int level, unsigned int count=1 ); void ltracein ( unsigned int level, unsigned int count=1 );
void ltraceout ( unsigned int level, unsigned int count=1 ); void ltraceout ( unsigned int level, unsigned int count=1 );
# define trace if (in_trace() ) cerr << tab #define trace if (in_trace() ) cerr << tab
# define ltrace(level) if (inltrace(level)) cerr << tab #define ltrace(level) if (inltrace(level)) cerr << tab
@ -136,7 +136,7 @@ using namespace std;
// Note: we are outside the Hurricane namespace. // Note: we are outside the Hurricane namespace.
# include "SlotAdapter.h" #include "SlotAdapter.h"
@ -166,9 +166,9 @@ bool Scan ( const string& s, unsigned short& redValue
// Note: Record & Tabulation are not templates, so they can be defined // Note: Record & Tabulation are not templates, so they can be defined
// early. // early.
# include "Tabulation.h" #include "Tabulation.h"
# endif #endif

26
hurricane/src/hurricane/Component.cpp
View File

@ -50,7 +50,7 @@ class Component_IsUnderFilter : public Filter<Component*> {
return new Component_IsUnderFilter(*this); return new Component_IsUnderFilter(*this);
}; };
public: virtual bool Accept(Component* component) const public: virtual bool accept(Component* component) const
// **************************************************** // ****************************************************
{ {
return _area.intersect(component->getBoundingBox()); return _area.intersect(component->getBoundingBox());
@ -94,9 +94,9 @@ class Component_Hooks : public Collection<Hook*> {
public: virtual Hook* getElement() const; public: virtual Hook* getElement() const;
public: virtual Hurricane::Locator<Hook*>* getClone() const; public: virtual Hurricane::Locator<Hook*>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
@ -162,9 +162,9 @@ class Component_ConnexComponents : public Collection<Component*> {
public: virtual Component* getElement() const; public: virtual Component* getElement() const;
public: virtual Hurricane::Locator<Component*>* getClone() const; public: virtual Hurricane::Locator<Component*>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
@ -230,9 +230,9 @@ class Component_SlaveComponents : public Collection<Component*> {
public: virtual Component* getElement() const; public: virtual Component* getElement() const;
public: virtual Hurricane::Locator<Component*>* getClone() const; public: virtual Hurricane::Locator<Component*>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
@ -626,13 +626,13 @@ Locator<Hook*>* Component_Hooks::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool Component_Hooks::Locator::IsValid() const bool Component_Hooks::Locator::isValid() const
// ******************************************* // *******************************************
{ {
return (_hook != NULL); return (_hook != NULL);
} }
void Component_Hooks::Locator::Progress() void Component_Hooks::Locator::progress()
// ************************************** // **************************************
{ {
_hook = NULL; _hook = NULL;
@ -745,13 +745,13 @@ Locator<Component*>* Component_ConnexComponents::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool Component_ConnexComponents::Locator::IsValid() const bool Component_ConnexComponents::Locator::isValid() const
// ****************************************************** // ******************************************************
{ {
return !_componentStack.empty(); return !_componentStack.empty();
} }
void Component_ConnexComponents::Locator::Progress() void Component_ConnexComponents::Locator::progress()
// ************************************************* // *************************************************
{ {
if (!_componentStack.empty()) { if (!_componentStack.empty()) {
@ -895,13 +895,13 @@ Locator<Component*>* Component_SlaveComponents::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool Component_SlaveComponents::Locator::IsValid() const bool Component_SlaveComponents::Locator::isValid() const
// ***************************************************** // *****************************************************
{ {
return !_componentStack.empty(); return !_componentStack.empty();
} }
void Component_SlaveComponents::Locator::Progress() void Component_SlaveComponents::Locator::progress()
// ************************************************ // ************************************************
{ {
if (!_componentStack.empty()) { if (!_componentStack.empty()) {

4
hurricane/src/hurricane/Components.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Component*> ComponentFilter;
/************************************************/\ /************************************************/\
{\ {\
ComponentLocator _locator = components.getLocator();\ ComponentLocator _locator = components.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Component* component = _locator.getElement();\ Component* component = _locator.getElement();\
_locator.Progress(); _locator.progress();

4
hurricane/src/hurricane/CompositeLayers.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<CompositeLayer*> CompositeLayerFilter;
/****************************************************************/\ /****************************************************************/\
{\ {\
CompositeLayerLocator _locator = compositeLayers.getLocator();\ CompositeLayerLocator _locator = compositeLayers.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
CompositeLayer* compositeLayer = _locator.getElement();\ CompositeLayer* compositeLayer = _locator.getElement();\
_locator.Progress(); _locator.progress();

8
hurricane/src/hurricane/Contact.cpp
View File

@ -43,9 +43,9 @@ class Contact_Hooks : public Collection<Hook*> {
public: virtual Hook* getElement() const; public: virtual Hook* getElement() const;
public: virtual Hurricane::Locator<Hook*>* getClone() const; public: virtual Hurricane::Locator<Hook*>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
@ -489,13 +489,13 @@ Locator<Hook*>* Contact_Hooks::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool Contact_Hooks::Locator::IsValid() const bool Contact_Hooks::Locator::isValid() const
// ***************************************** // *****************************************
{ {
return (_hook != NULL); return (_hook != NULL);
} }
void Contact_Hooks::Locator::Progress() void Contact_Hooks::Locator::progress()
// ************************************ // ************************************
{ {
if (_hook) { if (_hook) {

4
hurricane/src/hurricane/Contacts.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Contact*> ContactFilter;
/******************************************/\ /******************************************/\
{\ {\
ContactLocator _locator = contacts.getLocator();\ ContactLocator _locator = contacts.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Contact* contact = _locator.getElement();\ Contact* contact = _locator.getElement();\
_locator.Progress(); _locator.progress();

4
hurricane/src/hurricane/DBos.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<DBo*> DBoFilter;
/******************************/\ /******************************/\
{\ {\
DBoLocator _locator = dbos.getLocator();\ DBoLocator _locator = dbos.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
DBo* dbo = _locator.getElement();\ DBo* dbo = _locator.getElement();\
_locator.Progress(); _locator.progress();

2
hurricane/src/hurricane/DeepNet.cpp
View File

@ -127,7 +127,7 @@ Record* DeepNet::_getRecord () const
DeepNet* DeepNet::create ( HyperNet& hyperNet ) DeepNet* DeepNet::create ( HyperNet& hyperNet )
{ {
if ( !hyperNet.IsValid() ) if ( !hyperNet.isValid() )
throw Error ( "Can't create " + _TName("DeepNet") + ": occurence is invalid." ); throw Error ( "Can't create " + _TName("DeepNet") + ": occurence is invalid." );
Occurrence rootNetOccurrence = getHyperNetRootNetOccurrence ( hyperNet.getNetOccurrence() ); Occurrence rootNetOccurrence = getHyperNetRootNetOccurrence ( hyperNet.getNetOccurrence() );

4
hurricane/src/hurricane/DisplaySlots.h
View File

@ -51,9 +51,9 @@ typedef GenericFilter<DisplaySlot*> DisplaySlotFilter;
/******************************************************/\ /******************************************************/\
{\ {\
DisplaySlotLocator _locator = displaySlots.getLocator();\ DisplaySlotLocator _locator = displaySlots.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
DisplaySlot* displaySlot = _locator.getElement();\ DisplaySlot* displaySlot = _locator.getElement();\
_locator.Progress(); _locator.progress();

4
hurricane/src/hurricane/Entities.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Entity*> EntityFilter;
/****************************************/\ /****************************************/\
{\ {\
EntityLocator _locator = entities.getLocator();\ EntityLocator _locator = entities.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Entity* entity = _locator.getElement();\ Entity* entity = _locator.getElement();\
_locator.Progress(); _locator.progress();

10
hurricane/src/hurricane/Filter.h
View File

@ -54,7 +54,7 @@ template<class Type> class Filter : public NestedSlotAdapter {
// Predicates // Predicates
// ********** // **********
public: virtual bool Accept(Type type) const = 0; public: virtual bool accept(Type type) const = 0;
// Others // Others
// ****** // ******
@ -166,10 +166,10 @@ template<class Type> class GenericFilter : public Filter<Type> {
// Predicates // Predicates
// ********** // **********
public: virtual bool Accept(Type type) const public: virtual bool accept(Type type) const
// ***************************************** // *****************************************
{ {
return (_filter) ? _filter->Accept(type) : false; return (_filter) ? _filter->accept(type) : false;
}; };
// Others // Others
@ -257,10 +257,10 @@ template<class Type> class NotFilter : public Filter<Type> {
// Predicates // Predicates
// ********** // **********
public: virtual bool Accept(Type type) const public: virtual bool accept(Type type) const
// ***************************************** // *****************************************
{ {
return !_genericFilter.Accept(type); return !_genericFilter.accept(type);
}; };
// Others // Others

4
hurricane/src/hurricane/Gos.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Go*> GoFilter;
/***************************/\ /***************************/\
{\ {\
GoLocator _locator = gos.getLocator();\ GoLocator _locator = gos.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Go* go = _locator.getElement();\ Go* go = _locator.getElement();\
_locator.Progress(); _locator.progress();

18
hurricane/src/hurricane/Hook.cpp
View File

@ -28,7 +28,7 @@ class Hook_IsMasterFilter : public Filter<Hook*> {
public: virtual Filter<Hook*>* getClone() const {return new Hook_IsMasterFilter(*this);}; public: virtual Filter<Hook*>* getClone() const {return new Hook_IsMasterFilter(*this);};
public: virtual bool Accept(Hook* hook) const {return hook->IsMaster();}; public: virtual bool accept(Hook* hook) const {return hook->IsMaster();};
public: virtual string _getString() const {return "<" + _TName("Hook::IsMasterFilter>");}; public: virtual string _getString() const {return "<" + _TName("Hook::IsMasterFilter>");};
@ -64,9 +64,9 @@ class Hook_Hooks : public Collection<Hook*> {
public: virtual Hook* getElement() const; public: virtual Hook* getElement() const;
public: virtual Hurricane::Locator<Hook*>* getClone() const; public: virtual Hurricane::Locator<Hook*>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
@ -131,9 +131,9 @@ class Hook_SlaveHooks : public Collection<Hook*> {
public: virtual Hook* getElement() const; public: virtual Hook* getElement() const;
public: virtual Hurricane::Locator<Hook*>* getClone() const; public: virtual Hurricane::Locator<Hook*>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
@ -462,13 +462,13 @@ Locator<Hook*>* Hook_Hooks::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool Hook_Hooks::Locator::IsValid() const bool Hook_Hooks::Locator::isValid() const
// ************************************** // **************************************
{ {
return (_currentHook != NULL); return (_currentHook != NULL);
} }
void Hook_Hooks::Locator::Progress() void Hook_Hooks::Locator::progress()
// ********************************* // *********************************
{ {
if (_currentHook) { if (_currentHook) {
@ -584,13 +584,13 @@ Locator<Hook*>* Hook_SlaveHooks::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool Hook_SlaveHooks::Locator::IsValid() const bool Hook_SlaveHooks::Locator::isValid() const
// ******************************************* // *******************************************
{ {
return (_currentHook != NULL); return (_currentHook != NULL);
} }
void Hook_SlaveHooks::Locator::Progress() void Hook_SlaveHooks::Locator::progress()
// ************************************** // **************************************
{ {
if (_currentHook) { if (_currentHook) {

4
hurricane/src/hurricane/Hooks.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Hook*> HookFilter;
/*********************************/\ /*********************************/\
{\ {\
HookLocator _locator = hooks.getLocator();\ HookLocator _locator = hooks.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Hook* hook = _locator.getElement();\ Hook* hook = _locator.getElement();\
_locator.Progress(); _locator.progress();

4
hurricane/src/hurricane/Horizontals.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Horizontal*> HorizontalFilter;
/***************************************************/\ /***************************************************/\
{\ {\
HorizontalLocator _locator = horizontals.getLocator();\ HorizontalLocator _locator = horizontals.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Horizontal* horizontal = _locator.getElement();\ Horizontal* horizontal = _locator.getElement();\
_locator.Progress(); _locator.progress();

42
hurricane/src/hurricane/HyperNet.cpp
View File

@ -50,9 +50,9 @@ class HyperNet_NetOccurrences : public Collection<Occurrence> {
public: virtual Occurrence getElement() const; public: virtual Occurrence getElement() const;
public: virtual Hurricane::Locator<Occurrence>* getClone() const; public: virtual Hurricane::Locator<Occurrence>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
@ -124,9 +124,9 @@ class HyperNet_NetOccurrencesUnder : public Collection<Occurrence> {
public: virtual Occurrence getElement() const; public: virtual Occurrence getElement() const;
public: virtual Hurricane::Locator<Occurrence>* getClone() const; public: virtual Hurricane::Locator<Occurrence>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
@ -200,9 +200,9 @@ class HyperNet_LeafPlugOccurrences : public Collection<Occurrence> {
public: virtual Occurrence getElement() const; public: virtual Occurrence getElement() const;
public: virtual Hurricane::Locator<Occurrence>* getClone() const; public: virtual Hurricane::Locator<Occurrence>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
@ -250,7 +250,7 @@ HyperNet::HyperNet(const Occurrence& occurrence)
// ******************************************* // *******************************************
: _netOccurrence() : _netOccurrence()
{ {
if (occurrence.IsValid()) { if (occurrence.isValid()) {
Entity* entity = occurrence.getEntity(); Entity* entity = occurrence.getEntity();
if (is_a<Net*>(entity)) if (is_a<Net*>(entity))
_netOccurrence = occurrence; _netOccurrence = occurrence;
@ -293,7 +293,7 @@ string HyperNet::_getString() const
// ******************************** // ********************************
{ {
string s = "<" + _TName("HyperNet"); string s = "<" + _TName("HyperNet");
if (IsValid()) s += " " + getString(_netOccurrence); if (isValid()) s += " " + getString(_netOccurrence);
s += ">"; s += ">";
return s; return s;
} }
@ -311,7 +311,7 @@ Record* HyperNet::_getRecord() const
Occurrence getHyperNetRootNetOccurrence(const Occurrence& netoccurrence) Occurrence getHyperNetRootNetOccurrence(const Occurrence& netoccurrence)
// ********************************************************************* // *********************************************************************
{ {
if (!netoccurrence.IsValid()) if (!netoccurrence.isValid())
throw Error("getHyperNetRootNetOccurrence : invalid occurrence"); throw Error("getHyperNetRootNetOccurrence : invalid occurrence");
Net* net = dynamic_cast<Net*>(netoccurrence.getEntity()); Net* net = dynamic_cast<Net*>(netoccurrence.getEntity());
@ -449,7 +449,7 @@ HyperNet_NetOccurrences::Locator::Locator(const HyperNet* hyperNet, bool doExtra
{ {
if (_hyperNet) { if (_hyperNet) {
Occurrence netOccurrence = _hyperNet->getNetOccurrence(); Occurrence netOccurrence = _hyperNet->getNetOccurrence();
if (netOccurrence.IsValid()) { if (netOccurrence.isValid()) {
_netOccurrenceSet.insert(netOccurrence); _netOccurrenceSet.insert(netOccurrence);
_netOccurrenceStack.push(netOccurrence); _netOccurrenceStack.push(netOccurrence);
} }
@ -490,7 +490,7 @@ Locator<Occurrence>* HyperNet_NetOccurrences::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool HyperNet_NetOccurrences::Locator::IsValid() const bool HyperNet_NetOccurrences::Locator::isValid() const
// ************************************************** // **************************************************
{ {
return !_netOccurrenceStack.empty(); return !_netOccurrenceStack.empty();
@ -521,7 +521,7 @@ static bool IsConnex(const Occurrence& componentOccurrence1, const Occurrence& c
return false; return false;
} }
void HyperNet_NetOccurrences::Locator::Progress() void HyperNet_NetOccurrences::Locator::progress()
// ********************************************* // *********************************************
{ {
if (!_netOccurrenceStack.empty()) { if (!_netOccurrenceStack.empty()) {
@ -703,7 +703,7 @@ HyperNet_NetOccurrencesUnder::Locator::Locator(const HyperNet* hyperNet, Box are
{ {
if (_hyperNet) { if (_hyperNet) {
Occurrence netOccurrence = _hyperNet->getNetOccurrence(); Occurrence netOccurrence = _hyperNet->getNetOccurrence();
if (netOccurrence.IsValid()) { if (netOccurrence.isValid()) {
_netOccurrenceSet.insert(netOccurrence); _netOccurrenceSet.insert(netOccurrence);
_netOccurrenceStack.push(netOccurrence); _netOccurrenceStack.push(netOccurrence);
} }
@ -746,13 +746,13 @@ Locator<Occurrence>* HyperNet_NetOccurrencesUnder::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool HyperNet_NetOccurrencesUnder::Locator::IsValid() const bool HyperNet_NetOccurrencesUnder::Locator::isValid() const
// ******************************************************* // *******************************************************
{ {
return !_netOccurrenceStack.empty(); return !_netOccurrenceStack.empty();
} }
void HyperNet_NetOccurrencesUnder::Locator::Progress() void HyperNet_NetOccurrencesUnder::Locator::progress()
// ************************************************** // **************************************************
{ {
if (!_netOccurrenceStack.empty()) { if (!_netOccurrenceStack.empty()) {
@ -927,7 +927,7 @@ HyperNet_LeafPlugOccurrences::Locator::Locator(const HyperNet* hyperNet, bool do
{ {
if (hyperNet) { if (hyperNet) {
_netOccurrenceLocator = hyperNet->getNetOccurrences(doExtraction,allowInterruption).getLocator(); _netOccurrenceLocator = hyperNet->getNetOccurrences(doExtraction,allowInterruption).getLocator();
Progress(); progress();
} }
} }
@ -959,21 +959,21 @@ Locator<Occurrence>* HyperNet_LeafPlugOccurrences::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool HyperNet_LeafPlugOccurrences::Locator::IsValid() const bool HyperNet_LeafPlugOccurrences::Locator::isValid() const
// ************************************************** // **************************************************
{ {
return _plugOccurrence.IsValid(); return _plugOccurrence.isValid();
} }
void HyperNet_LeafPlugOccurrences::Locator::Progress() void HyperNet_LeafPlugOccurrences::Locator::progress()
// ********************************************* // *********************************************
{ {
_plugOccurrence = Occurrence(); _plugOccurrence = Occurrence();
while(_netOccurrenceLocator.IsValid() && !_plugOccurrence.IsValid()) while(_netOccurrenceLocator.isValid() && !_plugOccurrence.isValid())
{ {
Occurrence netOccurrence = _netOccurrenceLocator.getElement(); Occurrence netOccurrence = _netOccurrenceLocator.getElement();
_netOccurrenceLocator.Progress(); _netOccurrenceLocator.progress();
Net* net = (Net*)netOccurrence.getEntity(); Net* net = (Net*)netOccurrence.getEntity();
Path path = netOccurrence.getPath(); Path path = netOccurrence.getPath();
if (!path.IsEmpty() && net->getCell()->IsLeaf()) if (!path.IsEmpty() && net->getCell()->IsLeaf())

2
hurricane/src/hurricane/HyperNet.h
View File

@ -51,7 +51,7 @@ class HyperNet {
// Predicates // Predicates
// ********** // **********
public: bool IsValid() const {return _netOccurrence.IsValid();}; public: bool isValid() const {return _netOccurrence.isValid();};
// Others // Others
// ****** // ******

12
hurricane/src/hurricane/Instance.cpp
View File

@ -50,7 +50,7 @@ class Instance_IsUnderFilter : public Filter<Instance*> {
return new Instance_IsUnderFilter(*this); return new Instance_IsUnderFilter(*this);
}; };
public: virtual bool Accept(Instance* instance) const public: virtual bool accept(Instance* instance) const
// ************************************************** // **************************************************
{ {
return _area.intersect(instance->getBoundingBox()); return _area.intersect(instance->getBoundingBox());
@ -75,7 +75,7 @@ class Instance_IsTerminalFilter : public Filter<Instance*> {
public: virtual Filter<Instance*>* getClone() const {return new Instance_IsTerminalFilter(*this);}; public: virtual Filter<Instance*>* getClone() const {return new Instance_IsTerminalFilter(*this);};
public: virtual bool Accept(Instance* instance) const {return instance->IsTerminal();}; public: virtual bool accept(Instance* instance) const {return instance->IsTerminal();};
public: virtual string _getString() const {return "<" + _TName("Instance::IsTerminalFilter") + ">";}; public: virtual string _getString() const {return "<" + _TName("Instance::IsTerminalFilter") + ">";};
@ -92,7 +92,7 @@ class Instance_IsLeafFilter : public Filter<Instance*> {
public: virtual Filter<Instance*>* getClone() const {return new Instance_IsLeafFilter(*this);}; public: virtual Filter<Instance*>* getClone() const {return new Instance_IsLeafFilter(*this);};
public: virtual bool Accept(Instance* instance) const {return instance->IsLeaf();}; public: virtual bool accept(Instance* instance) const {return instance->IsLeaf();};
public: virtual string _getString() const {return "<" + _TName("Instance::IsLeafFilter") + ">";}; public: virtual string _getString() const {return "<" + _TName("Instance::IsLeafFilter") + ">";};
@ -109,7 +109,7 @@ class Instance_IsUnplacedFilter : public Filter<Instance*> {
public: virtual Filter<Instance*>* getClone() const {return new Instance_IsUnplacedFilter(*this);}; public: virtual Filter<Instance*>* getClone() const {return new Instance_IsUnplacedFilter(*this);};
public: virtual bool Accept(Instance* instance) const {return instance->IsUnplaced();}; public: virtual bool accept(Instance* instance) const {return instance->IsUnplaced();};
public: virtual string _getString() const {return "<" + _TName("Net::IsUnplacedFilter>");}; public: virtual string _getString() const {return "<" + _TName("Net::IsUnplacedFilter>");};
@ -126,7 +126,7 @@ class Instance_IsPlacedFilter : public Filter<Instance*> {
public: virtual Filter<Instance*>* getClone() const {return new Instance_IsPlacedFilter(*this);}; public: virtual Filter<Instance*>* getClone() const {return new Instance_IsPlacedFilter(*this);};
public: virtual bool Accept(Instance* instance) const {return instance->IsPlaced();}; public: virtual bool accept(Instance* instance) const {return instance->IsPlaced();};
public: virtual string _getString() const {return "<" + _TName("Net::IsPlacedFilter>");}; public: virtual string _getString() const {return "<" + _TName("Net::IsPlacedFilter>");};
@ -143,7 +143,7 @@ class Instance_IsFixedFilter : public Filter<Instance*> {
public: virtual Filter<Instance*>* getClone() const {return new Instance_IsFixedFilter(*this);}; public: virtual Filter<Instance*>* getClone() const {return new Instance_IsFixedFilter(*this);};
public: virtual bool Accept(Instance* instance) const {return instance->IsFixed();}; public: virtual bool accept(Instance* instance) const {return instance->IsFixed();};
public: virtual string _getString() const {return "<" + _TName("Net::IsFixedFilter>");}; public: virtual string _getString() const {return "<" + _TName("Net::IsFixedFilter>");};

4
hurricane/src/hurricane/Instances.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Instance*> InstanceFilter;
/*********************************************/\ /*********************************************/\
{\ {\
InstanceLocator _locator = instances.getLocator();\ InstanceLocator _locator = instances.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Instance* instance = _locator.getElement();\ Instance* instance = _locator.getElement();\
_locator.Progress(); _locator.progress();

4
hurricane/src/hurricane/Intervals.h
View File

@ -46,9 +46,9 @@ typedef GenericFilter<Interval> IntervalFilter;
/*********************************************/\ /*********************************************/\
{\ {\
IntervalLocator _locator = intervals.getLocator();\ IntervalLocator _locator = intervals.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Interval interval = _locator.getElement();\ Interval interval = _locator.getElement();\
_locator.Progress(); _locator.progress();

4
hurricane/src/hurricane/IntrusiveMap.h
View File

@ -106,7 +106,7 @@ template<class Key, class Element> class IntrusiveMap {
// Predicates // Predicates
// ********** // **********
public: virtual bool IsValid() const public: virtual bool isValid() const
// ********************************* // *********************************
{ {
return (_element != NULL); return (_element != NULL);
@ -115,7 +115,7 @@ template<class Key, class Element> class IntrusiveMap {
// Updators // Updators
// ******** // ********
public: virtual void Progress() public: virtual void progress()
// **************************** // ****************************
{ {
if (_element) { if (_element) {

4
hurricane/src/hurricane/IntrusiveSet.h
View File

@ -106,7 +106,7 @@ template<class Element> class IntrusiveSet : public NestedSlotAdapter {
// Predicates // Predicates
// ********** // **********
public: virtual bool IsValid() const public: virtual bool isValid() const
// ********************************* // *********************************
{ {
return (_element != NULL); return (_element != NULL);
@ -115,7 +115,7 @@ template<class Element> class IntrusiveSet : public NestedSlotAdapter {
// Updators // Updators
// ******** // ********
public: virtual void Progress() public: virtual void progress()
// **************************** // ****************************
{ {
if (_element) { if (_element) {

4
hurricane/src/hurricane/Layers.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Layer*> LayerFilter;
/************************************/\ /************************************/\
{\ {\
LayerLocator _locator = layers.getLocator();\ LayerLocator _locator = layers.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Layer* layer = _locator.getElement();\ Layer* layer = _locator.getElement();\
_locator.Progress(); _locator.progress();

4
hurricane/src/hurricane/Libraries.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Library*> LibraryFilter;
/*******************************************/\ /*******************************************/\
{\ {\
LibraryLocator _locator = libraries.getLocator();\ LibraryLocator _locator = libraries.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Library* library = _locator.getElement();\ Library* library = _locator.getElement();\
_locator.Progress(); _locator.progress();

6
hurricane/src/hurricane/ListCollection.h
View File

@ -47,7 +47,7 @@ template<class Element> class ListCollection : public Collection<Element> {
public: virtual Element getElement() const public: virtual Element getElement() const
// *************************************** // ***************************************
{ {
return (IsValid()) ? *_iterator : Element(); return (isValid()) ? *_iterator : Element();
}; };
public: virtual Hurricane::Locator<Element>* getClone() const public: virtual Hurricane::Locator<Element>* getClone() const
@ -56,13 +56,13 @@ template<class Element> class ListCollection : public Collection<Element> {
return new Locator(_elementList); return new Locator(_elementList);
}; };
public: virtual bool IsValid() const public: virtual bool isValid() const
// ********************************* // *********************************
{ {
return (_elementList && (_iterator != _elementList->end())); return (_elementList && (_iterator != _elementList->end()));
}; };
public: virtual void Progress() public: virtual void progress()
// **************************** // ****************************
{ {
++_iterator; ++_iterator;

14
hurricane/src/hurricane/Locator.h
View File

@ -65,12 +65,12 @@ template<class Type> class Locator : public NestedSlotAdapter {
// Predicates // Predicates
// ********** // **********
public: virtual bool IsValid() const = 0; public: virtual bool isValid() const = 0;
// Updators // Updators
// ******** // ********
public: virtual void Progress() = 0; public: virtual void progress() = 0;
// Others // Others
// ****** // ******
@ -84,7 +84,7 @@ template<class Type> class Locator : public NestedSlotAdapter {
public: virtual string _getString() const public: virtual string _getString() const
// ************************************** // **************************************
{ {
if (!IsValid()) if (!isValid())
return "<" + _getTypeName() + " invalid>"; return "<" + _getTypeName() + " invalid>";
else else
return "<" + _getTypeName() + " " + getString(getElement()) + ">"; return "<" + _getTypeName() + " " + getString(getElement()) + ">";
@ -207,19 +207,19 @@ template<class Type> class GenericLocator : public Locator<Type> {
// Predicates // Predicates
// ********** // **********
public: virtual bool IsValid() const public: virtual bool isValid() const
// ********************************* // *********************************
{ {
return (_locator && _locator->IsValid()); return (_locator && _locator->isValid());
}; };
// Updators // Updators
// ******** // ********
public: virtual void Progress() public: virtual void progress()
// **************************** // ****************************
{ {
if (_locator) _locator->Progress(); if (_locator) _locator->progress();
}; };
// Others // Others

6
hurricane/src/hurricane/MapCollection.h
View File

@ -48,7 +48,7 @@ template<class Key, class Element, class Compare = less<Key> >
public: virtual Element GetElement() const public: virtual Element GetElement() const
// *************************************** // ***************************************
{ {
return (IsValid()) ? (*_iterator).second : Element(); return (isValid()) ? (*_iterator).second : Element();
}; };
public: virtual Hurricane::Locator<Element>* GetClone() const public: virtual Hurricane::Locator<Element>* GetClone() const
@ -57,13 +57,13 @@ template<class Key, class Element, class Compare = less<Key> >
return new Locator(_elementMap); return new Locator(_elementMap);
}; };
public: virtual bool IsValid() const public: virtual bool isValid() const
// ********************************* // *********************************
{ {
return (_elementMap && (_iterator != _elementMap->end())); return (_elementMap && (_iterator != _elementMap->end()));
}; };
public: virtual void Progress() public: virtual void progress()
// **************************** // ****************************
{ {
++_iterator; ++_iterator;

4
hurricane/src/hurricane/Markers.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Marker*> MarkerFilter;
/***************************************/\ /***************************************/\
{\ {\
MarkerLocator _locator = markers.getLocator();\ MarkerLocator _locator = markers.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Marker* marker = _locator.getElement();\ Marker* marker = _locator.getElement();\
_locator.Progress(); _locator.progress();

6
hurricane/src/hurricane/MultisetCollection.h
View File

@ -53,7 +53,7 @@ template<class Element, class Compare = less<Element> >
public: virtual Element getElement() const public: virtual Element getElement() const
// *************************************** // ***************************************
{ {
return (IsValid()) ? *_iterator : Element(); return (isValid()) ? *_iterator : Element();
}; };
public: virtual Hurricane::Locator<Element>* getClone() const public: virtual Hurricane::Locator<Element>* getClone() const
@ -62,13 +62,13 @@ template<class Element, class Compare = less<Element> >
return new Locator(_elementMultiset); return new Locator(_elementMultiset);
}; };
public: virtual bool IsValid() const public: virtual bool isValid() const
// ********************************* // *********************************
{ {
return (_elementMultiset && (_iterator != _elementMultiset->end())); return (_elementMultiset && (_iterator != _elementMultiset->end()));
}; };
public: virtual void Progress() public: virtual void progress()
// **************************** // ****************************
{ {
++_iterator; ++_iterator;

4
hurricane/src/hurricane/Names.h
View File

@ -46,9 +46,9 @@ typedef GenericFilter<Name*> NameFilter;
/****************************************************/\ /****************************************************/\
{\ {\
NameLocator _locator = names.getLocator();\ NameLocator _locator = names.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Name* name = _locator.getElement();\ Name* name = _locator.getElement();\
_locator.Progress(); _locator.progress();
} // End of Hurricane namespace. } // End of Hurricane namespace.

34
hurricane/src/hurricane/Net.cpp
View File

@ -37,7 +37,7 @@ class Net_IsCellNetFilter : public Filter<Net*> {
public: virtual Filter<Net*>* getClone() const {return new Net_IsCellNetFilter(*this);}; public: virtual Filter<Net*>* getClone() const {return new Net_IsCellNetFilter(*this);};
public: virtual bool Accept(Net* net) const {return !net->IsDeepNet();}; public: virtual bool accept(Net* net) const {return !net->IsDeepNet();};
public: virtual string _getString() const {return "<" + _TName("Net::IsCellNetFilter>");}; public: virtual string _getString() const {return "<" + _TName("Net::IsCellNetFilter>");};
@ -54,7 +54,7 @@ class Net_IsDeepNetFilter : public Filter<Net*> {
public: virtual Filter<Net*>* getClone() const {return new Net_IsDeepNetFilter(*this);}; public: virtual Filter<Net*>* getClone() const {return new Net_IsDeepNetFilter(*this);};
public: virtual bool Accept(Net* net) const {return net->IsDeepNet();}; public: virtual bool accept(Net* net) const {return net->IsDeepNet();};
public: virtual string _getString() const {return "<" + _TName("Net::IsDeepNetFilter>");}; public: virtual string _getString() const {return "<" + _TName("Net::IsDeepNetFilter>");};
@ -71,7 +71,7 @@ class Net_IsGlobalFilter : public Filter<Net*> {
public: virtual Filter<Net*>* getClone() const {return new Net_IsGlobalFilter(*this);}; public: virtual Filter<Net*>* getClone() const {return new Net_IsGlobalFilter(*this);};
public: virtual bool Accept(Net* net) const {return net->IsGlobal();}; public: virtual bool accept(Net* net) const {return net->IsGlobal();};
public: virtual string _getString() const {return "<" + _TName("Net::IsGlobalFilter>");}; public: virtual string _getString() const {return "<" + _TName("Net::IsGlobalFilter>");};
@ -88,7 +88,7 @@ class Net_IsExternalFilter : public Filter<Net*> {
public: virtual Filter<Net*>* getClone() const {return new Net_IsExternalFilter(*this);}; public: virtual Filter<Net*>* getClone() const {return new Net_IsExternalFilter(*this);};
public: virtual bool Accept(Net* net) const {return net->IsExternal();}; public: virtual bool accept(Net* net) const {return net->IsExternal();};
public: virtual string _getString() const {return "<" + _TName("Net::IsExternalFilter>");}; public: virtual string _getString() const {return "<" + _TName("Net::IsExternalFilter>");};
@ -105,7 +105,7 @@ class Net_IsClockFilter : public Filter<Net*> {
public: virtual Filter<Net*>* getClone() const {return new Net_IsClockFilter(*this);}; public: virtual Filter<Net*>* getClone() const {return new Net_IsClockFilter(*this);};
public: virtual bool Accept(Net* net) const {return net->IsClock();}; public: virtual bool accept(Net* net) const {return net->IsClock();};
public: virtual string _getString() const {return "<" + _TName("Net::IsClockFilter>");}; public: virtual string _getString() const {return "<" + _TName("Net::IsClockFilter>");};
@ -122,7 +122,7 @@ class Net_IsSupplyFilter : public Filter<Net*> {
public: virtual Filter<Net*>* getClone() const {return new Net_IsSupplyFilter(*this);}; public: virtual Filter<Net*>* getClone() const {return new Net_IsSupplyFilter(*this);};
public: virtual bool Accept(Net* net) const {return net->IsSupply();}; public: virtual bool accept(Net* net) const {return net->IsSupply();};
public: virtual string _getString() const {return "<" + _TName("Net::IsSupplyFilter>");}; public: virtual string _getString() const {return "<" + _TName("Net::IsSupplyFilter>");};
@ -139,7 +139,7 @@ class Net_IsPowerFilter : public Filter<Net*> {
public: virtual Filter<Net*>* getClone() const {return new Net_IsPowerFilter(*this);}; public: virtual Filter<Net*>* getClone() const {return new Net_IsPowerFilter(*this);};
public: virtual bool Accept(Net* net) const {return net->IsPower();}; public: virtual bool accept(Net* net) const {return net->IsPower();};
public: virtual string _getString() const {return "<" + _TName("Net::IsPowerFilter>");}; public: virtual string _getString() const {return "<" + _TName("Net::IsPowerFilter>");};
@ -156,7 +156,7 @@ class Net_IsGroundFilter : public Filter<Net*> {
public: virtual Filter<Net*>* getClone() const {return new Net_IsGroundFilter(*this);}; public: virtual Filter<Net*>* getClone() const {return new Net_IsGroundFilter(*this);};
public: virtual bool Accept(Net* net) const {return net->IsGround();}; public: virtual bool accept(Net* net) const {return net->IsGround();};
public: virtual string _getString() const {return "<" + _TName("Net::IsGroundFilter>");}; public: virtual string _getString() const {return "<" + _TName("Net::IsGroundFilter>");};
@ -193,9 +193,9 @@ class Net_SlavePlugs : public Collection<Plug*> {
public: virtual Plug* getElement() const; public: virtual Plug* getElement() const;
public: virtual Hurricane::Locator<Plug*>* getClone() const; public: virtual Hurricane::Locator<Plug*>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
@ -858,9 +858,9 @@ Net_SlavePlugs::Locator::Locator(const Net* net)
{ {
if (_net) { if (_net) {
_instanceLocator = _net->getCell()->getSlaveInstances().getLocator(); _instanceLocator = _net->getCell()->getSlaveInstances().getLocator();
while (!_plug && _instanceLocator.IsValid()) { while (!_plug && _instanceLocator.isValid()) {
_plug = _instanceLocator.getElement()->getPlug(_net); _plug = _instanceLocator.getElement()->getPlug(_net);
_instanceLocator.Progress(); _instanceLocator.progress();
} }
} }
} }
@ -895,20 +895,20 @@ Locator<Plug*>* Net_SlavePlugs::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool Net_SlavePlugs::Locator::IsValid() const bool Net_SlavePlugs::Locator::isValid() const
// ****************************************** // ******************************************
{ {
return (_plug != NULL); return (_plug != NULL);
} }
void Net_SlavePlugs::Locator::Progress() void Net_SlavePlugs::Locator::progress()
// ************************************* // *************************************
{ {
if (IsValid()) { if (isValid()) {
_plug = NULL; _plug = NULL;
while (!_plug && _instanceLocator.IsValid()) { while (!_plug && _instanceLocator.isValid()) {
_plug = _instanceLocator.getElement()->getPlug(_net); _plug = _instanceLocator.getElement()->getPlug(_net);
_instanceLocator.Progress(); _instanceLocator.progress();
} }
} }
} }

4
hurricane/src/hurricane/Nets.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Net*> NetFilter;
/******************************/\ /******************************/\
{\ {\
NetLocator _locator = nets.getLocator();\ NetLocator _locator = nets.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Net* net = _locator.getElement();\ Net* net = _locator.getElement();\
_locator.Progress(); _locator.progress();

2
hurricane/src/hurricane/Occurrence.h
View File

@ -63,7 +63,7 @@ class Occurrence {
// Predicates // Predicates
// ********** // **********
public: bool IsValid() const {return (_entity != NULL);}; public: bool isValid() const {return (_entity != NULL);};
public: bool HasProperty() const; public: bool HasProperty() const;
// Updators // Updators

4
hurricane/src/hurricane/Occurrences.h
View File

@ -46,9 +46,9 @@ typedef GenericFilter<Occurrence> OccurrenceFilter;
/************************************************/\ /************************************************/\
{\ {\
OccurrenceLocator _locator = occurrences.getLocator();\ OccurrenceLocator _locator = occurrences.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Occurrence occurrence = _locator.getElement();\ Occurrence occurrence = _locator.getElement();\
_locator.Progress(); _locator.progress();

4
hurricane/src/hurricane/Pads.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Pad*> PadFilter;
/******************************/\ /******************************/\
{\ {\
PadLocator _locator = pads.getLocator();\ PadLocator _locator = pads.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Pad* pad = _locator.getElement();\ Pad* pad = _locator.getElement();\
_locator.Progress(); _locator.progress();

4
hurricane/src/hurricane/Pathes.h
View File

@ -46,9 +46,9 @@ typedef GenericFilter<Path> PathFilter;
/**********************************/\ /**********************************/\
{\ {\
PathLocator _locator = pathes.getLocator();\ PathLocator _locator = pathes.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Path path = _locator.getElement();\ Path path = _locator.getElement();\
_locator.Progress(); _locator.progress();

4
hurricane/src/hurricane/Pins.h
View File

@ -51,9 +51,9 @@ typedef GenericFilter<Pin*> PinFilter;
/******************************/\ /******************************/\
{\ {\
PinLocator _locator = pins.getLocator();\ PinLocator _locator = pins.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Pin* pin = _locator.getElement();\ Pin* pin = _locator.getElement();\
_locator.Progress(); _locator.progress();

2
hurricane/src/hurricane/Plug.cpp
View File

@ -29,7 +29,7 @@ class Plug_IsConnectedFilter : public Filter<Plug*> {
public: virtual Filter<Plug*>* getClone() const {return new Plug_IsConnectedFilter(*this);}; public: virtual Filter<Plug*>* getClone() const {return new Plug_IsConnectedFilter(*this);};
public: virtual bool Accept(Plug* plug) const {return plug->IsConnected();}; public: virtual bool accept(Plug* plug) const {return plug->IsConnected();};
public: virtual string _getString() const {return "<" + _TName("Plug::IsConnectedFilter>");}; public: virtual string _getString() const {return "<" + _TName("Plug::IsConnectedFilter>");};

4
hurricane/src/hurricane/Plugs.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Plug*> PlugFilter;
/*********************************/\ /*********************************/\
{\ {\
PlugLocator _locator = plugs.getLocator();\ PlugLocator _locator = plugs.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Plug* plug = _locator.getElement();\ Plug* plug = _locator.getElement();\
_locator.Progress(); _locator.progress();

4
hurricane/src/hurricane/Points.h
View File

@ -46,9 +46,9 @@ typedef GenericFilter<Point> PointFilter;
/************************************/\ /************************************/\
{\ {\
PointLocator _locator = points.getLocator();\ PointLocator _locator = points.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Point point = _locator.getElement();\ Point point = _locator.getElement();\
_locator.Progress(); _locator.progress();

4
hurricane/src/hurricane/Primitives.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Primitive*> PrimitiveFilter;
/************************************************/\ /************************************************/\
{\ {\
PrimitiveLocator _locator = primitives.getLocator();\ PrimitiveLocator _locator = primitives.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Primitive* primitive = _locator.getElement();\ Primitive* primitive = _locator.getElement();\
_locator.Progress(); _locator.progress();

4
hurricane/src/hurricane/Properties.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Property*> PropertyFilter;
/**********************************************/\ /**********************************************/\
{\ {\
PropertyLocator _locator = properties.getLocator();\ PropertyLocator _locator = properties.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Property* property = _locator.getElement();\ Property* property = _locator.getElement();\
_locator.Progress(); _locator.progress();

36
hurricane/src/hurricane/QuadTree.cpp
View File

@ -50,9 +50,9 @@ class QuadTree_Gos : public Collection<Go*> {
public: virtual Go* getElement() const; public: virtual Go* getElement() const;
public: virtual Hurricane::Locator<Go*>* getClone() const; public: virtual Hurricane::Locator<Go*>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
@ -120,9 +120,9 @@ class QuadTree_GosUnder : public Collection<Go*> {
public: virtual Go* getElement() const; public: virtual Go* getElement() const;
public: virtual Hurricane::Locator<Go*>* getClone() const; public: virtual Hurricane::Locator<Go*>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
@ -627,18 +627,18 @@ Locator<Go*>* QuadTree_Gos::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool QuadTree_Gos::Locator::IsValid() const bool QuadTree_Gos::Locator::isValid() const
// **************************************** // ****************************************
{ {
return _goLocator.IsValid(); return _goLocator.isValid();
} }
void QuadTree_Gos::Locator::Progress() void QuadTree_Gos::Locator::progress()
// *********************************** // ***********************************
{ {
if (IsValid()) { if (isValid()) {
_goLocator.Progress(); _goLocator.progress();
if (!_goLocator.IsValid()) { if (!_goLocator.isValid()) {
_currentQuadTree = _currentQuadTree->_getNextQuadTree(); _currentQuadTree = _currentQuadTree->_getNextQuadTree();
if (_currentQuadTree) if (_currentQuadTree)
_goLocator = _currentQuadTree->_getGoSet().getElements().getLocator(); _goLocator = _currentQuadTree->_getGoSet().getElements().getLocator();
@ -745,7 +745,7 @@ QuadTree_GosUnder::Locator::Locator(const QuadTree* quadTree, const Box& area)
_currentQuadTree = _quadTree->_getFirstQuadTree(_area); _currentQuadTree = _quadTree->_getFirstQuadTree(_area);
if (_currentQuadTree) { if (_currentQuadTree) {
_goLocator = _currentQuadTree->_getGoSet().getElements().getLocator(); _goLocator = _currentQuadTree->_getGoSet().getElements().getLocator();
if (!getElement()->getBoundingBox().intersect(_area)) Progress(); if (!getElement()->getBoundingBox().intersect(_area)) progress();
} }
} }
} }
@ -782,24 +782,24 @@ Locator<Go*>* QuadTree_GosUnder::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool QuadTree_GosUnder::Locator::IsValid() const bool QuadTree_GosUnder::Locator::isValid() const
// ********************************************* // *********************************************
{ {
return _goLocator.IsValid(); return _goLocator.isValid();
} }
void QuadTree_GosUnder::Locator::Progress() void QuadTree_GosUnder::Locator::progress()
// **************************************** // ****************************************
{ {
if (IsValid()) { if (isValid()) {
do { do {
_goLocator.Progress(); _goLocator.progress();
if (!_goLocator.IsValid()) { if (!_goLocator.isValid()) {
_currentQuadTree = _currentQuadTree->_getNextQuadTree(_area); _currentQuadTree = _currentQuadTree->_getNextQuadTree(_area);
if (_currentQuadTree) if (_currentQuadTree)
_goLocator = _currentQuadTree->_getGoSet().getElements().getLocator(); _goLocator = _currentQuadTree->_getGoSet().getElements().getLocator();
} }
} while (IsValid() && !getElement()->getBoundingBox().intersect(_area)); } while (isValid() && !getElement()->getBoundingBox().intersect(_area));
} }
} }

2
hurricane/src/hurricane/Quark.cpp
View File

@ -33,7 +33,7 @@ Quark::Quark(const Occurrence& occurrence)
_occurrence(occurrence), _occurrence(occurrence),
_nextOfSharedPathQuarkMap(NULL) _nextOfSharedPathQuarkMap(NULL)
{ {
if (!_occurrence.IsValid()) if (!_occurrence.isValid())
throw Error("Can't create " + _TName("Quark") + " : invalid occurrence"); throw Error("Can't create " + _TName("Quark") + " : invalid occurrence");
if (_occurrence._getQuark()) if (_occurrence._getQuark())

4
hurricane/src/hurricane/Quarks.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Quark*> QuarkFilter;
/************************************/\ /************************************/\
{\ {\
QuarkLocator _locator = quarks.getLocator();\ QuarkLocator _locator = quarks.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Quark* quark = _locator.getElement();\ Quark* quark = _locator.getElement();\
_locator.Progress(); _locator.progress();

4
hurricane/src/hurricane/References.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Reference*> ReferenceFilter;
/***************************************/\ /***************************************/\
{\ {\
ReferenceLocator _locator = references.getLocator();\ ReferenceLocator _locator = references.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Reference* reference = _locator.getElement();\ Reference* reference = _locator.getElement();\
_locator.Progress(); _locator.progress();

66
hurricane/src/hurricane/Region.cpp
View File

@ -46,7 +46,7 @@ class Region_Tile {
public: virtual Filter<Region_Tile*>* getClone() const; public: virtual Filter<Region_Tile*>* getClone() const;
public: virtual bool Accept(Region_Tile* tile) const; public: virtual bool accept(Region_Tile* tile) const;
public: virtual string _getString() const; public: virtual string _getString() const;
@ -983,7 +983,7 @@ Filter<Region_Tile*>* Region_Tile::IsVoidFilter::getClone() const
return new Region_Tile::IsVoidFilter(*this); return new Region_Tile::IsVoidFilter(*this);
} }
bool Region_Tile::IsVoidFilter::Accept(Region_Tile* tile) const bool Region_Tile::IsVoidFilter::accept(Region_Tile* tile) const
// ************************************************************ // ************************************************************
{ {
return tile->IsVoid(); return tile->IsVoid();
@ -1025,9 +1025,9 @@ class Region_Tiles : public Collection<Region_Tile*> {
public: virtual Region_Tile* getElement() const; public: virtual Region_Tile* getElement() const;
public: virtual Hurricane::Locator<Region_Tile*>* getClone() const; public: virtual Hurricane::Locator<Region_Tile*>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
@ -1159,13 +1159,13 @@ Locator<Region_Tile*>* Region_Tiles::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool Region_Tiles::Locator::IsValid() const bool Region_Tiles::Locator::isValid() const
// *************************************** // ***************************************
{ {
return !_tileStack.empty(); return !_tileStack.empty();
} }
void Region_Tiles::Locator::Progress() void Region_Tiles::Locator::progress()
// ********************************** // **********************************
{ {
if (!_tileStack.empty()) { if (!_tileStack.empty()) {
@ -1224,9 +1224,9 @@ class Region_TilesUnder : public Collection<Region_Tile*> {
public: virtual Region_Tile* getElement() const; public: virtual Region_Tile* getElement() const;
public: virtual Hurricane::Locator<Region_Tile*>* getClone() const; public: virtual Hurricane::Locator<Region_Tile*>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
@ -1402,13 +1402,13 @@ Locator<Region_Tile*>* Region_TilesUnder::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool Region_TilesUnder::Locator::IsValid() const bool Region_TilesUnder::Locator::isValid() const
// ********************************************* // *********************************************
{ {
return !_tileStack.empty(); return !_tileStack.empty();
} }
void Region_TilesUnder::Locator::Progress() void Region_TilesUnder::Locator::progress()
// **************************************** // ****************************************
{ {
if (!_tileStack.empty()) { if (!_tileStack.empty()) {
@ -1476,9 +1476,9 @@ class Region_BoxesUnder : public Collection<Box> {
public: virtual Box getElement() const; public: virtual Box getElement() const;
public: virtual Hurricane::Locator<Box>* getClone() const; public: virtual Hurricane::Locator<Box>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
@ -1628,7 +1628,7 @@ Region_BoxesUnder::Locator& Region_BoxesUnder::Locator::operator=(const Locator&
Box Region_BoxesUnder::Locator::getElement() const Box Region_BoxesUnder::Locator::getElement() const
// *********************************************** // ***********************************************
{ {
return (_tileLocator.IsValid()) ? _tileLocator.getElement()->getBoundingBox() : Box(); return (_tileLocator.isValid()) ? _tileLocator.getElement()->getBoundingBox() : Box();
} }
Locator<Box>* Region_BoxesUnder::Locator::getClone() const Locator<Box>* Region_BoxesUnder::Locator::getClone() const
@ -1637,16 +1637,16 @@ Locator<Box>* Region_BoxesUnder::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool Region_BoxesUnder::Locator::IsValid() const bool Region_BoxesUnder::Locator::isValid() const
// ******************************************** // ********************************************
{ {
return _tileLocator.IsValid(); return _tileLocator.isValid();
} }
void Region_BoxesUnder::Locator::Progress() void Region_BoxesUnder::Locator::progress()
// **************************************** // ****************************************
{ {
_tileLocator.Progress(); _tileLocator.progress();
} }
string Region_BoxesUnder::Locator::_getString() const string Region_BoxesUnder::Locator::_getString() const
@ -1693,9 +1693,9 @@ class Region_VoidBoxesUnder : public Collection<Box> {
public: virtual Box getElement() const; public: virtual Box getElement() const;
public: virtual Hurricane::Locator<Box>* getClone() const; public: virtual Hurricane::Locator<Box>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
@ -1845,7 +1845,7 @@ Region_VoidBoxesUnder::Locator& Region_VoidBoxesUnder::Locator::operator=(const
Box Region_VoidBoxesUnder::Locator::getElement() const Box Region_VoidBoxesUnder::Locator::getElement() const
// *************************************************** // ***************************************************
{ {
return (_tileLocator.IsValid()) ? _tileLocator.getElement()->getBoundingBox() : Box(); return (_tileLocator.isValid()) ? _tileLocator.getElement()->getBoundingBox() : Box();
} }
Locator<Box>* Region_VoidBoxesUnder::Locator::getClone() const Locator<Box>* Region_VoidBoxesUnder::Locator::getClone() const
@ -1854,16 +1854,16 @@ Locator<Box>* Region_VoidBoxesUnder::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool Region_VoidBoxesUnder::Locator::IsValid() const bool Region_VoidBoxesUnder::Locator::isValid() const
// ************************************************* // *************************************************
{ {
return _tileLocator.IsValid(); return _tileLocator.isValid();
} }
void Region_VoidBoxesUnder::Locator::Progress() void Region_VoidBoxesUnder::Locator::progress()
// ******************************************** // ********************************************
{ {
_tileLocator.Progress(); _tileLocator.progress();
} }
string Region_VoidBoxesUnder::Locator::_getString() const string Region_VoidBoxesUnder::Locator::_getString() const
@ -1909,9 +1909,9 @@ class Region_Intervals : public Collection<Interval> {
public: virtual Interval getElement() const; public: virtual Interval getElement() const;
public: virtual Hurricane::Locator<Interval>* getClone() const; public: virtual Hurricane::Locator<Interval>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
@ -2068,7 +2068,7 @@ Region_Intervals::Locator& Region_Intervals::Locator::operator=(const Locator& l
Interval Region_Intervals::Locator::getElement() const Interval Region_Intervals::Locator::getElement() const
// *************************************************** // ***************************************************
{ {
if (!IsValid()) return Interval(); if (!isValid()) return Interval();
Interval interval; Interval interval;
switch (_swapLine->getType()) { switch (_swapLine->getType()) {
@ -2091,16 +2091,16 @@ Locator<Interval>* Region_Intervals::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool Region_Intervals::Locator::IsValid() const bool Region_Intervals::Locator::isValid() const
// ******************************************** // ********************************************
{ {
return (_lowerTile && _upperTile); return (_lowerTile && _upperTile);
} }
void Region_Intervals::Locator::Progress() void Region_Intervals::Locator::progress()
// *************************************** // ***************************************
{ {
if (IsValid()) { if (isValid()) {
switch (_swapLine->getType()) { switch (_swapLine->getType()) {
case Region::SwapLine::Type::VERTICAL : { case Region::SwapLine::Type::VERTICAL : {
Unit x = _swapLine->getPosition(); Unit x = _swapLine->getPosition();
@ -2298,10 +2298,10 @@ Intervals Region::SwapLine::getIntervals() const
return Region_Intervals(this); return Region_Intervals(this);
} }
void Region::SwapLine::Progress(int n) void Region::SwapLine::progress(int n)
// *************************** // ***************************
{ {
if (IsValid() && n) { if (isValid() && n) {
if (0 < n) { if (0 < n) {
switch (_type) { switch (_type) {
case Type::VERTICAL : { case Type::VERTICAL : {
@ -2396,7 +2396,7 @@ string Region::SwapLine::_getString() const
// **************************************** // ****************************************
{ {
string s = "<" + _getTypeName() + ">"; string s = "<" + _getTypeName() + ">";
if (IsValid()) { if (isValid()) {
s.insert(s.length() - 1, " " + getString(_type)); s.insert(s.length() - 1, " " + getString(_type));
s.insert(s.length() - 1, " " + getString(_position)); s.insert(s.length() - 1, " " + getString(_position));
s.insert(s.length() - 1, " " + getString(_extention)); s.insert(s.length() - 1, " " + getString(_extention));

4
hurricane/src/hurricane/Region.h
View File

@ -93,12 +93,12 @@ class Region {
// Predicates // Predicates
// ********** // **********
public: bool IsValid() const {return _baseTile;}; public: bool isValid() const {return _baseTile;};
// Updators // Updators
// ******** // ********
public: void Progress(int n = 1); public: void progress(int n = 1);
public: void Translate(const Unit& quantity); public: void Translate(const Unit& quantity);
public: void SetPosition(const Unit& position); public: void SetPosition(const Unit& position);

2
hurricane/src/hurricane/Relation.cpp
View File

@ -48,7 +48,7 @@ class Relation_OwnerIsSlave : public Filter<DBo*> {
return new Relation_OwnerIsSlave(*this); return new Relation_OwnerIsSlave(*this);
}; };
public: virtual bool Accept(DBo* owner) const public: virtual bool accept(DBo* owner) const
// ****************************************** // ******************************************
{ {
return (owner != _relation->getMasterOwner()); return (owner != _relation->getMasterOwner());

49
hurricane/src/hurricane/RoutingPad.cpp
View File

@ -42,7 +42,7 @@ RoutingPad* RoutingPad::create(Net* net, Occurrence occurrence)
{ {
if (!net) if (!net)
throw Error ("Can't create RoutingPad : NULL net"); throw Error ("Can't create RoutingPad : NULL net");
if (!occurrence.IsValid()) if (!occurrence.isValid())
throw Error ("Can't create RoutingPag : Invalid occurrence"); throw Error ("Can't create RoutingPag : Invalid occurrence");
//TODO Gerer une contruction avec un composant externe, mais ce n'est pas prioritaire //TODO Gerer une contruction avec un composant externe, mais ce n'est pas prioritaire
@ -258,7 +258,7 @@ Record* RoutingPad::_getRecord() const
Component* RoutingPad::_getEntityAsComponent () const Component* RoutingPad::_getEntityAsComponent () const
// *************************************************** // ***************************************************
{ {
if ( _occurrence.IsValid() ) if ( _occurrence.isValid() )
return dynamic_cast<Component*>( _occurrence.getEntity() ); return dynamic_cast<Component*>( _occurrence.getEntity() );
return NULL; return NULL;
@ -267,55 +267,12 @@ Component* RoutingPad::_getEntityAsComponent () const
Segment* RoutingPad::_getEntityAsSegment () const Segment* RoutingPad::_getEntityAsSegment () const
// *********************************************** // ***********************************************
{ {
if ( _occurrence.IsValid() ) if ( _occurrence.isValid() )
return dynamic_cast<Segment*>( _occurrence.getEntity() ); return dynamic_cast<Segment*>( _occurrence.getEntity() );
return NULL; return NULL;
} }
//bool RoutingPad::_IsInterceptedBy(View* view, const Point& point, const Unit& aperture) const
//// ******************************************************************************************
//{
// Layer* layer = getLayer();
// Box boundingBox ( getBoundingBox() );
// Box area ( point );
//
// area.Inflate ( aperture );
//
// for_each_basic_layer(basicLayer, layer->getBasicLayers()) {
// if (view->IsVisible(basicLayer))
// if (boundingBox.Intersect(area)) return true;
// end_for;
// }
//
// return false;
//}
//
//
//void RoutingPad::_Draw(View* view, BasicLayer* basicLayer, const Box& updateArea, const Transformation& transformation)
//// ****************************************************************************************************
//{
// Box boundingBox ( getBoundingBox() );
// BasicLayer* layer = getLayer()->_getSymbolicBasicLayer();
//
// if ( basicLayer == layer ) {
// if ( 1 < view->getScreenSize(boundingBox.getWidth()) ) {
// view->DrawRectangle ( boundingBox );
// }
// else
// view->DrawLine ( getSourcePosition(), getTargetPosition() );
// }
//}
//
//
//void RoutingPad::_Highlight(View* view, const Box& updateArea, const Transformation& transformation)
//// **********************************************************************************************
//{
// BasicLayer* layer = getLayer()->_getSymbolicBasicLayer();
// _Draw ( view, layer, updateArea, transformation );
//}
void RoutingPad::SetExternalComponent(Component* component) void RoutingPad::SetExternalComponent(Component* component)
// ******************************************************** // ********************************************************
{ {

4
hurricane/src/hurricane/RoutingPads.h
View File

@ -51,9 +51,9 @@ typedef GenericFilter<RoutingPad*> RoutingPadFilter;
/*********************************/\ /*********************************/\
{\ {\
RoutingPadLocator _locator = routingpads.getLocator();\ RoutingPadLocator _locator = routingpads.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
RoutingPad* routingpad = _locator.getElement();\ RoutingPad* routingpad = _locator.getElement();\
_locator.Progress(); _locator.progress();

4
hurricane/src/hurricane/Rubbers.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Rubber*> RubberFilter;
/***************************************/\ /***************************************/\
{\ {\
RubberLocator _locator = rubbers.getLocator();\ RubberLocator _locator = rubbers.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Rubber* rubber = _locator.getElement();\ Rubber* rubber = _locator.getElement();\
_locator.Progress(); _locator.progress();

16
hurricane/src/hurricane/Segment.cpp
View File

@ -42,9 +42,9 @@ class Segment_Hooks : public Collection<Hook*> {
public: virtual Hook* getElement() const; public: virtual Hook* getElement() const;
public: virtual Hurricane::Locator<Hook*>* getClone() const; public: virtual Hurricane::Locator<Hook*>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
@ -109,9 +109,9 @@ class Segment_Anchors : public Collection<Component*> {
public: virtual Component* getElement() const; public: virtual Component* getElement() const;
public: virtual Hurricane::Locator<Component*>* getClone() const; public: virtual Hurricane::Locator<Component*>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
@ -519,13 +519,13 @@ Locator<Hook*>* Segment_Hooks::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool Segment_Hooks::Locator::IsValid() const bool Segment_Hooks::Locator::isValid() const
// ***************************************** // *****************************************
{ {
return (_hook != NULL); return (_hook != NULL);
} }
void Segment_Hooks::Locator::Progress() void Segment_Hooks::Locator::progress()
// ************************************ // ************************************
{ {
if (_hook) { if (_hook) {
@ -643,13 +643,13 @@ Locator<Component*>* Segment_Anchors::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool Segment_Anchors::Locator::IsValid() const bool Segment_Anchors::Locator::isValid() const
// ******************************************* // *******************************************
{ {
return (_anchor != NULL); return (_anchor != NULL);
} }
void Segment_Anchors::Locator::Progress() void Segment_Anchors::Locator::progress()
// ************************************** // **************************************
{ {
if (_anchor) { if (_anchor) {

4
hurricane/src/hurricane/Segments.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Segment*> SegmentFilter;
/******************************************/\ /******************************************/\
{\ {\
SegmentLocator _locator = segments.getLocator();\ SegmentLocator _locator = segments.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Segment* segment = _locator.getElement();\ Segment* segment = _locator.getElement();\
_locator.Progress(); _locator.progress();

4
hurricane/src/hurricane/Selectors.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Selector*> SelectorFilter;
/*********************************************/\ /*********************************************/\
{\ {\
SelectorLocator _locator = selectors.getLocator();\ SelectorLocator _locator = selectors.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Selector* selector = _locator.getElement();\ Selector* selector = _locator.getElement();\
_locator.Progress(); _locator.progress();

6
hurricane/src/hurricane/SetCollection.h
View File

@ -53,7 +53,7 @@ template<class Element, class Compare = less<Element> >
public: virtual Element getElement() const public: virtual Element getElement() const
// *************************************** // ***************************************
{ {
return (IsValid()) ? *_iterator : Element(); return (isValid()) ? *_iterator : Element();
}; };
public: virtual Hurricane::Locator<Element>* getClone() const public: virtual Hurricane::Locator<Element>* getClone() const
@ -62,13 +62,13 @@ template<class Element, class Compare = less<Element> >
return new Locator(_elementSet); return new Locator(_elementSet);
}; };
public: virtual bool IsValid() const public: virtual bool isValid() const
// ********************************* // *********************************
{ {
return (_elementSet && (_iterator != _elementSet->end())); return (_elementSet && (_iterator != _elementSet->end()));
}; };
public: virtual void Progress() public: virtual void progress()
// **************************** // ****************************
{ {
++_iterator; ++_iterator;

8
hurricane/src/hurricane/SharedPath.cpp
View File

@ -40,9 +40,9 @@ class SharedPath_Instances : public Collection<Instance*> {
public: virtual Instance* getElement() const; public: virtual Instance* getElement() const;
public: virtual Hurricane::Locator<Instance*>* getClone() const; public: virtual Hurricane::Locator<Instance*>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
}; };
@ -341,13 +341,13 @@ Locator<Instance*>* SharedPath_Instances::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool SharedPath_Instances::Locator::IsValid() const bool SharedPath_Instances::Locator::isValid() const
// ************************************************ // ************************************************
{ {
return (_sharedPath != NULL); return (_sharedPath != NULL);
} }
void SharedPath_Instances::Locator::Progress() void SharedPath_Instances::Locator::progress()
// ******************************************* // *******************************************
{ {
if (_sharedPath) _sharedPath = _sharedPath->getTailSharedPath(); if (_sharedPath) _sharedPath = _sharedPath->getTailSharedPath();

4
hurricane/src/hurricane/SharedPathes.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<SharedPath*> SharedPathFilter;
/*****************************************************/\ /*****************************************************/\
{\ {\
SharedPathLocator _locator = sharedPathes.getLocator();\ SharedPathLocator _locator = sharedPathes.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
SharedPath* sharedPath = _locator.getElement();\ SharedPath* sharedPath = _locator.getElement();\
_locator.Progress(); _locator.progress();

4
hurricane/src/hurricane/Slices.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Slice*> SliceFilter;
/************************************/\ /************************************/\
{\ {\
SliceLocator _locator = slices.getLocator();\ SliceLocator _locator = slices.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Slice* slice = _locator.getElement();\ Slice* slice = _locator.getElement();\
_locator.Progress(); _locator.progress();

4
hurricane/src/hurricane/Symbols.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Symbol*> SymbolFilter;
/***************************************/\ /***************************************/\
{\ {\
SymbolLocator _locator = symbols.getLocator();\ SymbolLocator _locator = symbols.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Symbol* symbol = _locator.getElement();\ Symbol* symbol = _locator.getElement();\
_locator.Progress(); _locator.progress();

18
hurricane/src/hurricane/Technology.cpp
View File

@ -47,9 +47,9 @@ class Technology_BasicLayers : public Collection<BasicLayer*> {
public: virtual BasicLayer* getElement() const; public: virtual BasicLayer* getElement() const;
public: virtual Hurricane::Locator<BasicLayer*>* getClone() const; public: virtual Hurricane::Locator<BasicLayer*>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
@ -321,8 +321,8 @@ Technology_BasicLayers::Locator::Locator(const Technology* technology, const Lay
{ {
if (_technology) { if (_technology) {
_basicLayerLocator = _technology->getBasicLayers().getLocator(); _basicLayerLocator = _technology->getBasicLayers().getLocator();
while (_basicLayerLocator.IsValid() && !(_basicLayerLocator.getElement()->getMask() & _mask)) while (_basicLayerLocator.isValid() && !(_basicLayerLocator.getElement()->getMask() & _mask))
_basicLayerLocator.Progress(); _basicLayerLocator.progress();
} }
} }
@ -356,19 +356,19 @@ Locator<BasicLayer*>* Technology_BasicLayers::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool Technology_BasicLayers::Locator::IsValid() const bool Technology_BasicLayers::Locator::isValid() const
// ************************************************** // **************************************************
{ {
return _basicLayerLocator.IsValid(); return _basicLayerLocator.isValid();
} }
void Technology_BasicLayers::Locator::Progress() void Technology_BasicLayers::Locator::progress()
// ********************************************* // *********************************************
{ {
do { do {
_basicLayerLocator.Progress(); _basicLayerLocator.progress();
} }
while (_basicLayerLocator.IsValid() && !(_basicLayerLocator.getElement()->getMask() & _mask)); while (_basicLayerLocator.isValid() && !(_basicLayerLocator.getElement()->getMask() & _mask));
} }
string Technology_BasicLayers::Locator::_getString() const string Technology_BasicLayers::Locator::_getString() const

22
hurricane/src/hurricane/UserGo.cpp
View File

@ -44,9 +44,9 @@ class UserGo_CellUserGos : public Collection<UserGo*> {
public: virtual UserGo* getElement() const; public: virtual UserGo* getElement() const;
public: virtual Hurricane::Locator<UserGo*>* getClone() const; public: virtual Hurricane::Locator<UserGo*>* getClone() const;
public: virtual bool IsValid() const; public: virtual bool isValid() const;
public: virtual void Progress(); public: virtual void progress();
public: virtual string _getString() const; public: virtual string _getString() const;
@ -220,7 +220,7 @@ UserGo_CellUserGos::Locator::Locator(const Cell* cell)
{ {
if (_cell) { if (_cell) {
_displaySlotLocator = getDisplaySlots(cell).getLocator(); _displaySlotLocator = getDisplaySlots(cell).getLocator();
if (_displaySlotLocator.IsValid()) if (_displaySlotLocator.isValid())
{ {
DisplaySlot* displaySlot = _displaySlotLocator.getElement(); DisplaySlot* displaySlot = _displaySlotLocator.getElement();
_userGoLocator = displaySlot->getUserGos().getLocator(); _userGoLocator = displaySlot->getUserGos().getLocator();
@ -258,21 +258,21 @@ Locator<UserGo*>* UserGo_CellUserGos::Locator::getClone() const
return new Locator(*this); return new Locator(*this);
} }
bool UserGo_CellUserGos::Locator::IsValid() const bool UserGo_CellUserGos::Locator::isValid() const
// *************************************** // ***************************************
{ {
return _userGoLocator.IsValid(); return _userGoLocator.isValid();
} }
void UserGo_CellUserGos::Locator::Progress() void UserGo_CellUserGos::Locator::progress()
// ***************************************** // *****************************************
{ {
if (_userGoLocator.IsValid()) { if (_userGoLocator.isValid()) {
_userGoLocator.Progress(); _userGoLocator.progress();
} }
else if (_displaySlotLocator.IsValid()) { else if (_displaySlotLocator.isValid()) {
_displaySlotLocator.Progress(); _displaySlotLocator.progress();
if (_displaySlotLocator.IsValid()) if (_displaySlotLocator.isValid())
{ {
DisplaySlot* displaySlot = _displaySlotLocator.getElement(); DisplaySlot* displaySlot = _displaySlotLocator.getElement();
_userGoLocator = displaySlot->getUserGos().getLocator(); _userGoLocator = displaySlot->getUserGos().getLocator();

4
hurricane/src/hurricane/UserGos.h
View File

@ -51,9 +51,9 @@ typedef GenericFilter<UserGo*> UserGoFilter;
/***************************************/\ /***************************************/\
{\ {\
UserGoLocator _locator = userGos.getLocator();\ UserGoLocator _locator = userGos.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
UserGo* userGo = _locator.getElement();\ UserGo* userGo = _locator.getElement();\
_locator.Progress(); _locator.progress();
} // End of Hurricane namespace. } // End of Hurricane namespace.

6
hurricane/src/hurricane/VectorCollection.h
View File

@ -47,7 +47,7 @@ template<class Element> class VectorCollection : public Collection<Element> {
public: virtual Element getElement() const public: virtual Element getElement() const
// *************************************** // ***************************************
{ {
return (IsValid()) ? *_iterator : Element(); return (isValid()) ? *_iterator : Element();
}; };
public: virtual Hurricane::Locator<Element>* getClone() const public: virtual Hurricane::Locator<Element>* getClone() const
@ -56,13 +56,13 @@ template<class Element> class VectorCollection : public Collection<Element> {
return new Locator(_elementVector); return new Locator(_elementVector);
}; };
public: virtual bool IsValid() const public: virtual bool isValid() const
// ********************************* // *********************************
{ {
return (_elementVector && (_iterator != _elementVector->end())); return (_elementVector && (_iterator != _elementVector->end()));
}; };
public: virtual void Progress() public: virtual void progress()
// **************************** // ****************************
{ {
++_iterator; ++_iterator;

4
hurricane/src/hurricane/Verticals.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<Vertical*> VerticalFilter;
/*********************************************/\ /*********************************************/\
{\ {\
VerticalLocator _locator = verticals.getLocator();\ VerticalLocator _locator = verticals.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
Vertical* vertical = _locator.getElement();\ Vertical* vertical = _locator.getElement();\
_locator.Progress(); _locator.progress();

4
hurricane/src/hurricane/Views.h
View File

@ -47,9 +47,9 @@ typedef GenericFilter<View*> ViewFilter;
/*********************************/\ /*********************************/\
{\ {\
ViewLocator _locator = views.getLocator();\ ViewLocator _locator = views.getLocator();\
while (_locator.IsValid()) {\ while (_locator.isValid()) {\
View* view = _locator.getElement();\ View* view = _locator.getElement();\
_locator.Progress(); _locator.progress();

6
hurricane/src/pyext/PyCellLocator.cpp
View File

@ -83,7 +83,7 @@ extern "C" {
// Standart Predicates (Attributes). // Standart Predicates (Attributes).
DirectGetBoolAttribute(PyCellLocator_IsValid,IsValid,PyCellLocator,Locator<Cell*>) DirectGetBoolAttribute(PyCellLocator_isValid,isValid,PyCellLocator,Locator<Cell*>)
// Standart Locator Accessors (Attributes). // Standart Locator Accessors (Attributes).
@ -101,8 +101,8 @@ extern "C" {
// PyCellLocator Attribute Method table. // PyCellLocator Attribute Method table.
PyMethodDef PyCellLocator_Methods[] = PyMethodDef PyCellLocator_Methods[] =
{ { "IsValid" , (PyCFunction)PyCellLocator_IsValid , METH_NOARGS , "Returns true while the walk has not exhausted the set of elements, else false." } { { "isValid" , (PyCFunction)PyCellLocator_isValid , METH_NOARGS , "Returns true while the walk has not exhausted the set of elements, else false." }
, { "Progress" , (PyCFunction)PyCellLocator_Progress , METH_NOARGS , "Moves forward the locator to the following element." } , { "progress" , (PyCFunction)PyCellLocator_progress , METH_NOARGS , "Moves forward the locator to the following element." }
, { "getElement" , (PyCFunction)PyCellLocator_getElement , METH_NOARGS , "Returns the current element (or the value Type() when the locator is not or no longer valid)." } , { "getElement" , (PyCFunction)PyCellLocator_getElement , METH_NOARGS , "Returns the current element (or the value Type() when the locator is not or no longer valid)." }
, { "getClone" , (PyCFunction)PyCellLocator_getClone , METH_NOARGS , "This function allocates and returns a new locator that will have the same visiting course than the remaining one of the locator being cloned." } , { "getClone" , (PyCFunction)PyCellLocator_getClone , METH_NOARGS , "This function allocates and returns a new locator that will have the same visiting course than the remaining one of the locator being cloned." }
, { "destroy" , (PyCFunction)PyCellLocator_destroy , METH_NOARGS , { "destroy" , (PyCFunction)PyCellLocator_destroy , METH_NOARGS

8
hurricane/src/pyext/PyComponentLocator.cpp
View File

@ -81,7 +81,7 @@ extern "C" {
// Standart Accessors (Attributes). // Standart Accessors (Attributes).
// Standart Predicates (Attributes). // Standart Predicates (Attributes).
DirectGetBoolAttribute(PyComponentLocator_IsValid,IsValid,PyComponentLocator,Locator<Component*>) DirectGetBoolAttribute(PyComponentLocator_isValid,isValid,PyComponentLocator,Locator<Component*>)
// Standart Locator Accessors (Attributes). // Standart Locator Accessors (Attributes).
@ -99,8 +99,8 @@ extern "C" {
// PyComponent Attribute Method table. // PyComponent Attribute Method table.
PyMethodDef PyComponentLocator_Methods[] = PyMethodDef PyComponentLocator_Methods[] =
{ { "IsValid" , (PyCFunction)PyComponentLocator_IsValid , METH_NOARGS , "Returns true while the walk has not exhausted the set of elements, else false." } { { "isValid" , (PyCFunction)PyComponentLocator_isValid , METH_NOARGS , "Returns true while the walk has not exhausted the set of elements, else false." }
, { "Progress" , (PyCFunction)PyComponentLocator_Progress , METH_NOARGS , "Moves forward the locator to the following element." } , { "progress" , (PyCFunction)PyComponentLocator_progress , METH_NOARGS , "Moves forward the locator to the following element." }
, { "getElement" , (PyCFunction)PyComponentLocator_getElement , METH_NOARGS , "Returns the current element (or the value Type() when the locator is not or no longer valid)." } , { "getElement" , (PyCFunction)PyComponentLocator_getElement , METH_NOARGS , "Returns the current element (or the value Type() when the locator is not or no longer valid)." }
, { "getClone" , (PyCFunction)PyComponentLocator_getClone , METH_NOARGS , "This function allocates and returns a new locator that will have the same visiting course than the remaining one of the locator being cloned." } , { "getClone" , (PyCFunction)PyComponentLocator_getClone , METH_NOARGS , "This function allocates and returns a new locator that will have the same visiting course than the remaining one of the locator being cloned." }
, { "destroy" , (PyCFunction)PyComponentLocator_destroy , METH_NOARGS , { "destroy" , (PyCFunction)PyComponentLocator_destroy , METH_NOARGS
@ -117,7 +117,7 @@ extern "C" {
LocatorPyTypeObjectLinkPyType(Component, Component*) LocatorPyTypeObjectLinkPyType(Component, Component*)
# else // End of Python Module Code Part. #else // End of Python Module Code Part.
// x=================================================================x // x=================================================================x

8
hurricane/src/pyext/PyHurricane.h
View File

@ -390,13 +390,13 @@ extern "C" {
// Locator Attribute Method For Progress. // Locator Attribute Method For Progress.
# define LocatorProgressAttribute(SELF_TYPE) \ # define LocatorProgressAttribute(SELF_TYPE) \
static PyObject* Py##SELF_TYPE##Locator_Progress ( Py##SELF_TYPE##Locator *self ) \ static PyObject* Py##SELF_TYPE##Locator_progress ( Py##SELF_TYPE##Locator *self ) \
{ \ { \
trace << #SELF_TYPE "Locator.Progress()" << endl; \ trace << #SELF_TYPE "Locator.progress()" << endl; \
METHOD_HEAD ( #SELF_TYPE "Locator.Progress()" ) \ METHOD_HEAD ( #SELF_TYPE "Locator.progress()" ) \
\ \
HTRY \ HTRY \
locator->Progress (); \ locator->progress (); \
HCATCH \ HCATCH \
\ \
Py_RETURN_NONE; \ Py_RETURN_NONE; \

4
hurricane/src/pyext/PyHyperNet.cpp
View File

@ -87,7 +87,7 @@ extern "C" {
// Standart Predicates (Attributes). // Standart Predicates (Attributes).
DirectGetBoolAttribute(PyHyperNet_IsValid ,IsValid ,PyHyperNet,HyperNet) DirectGetBoolAttribute(PyHyperNet_isValid ,isValid ,PyHyperNet,HyperNet)
// Standart Delete (Attribute). // Standart Delete (Attribute).
@ -150,7 +150,7 @@ extern "C" {
PyMethodDef PyHyperNet_Methods[] = PyMethodDef PyHyperNet_Methods[] =
{ { "getCell" , (PyCFunction)PyHyperNet_getCell , METH_NOARGS , "Returns the hyperNet cell." } { { "getCell" , (PyCFunction)PyHyperNet_getCell , METH_NOARGS , "Returns the hyperNet cell." }
, { "IsValid" , (PyCFunction)PyHyperNet_IsValid , METH_NOARGS , "Returns trus if the HyperNet isValid." } , { "isValid" , (PyCFunction)PyHyperNet_isValid , METH_NOARGS , "Returns trus if the HyperNet isValid." }
, { "getLeafPlugOccurrenceLocator", (PyCFunction)PyHyperNet_getLeafPlugOccurrenceLocator, METH_NOARGS , { "getLeafPlugOccurrenceLocator", (PyCFunction)PyHyperNet_getLeafPlugOccurrenceLocator, METH_NOARGS
, "Returns the collection of leaf occurrences" } , "Returns the collection of leaf occurrences" }
, { "destroy" , (PyCFunction)PyHyperNet_destroy , METH_NOARGS , { "destroy" , (PyCFunction)PyHyperNet_destroy , METH_NOARGS

6
hurricane/src/pyext/PyInstanceLocator.cpp
View File

@ -84,7 +84,7 @@ extern "C" {
// Standart Predicates (Attributes). // Standart Predicates (Attributes).
DirectGetBoolAttribute(PyInstanceLocator_IsValid,IsValid,PyInstanceLocator,Locator<Instance*>) DirectGetBoolAttribute(PyInstanceLocator_isValid,isValid,PyInstanceLocator,Locator<Instance*>)
// Standart Locator Accessors (Attributes). // Standart Locator Accessors (Attributes).
@ -103,8 +103,8 @@ extern "C" {
// PyInstanceLocator Attribute Method table. // PyInstanceLocator Attribute Method table.
PyMethodDef PyInstanceLocator_Methods[] = PyMethodDef PyInstanceLocator_Methods[] =
{ { "IsValid" , (PyCFunction)PyInstanceLocator_IsValid , METH_NOARGS , "Returns true while the walk has not exhausted the set of elements, else false." } { { "isValid" , (PyCFunction)PyInstanceLocator_isValid , METH_NOARGS , "Returns true while the walk has not exhausted the set of elements, else false." }
, { "Progress" , (PyCFunction)PyInstanceLocator_Progress , METH_NOARGS , "Moves forward the locator to the following element." } , { "progress" , (PyCFunction)PyInstanceLocator_progress , METH_NOARGS , "Moves forward the locator to the following element." }
, { "getElement" , (PyCFunction)PyInstanceLocator_getElement , METH_NOARGS , "Returns the current element (or the value Type() when the locator is not or no longer valid)." } , { "getElement" , (PyCFunction)PyInstanceLocator_getElement , METH_NOARGS , "Returns the current element (or the value Type() when the locator is not or no longer valid)." }
, { "getClone" , (PyCFunction)PyInstanceLocator_getClone , METH_NOARGS , "This function allocates and returns a new locator that will have the same visiting course than the remaining one of the locator being cloned." } , { "getClone" , (PyCFunction)PyInstanceLocator_getClone , METH_NOARGS , "This function allocates and returns a new locator that will have the same visiting course than the remaining one of the locator being cloned." }
, { "destroy" , (PyCFunction)PyInstanceLocator_destroy , METH_NOARGS , { "destroy" , (PyCFunction)PyInstanceLocator_destroy , METH_NOARGS

6
hurricane/src/pyext/PyNetLocator.cpp
View File

@ -79,7 +79,7 @@ extern "C" {
// Standart Predicates (Attributes). // Standart Predicates (Attributes).
DirectGetBoolAttribute(PyNetLocator_IsValid,IsValid,PyNetLocator,Locator<Net*>) DirectGetBoolAttribute(PyNetLocator_isValid,isValid,PyNetLocator,Locator<Net*>)
// Standart Locator Accessors (Attributes). // Standart Locator Accessors (Attributes).
@ -97,8 +97,8 @@ extern "C" {
// PyNetLocator Attribute Method table. // PyNetLocator Attribute Method table.
PyMethodDef PyNetLocator_Methods[] = PyMethodDef PyNetLocator_Methods[] =
{ { "IsValid" , (PyCFunction)PyNetLocator_IsValid , METH_NOARGS , "Returns true while the walk has not exhausted the set of elements, else false." } { { "isValid" , (PyCFunction)PyNetLocator_isValid , METH_NOARGS , "Returns true while the walk has not exhausted the set of elements, else false." }
, { "Progress" , (PyCFunction)PyNetLocator_Progress , METH_NOARGS , "Moves forward the locator to the following element." } , { "progress" , (PyCFunction)PyNetLocator_progress , METH_NOARGS , "Moves forward the locator to the following element." }
, { "getElement" , (PyCFunction)PyNetLocator_getElement , METH_NOARGS , "Returns the current element (or the value Type() when the locator is not or no longer valid)." } , { "getElement" , (PyCFunction)PyNetLocator_getElement , METH_NOARGS , "Returns the current element (or the value Type() when the locator is not or no longer valid)." }
, { "getClone" , (PyCFunction)PyNetLocator_getClone , METH_NOARGS , "This function allocates and returns a new locator that will have the same visiting course than the remaining one of the locator being cloned." } , { "getClone" , (PyCFunction)PyNetLocator_getClone , METH_NOARGS , "This function allocates and returns a new locator that will have the same visiting course than the remaining one of the locator being cloned." }
, { "destroy" , (PyCFunction)PyNetLocator_destroy , METH_NOARGS , { "destroy" , (PyCFunction)PyNetLocator_destroy , METH_NOARGS

4
hurricane/src/pyext/PyOccurrence.cpp
View File

@ -86,7 +86,7 @@ extern "C" {
// Standart Predicates (Attributes). // Standart Predicates (Attributes).
DirectGetBoolAttribute(PyOccurrence_IsValid ,IsValid ,PyOccurrence,Occurrence) DirectGetBoolAttribute(PyOccurrence_isValid ,isValid ,PyOccurrence,Occurrence)
DirectGetBoolAttribute(PyOccurrence_HasProperty,HasProperty,PyOccurrence,Occurrence) DirectGetBoolAttribute(PyOccurrence_HasProperty,HasProperty,PyOccurrence,Occurrence)
@ -227,7 +227,7 @@ extern "C" {
, { "getOwnerCell" , (PyCFunction)PyOccurrence_getOwnerCell , METH_NOARGS, "Returns the occurrence owner cell." } , { "getOwnerCell" , (PyCFunction)PyOccurrence_getOwnerCell , METH_NOARGS, "Returns the occurrence owner cell." }
, { "getMasterCell" , (PyCFunction)PyOccurrence_getMasterCell , METH_NOARGS, "Returns the cell owning the referenced entity." } , { "getMasterCell" , (PyCFunction)PyOccurrence_getMasterCell , METH_NOARGS, "Returns the cell owning the referenced entity." }
, { "getBoundingBox", (PyCFunction)PyOccurrence_getBoundingBox, METH_NOARGS, "Returns the occurrence bounding box." } , { "getBoundingBox", (PyCFunction)PyOccurrence_getBoundingBox, METH_NOARGS, "Returns the occurrence bounding box." }
, { "IsValid" , (PyCFunction)PyOccurrence_IsValid , METH_NOARGS, "Returns true if the occurrence is valid." } , { "isValid" , (PyCFunction)PyOccurrence_isValid , METH_NOARGS, "Returns true if the occurrence is valid." }
, { "HasProperty" , (PyCFunction)PyOccurrence_HasProperty , METH_NOARGS, "Returns true if the occurrence owns some properties." } , { "HasProperty" , (PyCFunction)PyOccurrence_HasProperty , METH_NOARGS, "Returns true if the occurrence owns some properties." }
, { "destroy" , (PyCFunction)PyOccurrence_destroy , METH_NOARGS , { "destroy" , (PyCFunction)PyOccurrence_destroy , METH_NOARGS
, "Destroy associated hurricane object, the python object remains." } , "Destroy associated hurricane object, the python object remains." }

18
hurricane/src/pyext/PyOccurrenceLocator.cpp
View File

@ -79,22 +79,22 @@ extern "C" {
// Standart Predicates (Attributes). // Standart Predicates (Attributes).
DirectGetBoolAttribute(PyOccurrenceLocator_IsValid,IsValid,PyOccurrenceLocator,Locator<Occurrence>) DirectGetBoolAttribute(PyOccurrenceLocator_isValid,isValid,PyOccurrenceLocator,Locator<Occurrence>)
// Standart destroy (Attribute). // Standart destroy (Attribute).
DirectDestroyAttribute(PyOccurrenceLocator_destroy, PyOccurrenceLocator) DirectDestroyAttribute(PyOccurrenceLocator_destroy, PyOccurrenceLocator)
// --------------------------------------------------------------- // ---------------------------------------------------------------
// Attribute Method : "PyOccurrenceLocator_Progress ()" // Attribute Method : "PyOccurrenceLocator_progress ()"
static PyObject* PyOccurrenceLocator_Progress ( PyOccurrenceLocator *self ) { static PyObject* PyOccurrenceLocator_progress ( PyOccurrenceLocator *self ) {
trace << "OccurrenceLocator.Progress()" << endl; trace << "OccurrenceLocator.progress()" << endl;
HTRY HTRY
METHOD_HEAD ( "OccurrenceLocator.Progress()" ) METHOD_HEAD ( "OccurrenceLocator.progress()" )
locator->Progress (); locator->progress ();
HCATCH HCATCH
Py_RETURN_NONE; Py_RETURN_NONE;
@ -150,8 +150,8 @@ extern "C" {
// PyOccurrenceLocator Attribute Method table. // PyOccurrenceLocator Attribute Method table.
PyMethodDef PyOccurrenceLocator_Methods[] = PyMethodDef PyOccurrenceLocator_Methods[] =
{ { "IsValid" , (PyCFunction)PyOccurrenceLocator_IsValid , METH_NOARGS , "Returns true while the walk has not exhausted the set of elements, else false." } { { "isValid" , (PyCFunction)PyOccurrenceLocator_isValid , METH_NOARGS , "Returns true while the walk has not exhausted the set of elements, else false." }
, { "Progress" , (PyCFunction)PyOccurrenceLocator_Progress , METH_NOARGS , "Moves forward the locator to the following element." } , { "progress" , (PyCFunction)PyOccurrenceLocator_progress , METH_NOARGS , "Moves forward the locator to the following element." }
, { "getElement" , (PyCFunction)PyOccurrenceLocator_getElement , METH_NOARGS , "Returns the current element (or the value Type() when the locator is not or no longer valid)." } , { "getElement" , (PyCFunction)PyOccurrenceLocator_getElement , METH_NOARGS , "Returns the current element (or the value Type() when the locator is not or no longer valid)." }
, { "getClone" , (PyCFunction)PyOccurrenceLocator_getClone , METH_NOARGS , "This function allocates and returns a new locator that will have the same visiting course than the remaining one of the locator being cloned." } , { "getClone" , (PyCFunction)PyOccurrenceLocator_getClone , METH_NOARGS , "This function allocates and returns a new locator that will have the same visiting course than the remaining one of the locator being cloned." }
, { "destroy" , (PyCFunction)PyOccurrenceLocator_destroy , METH_NOARGS , { "destroy" , (PyCFunction)PyOccurrenceLocator_destroy , METH_NOARGS
@ -168,7 +168,7 @@ extern "C" {
LocatorPyTypeObjectLinkPyType(Occurrence, Occurrence) LocatorPyTypeObjectLinkPyType(Occurrence, Occurrence)
# else // End of Python Module Code Part. #else // End of Python Module Code Part.
// x=================================================================x // x=================================================================x

6
hurricane/src/pyext/PyPinLocator.cpp
View File

@ -85,7 +85,7 @@ extern "C" {
// Standart Predicates (Attributes). // Standart Predicates (Attributes).
DirectGetBoolAttribute(PyPinLocator_IsValid,IsValid,PyPinLocator,Locator<Pin*>) DirectGetBoolAttribute(PyPinLocator_isValid,isValid,PyPinLocator,Locator<Pin*>)
// Standart Locator Accessors (Attributes). // Standart Locator Accessors (Attributes).
@ -104,8 +104,8 @@ extern "C" {
// PyPinLocator Attribute Method table. // PyPinLocator Attribute Method table.
PyMethodDef PyPinLocator_Methods[] = PyMethodDef PyPinLocator_Methods[] =
{ { "IsValid" , (PyCFunction)PyPinLocator_IsValid , METH_NOARGS , "Returns true while the walk has not exhausted the set of elements, else false." } { { "isValid" , (PyCFunction)PyPinLocator_isValid , METH_NOARGS , "Returns true while the walk has not exhausted the set of elements, else false." }
, { "Progress" , (PyCFunction)PyPinLocator_Progress , METH_NOARGS , "Moves forward the locator to the following element." } , { "progress" , (PyCFunction)PyPinLocator_progress , METH_NOARGS , "Moves forward the locator to the following element." }
, { "getElement" , (PyCFunction)PyPinLocator_getElement , METH_NOARGS , "Returns the current element (or the value Type() when the locator is not or no longer valid)." } , { "getElement" , (PyCFunction)PyPinLocator_getElement , METH_NOARGS , "Returns the current element (or the value Type() when the locator is not or no longer valid)." }
, { "getClone" , (PyCFunction)PyPinLocator_getClone , METH_NOARGS , "This function allocates and returns a new locator that will have the same visiting course than the remaining one of the locator being cloned." } , { "getClone" , (PyCFunction)PyPinLocator_getClone , METH_NOARGS , "This function allocates and returns a new locator that will have the same visiting course than the remaining one of the locator being cloned." }
, { "destroy" , (PyCFunction)PyPinLocator_destroy , METH_NOARGS , { "destroy" , (PyCFunction)PyPinLocator_destroy , METH_NOARGS

6
hurricane/src/pyext/PyPlugLocator.cpp
View File

@ -86,7 +86,7 @@ extern "C" {
// Standart Predicates (Attributes). // Standart Predicates (Attributes).
DirectGetBoolAttribute(PyPlugLocator_IsValid,IsValid,PyPlugLocator,Locator<Plug*>) DirectGetBoolAttribute(PyPlugLocator_isValid,isValid,PyPlugLocator,Locator<Plug*>)
// Standart Locator Accessors (Attributes). // Standart Locator Accessors (Attributes).
@ -101,8 +101,8 @@ extern "C" {
// PyPlugLocator Attribute Method table. // PyPlugLocator Attribute Method table.
PyMethodDef PyPlugLocator_Methods[] = PyMethodDef PyPlugLocator_Methods[] =
{ { "IsValid" , (PyCFunction)PyPlugLocator_IsValid , METH_NOARGS , "Returns true while the walk has not exhausted the set of elements, else false." } { { "isValid" , (PyCFunction)PyPlugLocator_isValid , METH_NOARGS , "Returns true while the walk has not exhausted the set of elements, else false." }
, { "Progress" , (PyCFunction)PyPlugLocator_Progress , METH_NOARGS , "Moves forward the locator to the following element." } , { "progress" , (PyCFunction)PyPlugLocator_progress , METH_NOARGS , "Moves forward the locator to the following element." }
, { "getElement" , (PyCFunction)PyPlugLocator_getElement , METH_NOARGS , "Returns the current element (or the value Type() when the locator is not or no longer valid)." } , { "getElement" , (PyCFunction)PyPlugLocator_getElement , METH_NOARGS , "Returns the current element (or the value Type() when the locator is not or no longer valid)." }
, { "getClone" , (PyCFunction)PyPlugLocator_getClone , METH_NOARGS , "This function allocates and returns a new locator that will have the same visiting course than the remaining one of the locator being cloned." } , { "getClone" , (PyCFunction)PyPlugLocator_getClone , METH_NOARGS , "This function allocates and returns a new locator that will have the same visiting course than the remaining one of the locator being cloned." }
, {NULL, NULL, 0, NULL} /* sentinel */ , {NULL, NULL, 0, NULL} /* sentinel */

8
hurricane/src/pyext/PyReferenceLocator.cpp
View File

@ -82,7 +82,7 @@ extern "C" {
// Standart Predicates (Attributes). // Standart Predicates (Attributes).
DirectGetBoolAttribute(PyReferenceLocator_IsValid,IsValid,PyReferenceLocator,Locator<Reference*>) DirectGetBoolAttribute(PyReferenceLocator_isValid,isValid,PyReferenceLocator,Locator<Reference*>)
// Standart Locator Accessors (Attributes). // Standart Locator Accessors (Attributes).
@ -101,8 +101,8 @@ extern "C" {
// PyReferenceLocator Attribute Method table. // PyReferenceLocator Attribute Method table.
PyMethodDef PyReferenceLocator_Methods[] = PyMethodDef PyReferenceLocator_Methods[] =
{ { "IsValid" , (PyCFunction)PyReferenceLocator_IsValid , METH_NOARGS , "Returns true while the walk has not exhausted the set of elements, else false." } { { "isValid" , (PyCFunction)PyReferenceLocator_isValid , METH_NOARGS , "Returns true while the walk has not exhausted the set of elements, else false." }
, { "Progress" , (PyCFunction)PyReferenceLocator_Progress , METH_NOARGS , "Moves forward the locator to the following element." } , { "progress" , (PyCFunction)PyReferenceLocator_progress , METH_NOARGS , "Moves forward the locator to the following element." }
, { "getElement" , (PyCFunction)PyReferenceLocator_getElement , METH_NOARGS , "Returns the current element (or the value Type() when the locator is not or no longer valid)." } , { "getElement" , (PyCFunction)PyReferenceLocator_getElement , METH_NOARGS , "Returns the current element (or the value Type() when the locator is not or no longer valid)." }
, { "getClone" , (PyCFunction)PyReferenceLocator_getClone , METH_NOARGS , "This function allocates and returns a new locator that will have the same visiting course than the remaining one of the locator being cloned." } , { "getClone" , (PyCFunction)PyReferenceLocator_getClone , METH_NOARGS , "This function allocates and returns a new locator that will have the same visiting course than the remaining one of the locator being cloned." }
, { "destroy" , (PyCFunction)PyReferenceLocator_destroy , METH_NOARGS , { "destroy" , (PyCFunction)PyReferenceLocator_destroy , METH_NOARGS
@ -120,7 +120,7 @@ extern "C" {
LocatorPyTypeObjectLinkPyType(Reference, Reference*) LocatorPyTypeObjectLinkPyType(Reference, Reference*)
# else // End of Python Module Code Part. #else // End of Python Module Code Part.
// x=================================================================x // x=================================================================x

6
hurricane/src/pyext/PySegmentLocator.cpp
View File

@ -84,7 +84,7 @@ extern "C" {
// Standart Predicates (Attributes). // Standart Predicates (Attributes).
DirectGetBoolAttribute(PySegmentLocator_IsValid,IsValid,PySegmentLocator,Locator<Segment*>) DirectGetBoolAttribute(PySegmentLocator_isValid,isValid,PySegmentLocator,Locator<Segment*>)
// Standart Locator Accessors (Attributes). // Standart Locator Accessors (Attributes).
@ -103,8 +103,8 @@ extern "C" {
// PySegmentLocator Attribute Method table. // PySegmentLocator Attribute Method table.
PyMethodDef PySegmentLocator_Methods[] = PyMethodDef PySegmentLocator_Methods[] =
{ { "IsValid" , (PyCFunction)PySegmentLocator_IsValid , METH_NOARGS , "Returns true while the walk has not exhausted the set of elements, else false." } { { "isValid" , (PyCFunction)PySegmentLocator_isValid , METH_NOARGS , "Returns true while the walk has not exhausted the set of elements, else false." }
, { "Progress" , (PyCFunction)PySegmentLocator_Progress , METH_NOARGS , "Moves forward the locator to the following element." } , { "progress" , (PyCFunction)PySegmentLocator_progress , METH_NOARGS , "Moves forward the locator to the following element." }
, { "getElement" , (PyCFunction)PySegmentLocator_getElement , METH_NOARGS , "Returns the current element (or the value Type() when the locator is not or no longer valid)." } , { "getElement" , (PyCFunction)PySegmentLocator_getElement , METH_NOARGS , "Returns the current element (or the value Type() when the locator is not or no longer valid)." }
, { "getClone" , (PyCFunction)PySegmentLocator_getClone , METH_NOARGS , "This function allocates and returns a new locator that will have the same visiting course than the remaining one of the locator being cloned." } , { "getClone" , (PyCFunction)PySegmentLocator_getClone , METH_NOARGS , "This function allocates and returns a new locator that will have the same visiting course than the remaining one of the locator being cloned." }
, { "destroy" , (PyCFunction)PySegmentLocator_destroy , METH_NOARGS , { "destroy" , (PyCFunction)PySegmentLocator_destroy , METH_NOARGS