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 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;
@ -288,13 +288,13 @@ Locator<BasicLayer*>* BasicLayer_BasicLayers::Locator::getClone() const
return new Locator(*this);
}
bool BasicLayer_BasicLayers::Locator::IsValid() const
bool BasicLayer_BasicLayers::Locator::isValid() const
// **************************************************
{
return (_basicLayer != NULL);
}
void BasicLayer_BasicLayers::Locator::Progress()
void BasicLayer_BasicLayers::Locator::progress()
// *********************************************
{
_basicLayer = NULL;

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

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

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

@ -26,21 +26,21 @@
# ifndef __HURRICANE_COMMONS__
# define __HURRICANE_COMMONS__
#ifndef __HURRICANE_COMMONS__
#define __HURRICANE_COMMONS__
# include <stdio.h>
# include <assert.h>
#include <stdio.h>
#include <assert.h>
# include <string>
# include <list>
# include <set>
# include <map>
# include <stack>
# include <vector>
# include <iostream>
# include <fstream>
#include <string>
#include <list>
#include <set>
#include <map>
#include <stack>
#include <vector>
#include <iostream>
#include <fstream>
@ -50,13 +50,13 @@
// x-----------------------------------------------------------------x
# define Hurricane H
# define BEGIN_NAMESPACE_HURRICANE namespace Hurricane {
# define END_NAMESPACE_HURRICANE }
# define USING_NAMESPACE_HURRICANE using namespace std; using namespace Hurricane;
#define Hurricane H
#define BEGIN_NAMESPACE_HURRICANE namespace Hurricane {
#define END_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;
@ -91,8 +91,8 @@ namespace Hurricane {
void ltracein ( unsigned int level, unsigned int count=1 );
void ltraceout ( unsigned int level, unsigned int count=1 );
# define trace if (in_trace() ) cerr << tab
# define ltrace(level) if (inltrace(level)) cerr << tab
#define trace if (in_trace() ) cerr << tab
#define ltrace(level) if (inltrace(level)) cerr << tab
@ -136,7 +136,7 @@ using namespace std;
// 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
// 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);
};
public: virtual bool Accept(Component* component) const
public: virtual bool accept(Component* component) const
// ****************************************************
{
return _area.intersect(component->getBoundingBox());
@ -94,9 +94,9 @@ class Component_Hooks : public Collection<Hook*> {
public: virtual Hook* getElement() 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;
@ -162,9 +162,9 @@ class Component_ConnexComponents : public Collection<Component*> {
public: virtual Component* getElement() 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;
@ -230,9 +230,9 @@ class Component_SlaveComponents : public Collection<Component*> {
public: virtual Component* getElement() 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;
@ -626,13 +626,13 @@ Locator<Hook*>* Component_Hooks::Locator::getClone() const
return new Locator(*this);
}
bool Component_Hooks::Locator::IsValid() const
bool Component_Hooks::Locator::isValid() const
// *******************************************
{
return (_hook != NULL);
}
void Component_Hooks::Locator::Progress()
void Component_Hooks::Locator::progress()
// **************************************
{
_hook = NULL;
@ -745,13 +745,13 @@ Locator<Component*>* Component_ConnexComponents::Locator::getClone() const
return new Locator(*this);
}
bool Component_ConnexComponents::Locator::IsValid() const
bool Component_ConnexComponents::Locator::isValid() const
// ******************************************************
{
return !_componentStack.empty();
}
void Component_ConnexComponents::Locator::Progress()
void Component_ConnexComponents::Locator::progress()
// *************************************************
{
if (!_componentStack.empty()) {
@ -895,13 +895,13 @@ Locator<Component*>* Component_SlaveComponents::Locator::getClone() const
return new Locator(*this);
}
bool Component_SlaveComponents::Locator::IsValid() const
bool Component_SlaveComponents::Locator::isValid() const
// *****************************************************
{
return !_componentStack.empty();
}
void Component_SlaveComponents::Locator::Progress()
void Component_SlaveComponents::Locator::progress()
// ************************************************
{
if (!_componentStack.empty()) {

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

@ -47,9 +47,9 @@ typedef GenericFilter<Component*> ComponentFilter;
/************************************************/\
{\
ComponentLocator _locator = components.getLocator();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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 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;
@ -489,13 +489,13 @@ Locator<Hook*>* Contact_Hooks::Locator::getClone() const
return new Locator(*this);
}
bool Contact_Hooks::Locator::IsValid() const
bool Contact_Hooks::Locator::isValid() const
// *****************************************
{
return (_hook != NULL);
}
void Contact_Hooks::Locator::Progress()
void Contact_Hooks::Locator::progress()
// ************************************
{
if (_hook) {

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

@ -47,9 +47,9 @@ typedef GenericFilter<Contact*> ContactFilter;
/******************************************/\
{\
ContactLocator _locator = contacts.getLocator();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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 )
{
if ( !hyperNet.IsValid() )
if ( !hyperNet.isValid() )
throw Error ( "Can't create " + _TName("DeepNet") + ": occurence is invalid." );
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();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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
// **********
public: virtual bool Accept(Type type) const = 0;
public: virtual bool accept(Type type) const = 0;
// Others
// ******
@ -166,10 +166,10 @@ template<class Type> class GenericFilter : public Filter<Type> {
// 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
@ -257,10 +257,10 @@ template<class Type> class NotFilter : public Filter<Type> {
// Predicates
// **********
public: virtual bool Accept(Type type) const
public: virtual bool accept(Type type) const
// *****************************************
{
return !_genericFilter.Accept(type);
return !_genericFilter.accept(type);
};
// Others

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

@ -47,9 +47,9 @@ typedef GenericFilter<Go*> GoFilter;
/***************************/\
{\
GoLocator _locator = gos.getLocator();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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 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>");};
@ -64,9 +64,9 @@ class Hook_Hooks : public Collection<Hook*> {
public: virtual Hook* getElement() 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;
@ -131,9 +131,9 @@ class Hook_SlaveHooks : public Collection<Hook*> {
public: virtual Hook* getElement() 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;
@ -462,13 +462,13 @@ Locator<Hook*>* Hook_Hooks::Locator::getClone() const
return new Locator(*this);
}
bool Hook_Hooks::Locator::IsValid() const
bool Hook_Hooks::Locator::isValid() const
// **************************************
{
return (_currentHook != NULL);
}
void Hook_Hooks::Locator::Progress()
void Hook_Hooks::Locator::progress()
// *********************************
{
if (_currentHook) {
@ -584,13 +584,13 @@ Locator<Hook*>* Hook_SlaveHooks::Locator::getClone() const
return new Locator(*this);
}
bool Hook_SlaveHooks::Locator::IsValid() const
bool Hook_SlaveHooks::Locator::isValid() const
// *******************************************
{
return (_currentHook != NULL);
}
void Hook_SlaveHooks::Locator::Progress()
void Hook_SlaveHooks::Locator::progress()
// **************************************
{
if (_currentHook) {

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

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

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

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

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

@ -50,7 +50,7 @@ class Instance_IsUnderFilter : public Filter<Instance*> {
return new Instance_IsUnderFilter(*this);
};
public: virtual bool Accept(Instance* instance) const
public: virtual bool accept(Instance* instance) const
// **************************************************
{
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 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") + ">";};
@ -92,7 +92,7 @@ class Instance_IsLeafFilter : public Filter<Instance*> {
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") + ">";};
@ -109,7 +109,7 @@ class Instance_IsUnplacedFilter : public Filter<Instance*> {
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>");};
@ -126,7 +126,7 @@ class Instance_IsPlacedFilter : public Filter<Instance*> {
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>");};
@ -143,7 +143,7 @@ class Instance_IsFixedFilter : public Filter<Instance*> {
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>");};

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

@ -47,9 +47,9 @@ typedef GenericFilter<Instance*> InstanceFilter;
/*********************************************/\
{\
InstanceLocator _locator = instances.getLocator();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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
// **********
public: virtual bool IsValid() const
public: virtual bool isValid() const
// *********************************
{
return (_element != NULL);
@ -115,7 +115,7 @@ template<class Key, class Element> class IntrusiveMap {
// Updators
// ********
public: virtual void Progress()
public: virtual void progress()
// ****************************
{
if (_element) {

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

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

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

@ -47,9 +47,9 @@ typedef GenericFilter<Layer*> LayerFilter;
/************************************/\
{\
LayerLocator _locator = layers.getLocator();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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
// ***************************************
{
return (IsValid()) ? *_iterator : Element();
return (isValid()) ? *_iterator : Element();
};
public: virtual Hurricane::Locator<Element>* getClone() const
@ -56,13 +56,13 @@ template<class Element> class ListCollection : public Collection<Element> {
return new Locator(_elementList);
};
public: virtual bool IsValid() const
public: virtual bool isValid() const
// *********************************
{
return (_elementList && (_iterator != _elementList->end()));
};
public: virtual void Progress()
public: virtual void progress()
// ****************************
{
++_iterator;

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

@ -65,12 +65,12 @@ template<class Type> class Locator : public NestedSlotAdapter {
// Predicates
// **********
public: virtual bool IsValid() const = 0;
public: virtual bool isValid() const = 0;
// Updators
// ********
public: virtual void Progress() = 0;
public: virtual void progress() = 0;
// Others
// ******
@ -84,7 +84,7 @@ template<class Type> class Locator : public NestedSlotAdapter {
public: virtual string _getString() const
// **************************************
{
if (!IsValid())
if (!isValid())
return "<" + _getTypeName() + " invalid>";
else
return "<" + _getTypeName() + " " + getString(getElement()) + ">";
@ -207,19 +207,19 @@ template<class Type> class GenericLocator : public Locator<Type> {
// Predicates
// **********
public: virtual bool IsValid() const
public: virtual bool isValid() const
// *********************************
{
return (_locator && _locator->IsValid());
return (_locator && _locator->isValid());
};
// Updators
// ********
public: virtual void Progress()
public: virtual void progress()
// ****************************
{
if (_locator) _locator->Progress();
if (_locator) _locator->progress();
};
// 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
// ***************************************
{
return (IsValid()) ? (*_iterator).second : Element();
return (isValid()) ? (*_iterator).second : Element();
};
public: virtual Hurricane::Locator<Element>* GetClone() const
@ -57,13 +57,13 @@ template<class Key, class Element, class Compare = less<Key> >
return new Locator(_elementMap);
};
public: virtual bool IsValid() const
public: virtual bool isValid() const
// *********************************
{
return (_elementMap && (_iterator != _elementMap->end()));
};
public: virtual void Progress()
public: virtual void progress()
// ****************************
{
++_iterator;

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

@ -47,9 +47,9 @@ typedef GenericFilter<Marker*> MarkerFilter;
/***************************************/\
{\
MarkerLocator _locator = markers.getLocator();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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
// ***************************************
{
return (IsValid()) ? *_iterator : Element();
return (isValid()) ? *_iterator : Element();
};
public: virtual Hurricane::Locator<Element>* getClone() const
@ -62,13 +62,13 @@ template<class Element, class Compare = less<Element> >
return new Locator(_elementMultiset);
};
public: virtual bool IsValid() const
public: virtual bool isValid() const
// *********************************
{
return (_elementMultiset && (_iterator != _elementMultiset->end()));
};
public: virtual void Progress()
public: virtual void progress()
// ****************************
{
++_iterator;

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

@ -46,9 +46,9 @@ typedef GenericFilter<Name*> NameFilter;
/****************************************************/\
{\
NameLocator _locator = names.getLocator();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
Name* name = _locator.getElement();\
_locator.Progress();
_locator.progress();
} // 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 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>");};
@ -54,7 +54,7 @@ class Net_IsDeepNetFilter : public Filter<Net*> {
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>");};
@ -71,7 +71,7 @@ class Net_IsGlobalFilter : public Filter<Net*> {
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>");};
@ -88,7 +88,7 @@ class Net_IsExternalFilter : public Filter<Net*> {
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>");};
@ -105,7 +105,7 @@ class Net_IsClockFilter : public Filter<Net*> {
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>");};
@ -122,7 +122,7 @@ class Net_IsSupplyFilter : public Filter<Net*> {
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>");};
@ -139,7 +139,7 @@ class Net_IsPowerFilter : public Filter<Net*> {
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>");};
@ -156,7 +156,7 @@ class Net_IsGroundFilter : public Filter<Net*> {
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>");};
@ -193,9 +193,9 @@ class Net_SlavePlugs : public Collection<Plug*> {
public: virtual Plug* getElement() 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;
@ -858,9 +858,9 @@ Net_SlavePlugs::Locator::Locator(const Net* net)
{
if (_net) {
_instanceLocator = _net->getCell()->getSlaveInstances().getLocator();
while (!_plug && _instanceLocator.IsValid()) {
while (!_plug && _instanceLocator.isValid()) {
_plug = _instanceLocator.getElement()->getPlug(_net);
_instanceLocator.Progress();
_instanceLocator.progress();
}
}
}
@ -895,20 +895,20 @@ Locator<Plug*>* Net_SlavePlugs::Locator::getClone() const
return new Locator(*this);
}
bool Net_SlavePlugs::Locator::IsValid() const
bool Net_SlavePlugs::Locator::isValid() const
// ******************************************
{
return (_plug != NULL);
}
void Net_SlavePlugs::Locator::Progress()
void Net_SlavePlugs::Locator::progress()
// *************************************
{
if (IsValid()) {
if (isValid()) {
_plug = NULL;
while (!_plug && _instanceLocator.IsValid()) {
while (!_plug && _instanceLocator.isValid()) {
_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();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
Net* net = _locator.getElement();\
_locator.Progress();
_locator.progress();

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

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

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

@ -46,9 +46,9 @@ typedef GenericFilter<Occurrence> OccurrenceFilter;
/************************************************/\
{\
OccurrenceLocator _locator = occurrences.getLocator();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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 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>");};

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

@ -47,9 +47,9 @@ typedef GenericFilter<Plug*> PlugFilter;
/*********************************/\
{\
PlugLocator _locator = plugs.getLocator();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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 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;
@ -120,9 +120,9 @@ class QuadTree_GosUnder : public Collection<Go*> {
public: virtual Go* getElement() 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;
@ -627,18 +627,18 @@ Locator<Go*>* QuadTree_Gos::Locator::getClone() const
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()) {
_goLocator.Progress();
if (!_goLocator.IsValid()) {
if (isValid()) {
_goLocator.progress();
if (!_goLocator.isValid()) {
_currentQuadTree = _currentQuadTree->_getNextQuadTree();
if (_currentQuadTree)
_goLocator = _currentQuadTree->_getGoSet().getElements().getLocator();
@ -745,7 +745,7 @@ QuadTree_GosUnder::Locator::Locator(const QuadTree* quadTree, const Box& area)
_currentQuadTree = _quadTree->_getFirstQuadTree(_area);
if (_currentQuadTree) {
_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);
}
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 {
_goLocator.Progress();
if (!_goLocator.IsValid()) {
_goLocator.progress();
if (!_goLocator.isValid()) {
_currentQuadTree = _currentQuadTree->_getNextQuadTree(_area);
if (_currentQuadTree)
_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),
_nextOfSharedPathQuarkMap(NULL)
{
if (!_occurrence.IsValid())
if (!_occurrence.isValid())
throw Error("Can't create " + _TName("Quark") + " : invalid occurrence");
if (_occurrence._getQuark())

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

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

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

@ -93,12 +93,12 @@ class Region {
// Predicates
// **********
public: bool IsValid() const {return _baseTile;};
public: bool isValid() const {return _baseTile;};
// Updators
// ********
public: void Progress(int n = 1);
public: void progress(int n = 1);
public: void Translate(const Unit& quantity);
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);
};
public: virtual bool Accept(DBo* owner) const
public: virtual bool accept(DBo* owner) const
// ******************************************
{
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)
throw Error ("Can't create RoutingPad : NULL net");
if (!occurrence.IsValid())
if (!occurrence.isValid())
throw Error ("Can't create RoutingPag : Invalid occurrence");
//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
// ***************************************************
{
if ( _occurrence.IsValid() )
if ( _occurrence.isValid() )
return dynamic_cast<Component*>( _occurrence.getEntity() );
return NULL;
@ -267,55 +267,12 @@ Component* RoutingPad::_getEntityAsComponent () const
Segment* RoutingPad::_getEntityAsSegment () const
// ***********************************************
{
if ( _occurrence.IsValid() )
if ( _occurrence.isValid() )
return dynamic_cast<Segment*>( _occurrence.getEntity() );
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)
// ********************************************************
{

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

@ -51,9 +51,9 @@ typedef GenericFilter<RoutingPad*> RoutingPadFilter;
/*********************************/\
{\
RoutingPadLocator _locator = routingpads.getLocator();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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 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;
@ -109,9 +109,9 @@ class Segment_Anchors : public Collection<Component*> {
public: virtual Component* getElement() 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;
@ -519,13 +519,13 @@ Locator<Hook*>* Segment_Hooks::Locator::getClone() const
return new Locator(*this);
}
bool Segment_Hooks::Locator::IsValid() const
bool Segment_Hooks::Locator::isValid() const
// *****************************************
{
return (_hook != NULL);
}
void Segment_Hooks::Locator::Progress()
void Segment_Hooks::Locator::progress()
// ************************************
{
if (_hook) {
@ -643,13 +643,13 @@ Locator<Component*>* Segment_Anchors::Locator::getClone() const
return new Locator(*this);
}
bool Segment_Anchors::Locator::IsValid() const
bool Segment_Anchors::Locator::isValid() const
// *******************************************
{
return (_anchor != NULL);
}
void Segment_Anchors::Locator::Progress()
void Segment_Anchors::Locator::progress()
// **************************************
{
if (_anchor) {

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

@ -47,9 +47,9 @@ typedef GenericFilter<Segment*> SegmentFilter;
/******************************************/\
{\
SegmentLocator _locator = segments.getLocator();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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
// ***************************************
{
return (IsValid()) ? *_iterator : Element();
return (isValid()) ? *_iterator : Element();
};
public: virtual Hurricane::Locator<Element>* getClone() const
@ -62,13 +62,13 @@ template<class Element, class Compare = less<Element> >
return new Locator(_elementSet);
};
public: virtual bool IsValid() const
public: virtual bool isValid() const
// *********************************
{
return (_elementSet && (_iterator != _elementSet->end()));
};
public: virtual void Progress()
public: virtual void progress()
// ****************************
{
++_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 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;
};
@ -341,13 +341,13 @@ Locator<Instance*>* SharedPath_Instances::Locator::getClone() const
return new Locator(*this);
}
bool SharedPath_Instances::Locator::IsValid() const
bool SharedPath_Instances::Locator::isValid() const
// ************************************************
{
return (_sharedPath != NULL);
}
void SharedPath_Instances::Locator::Progress()
void SharedPath_Instances::Locator::progress()
// *******************************************
{
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();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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 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;
@ -321,8 +321,8 @@ Technology_BasicLayers::Locator::Locator(const Technology* technology, const Lay
{
if (_technology) {
_basicLayerLocator = _technology->getBasicLayers().getLocator();
while (_basicLayerLocator.IsValid() && !(_basicLayerLocator.getElement()->getMask() & _mask))
_basicLayerLocator.Progress();
while (_basicLayerLocator.isValid() && !(_basicLayerLocator.getElement()->getMask() & _mask))
_basicLayerLocator.progress();
}
}
@ -356,19 +356,19 @@ Locator<BasicLayer*>* Technology_BasicLayers::Locator::getClone() const
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 {
_basicLayerLocator.Progress();
_basicLayerLocator.progress();
}
while (_basicLayerLocator.IsValid() && !(_basicLayerLocator.getElement()->getMask() & _mask));
while (_basicLayerLocator.isValid() && !(_basicLayerLocator.getElement()->getMask() & _mask));
}
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 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;
@ -220,7 +220,7 @@ UserGo_CellUserGos::Locator::Locator(const Cell* cell)
{
if (_cell) {
_displaySlotLocator = getDisplaySlots(cell).getLocator();
if (_displaySlotLocator.IsValid())
if (_displaySlotLocator.isValid())
{
DisplaySlot* displaySlot = _displaySlotLocator.getElement();
_userGoLocator = displaySlot->getUserGos().getLocator();
@ -258,21 +258,21 @@ Locator<UserGo*>* UserGo_CellUserGos::Locator::getClone() const
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()) {
_userGoLocator.Progress();
if (_userGoLocator.isValid()) {
_userGoLocator.progress();
}
else if (_displaySlotLocator.IsValid()) {
_displaySlotLocator.Progress();
if (_displaySlotLocator.IsValid())
else if (_displaySlotLocator.isValid()) {
_displaySlotLocator.progress();
if (_displaySlotLocator.isValid())
{
DisplaySlot* displaySlot = _displaySlotLocator.getElement();
_userGoLocator = displaySlot->getUserGos().getLocator();

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

@ -51,9 +51,9 @@ typedef GenericFilter<UserGo*> UserGoFilter;
/***************************************/\
{\
UserGoLocator _locator = userGos.getLocator();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
UserGo* userGo = _locator.getElement();\
_locator.Progress();
_locator.progress();
} // 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
// ***************************************
{
return (IsValid()) ? *_iterator : Element();
return (isValid()) ? *_iterator : Element();
};
public: virtual Hurricane::Locator<Element>* getClone() const
@ -56,13 +56,13 @@ template<class Element> class VectorCollection : public Collection<Element> {
return new Locator(_elementVector);
};
public: virtual bool IsValid() const
public: virtual bool isValid() const
// *********************************
{
return (_elementVector && (_iterator != _elementVector->end()));
};
public: virtual void Progress()
public: virtual void progress()
// ****************************
{
++_iterator;

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

@ -47,9 +47,9 @@ typedef GenericFilter<Vertical*> VerticalFilter;
/*********************************************/\
{\
VerticalLocator _locator = verticals.getLocator();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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();\
while (_locator.IsValid()) {\
while (_locator.isValid()) {\
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).
DirectGetBoolAttribute(PyCellLocator_IsValid,IsValid,PyCellLocator,Locator<Cell*>)
DirectGetBoolAttribute(PyCellLocator_isValid,isValid,PyCellLocator,Locator<Cell*>)
// Standart Locator Accessors (Attributes).
@ -101,8 +101,8 @@ extern "C" {
// PyCellLocator Attribute Method table.
PyMethodDef PyCellLocator_Methods[] =
{ { "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." }
{ { "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." }
, { "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." }
, { "destroy" , (PyCFunction)PyCellLocator_destroy , METH_NOARGS

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

@ -81,7 +81,7 @@ extern "C" {
// Standart Accessors (Attributes).
// Standart Predicates (Attributes).
DirectGetBoolAttribute(PyComponentLocator_IsValid,IsValid,PyComponentLocator,Locator<Component*>)
DirectGetBoolAttribute(PyComponentLocator_isValid,isValid,PyComponentLocator,Locator<Component*>)
// Standart Locator Accessors (Attributes).
@ -99,8 +99,8 @@ extern "C" {
// PyComponent Attribute Method table.
PyMethodDef PyComponentLocator_Methods[] =
{ { "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." }
{ { "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." }
, { "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." }
, { "destroy" , (PyCFunction)PyComponentLocator_destroy , METH_NOARGS
@ -117,7 +117,7 @@ extern "C" {
LocatorPyTypeObjectLinkPyType(Component, Component*)
# else // End of Python Module Code Part.
#else // End of Python Module Code Part.
// x=================================================================x

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

@ -390,13 +390,13 @@ extern "C" {
// Locator Attribute Method For Progress.
# 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; \
METHOD_HEAD ( #SELF_TYPE "Locator.Progress()" ) \
trace << #SELF_TYPE "Locator.progress()" << endl; \
METHOD_HEAD ( #SELF_TYPE "Locator.progress()" ) \
\
HTRY \
locator->Progress (); \
locator->progress (); \
HCATCH \
\
Py_RETURN_NONE; \

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

@ -87,7 +87,7 @@ extern "C" {
// Standart Predicates (Attributes).
DirectGetBoolAttribute(PyHyperNet_IsValid ,IsValid ,PyHyperNet,HyperNet)
DirectGetBoolAttribute(PyHyperNet_isValid ,isValid ,PyHyperNet,HyperNet)
// Standart Delete (Attribute).
@ -150,7 +150,7 @@ extern "C" {
PyMethodDef PyHyperNet_Methods[] =
{ { "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
, "Returns the collection of leaf occurrences" }
, { "destroy" , (PyCFunction)PyHyperNet_destroy , METH_NOARGS

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

@ -84,7 +84,7 @@ extern "C" {
// Standart Predicates (Attributes).
DirectGetBoolAttribute(PyInstanceLocator_IsValid,IsValid,PyInstanceLocator,Locator<Instance*>)
DirectGetBoolAttribute(PyInstanceLocator_isValid,isValid,PyInstanceLocator,Locator<Instance*>)
// Standart Locator Accessors (Attributes).
@ -103,8 +103,8 @@ extern "C" {
// PyInstanceLocator Attribute Method table.
PyMethodDef PyInstanceLocator_Methods[] =
{ { "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." }
{ { "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." }
, { "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." }
, { "destroy" , (PyCFunction)PyInstanceLocator_destroy , METH_NOARGS

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

@ -79,7 +79,7 @@ extern "C" {
// Standart Predicates (Attributes).
DirectGetBoolAttribute(PyNetLocator_IsValid,IsValid,PyNetLocator,Locator<Net*>)
DirectGetBoolAttribute(PyNetLocator_isValid,isValid,PyNetLocator,Locator<Net*>)
// Standart Locator Accessors (Attributes).
@ -97,8 +97,8 @@ extern "C" {
// PyNetLocator Attribute Method table.
PyMethodDef PyNetLocator_Methods[] =
{ { "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." }
{ { "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." }
, { "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." }
, { "destroy" , (PyCFunction)PyNetLocator_destroy , METH_NOARGS

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

@ -86,7 +86,7 @@ extern "C" {
// Standart Predicates (Attributes).
DirectGetBoolAttribute(PyOccurrence_IsValid ,IsValid ,PyOccurrence,Occurrence)
DirectGetBoolAttribute(PyOccurrence_isValid ,isValid ,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." }
, { "getMasterCell" , (PyCFunction)PyOccurrence_getMasterCell , METH_NOARGS, "Returns the cell owning the referenced entity." }
, { "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." }
, { "destroy" , (PyCFunction)PyOccurrence_destroy , METH_NOARGS
, "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).
DirectGetBoolAttribute(PyOccurrenceLocator_IsValid,IsValid,PyOccurrenceLocator,Locator<Occurrence>)
DirectGetBoolAttribute(PyOccurrenceLocator_isValid,isValid,PyOccurrenceLocator,Locator<Occurrence>)
// Standart destroy (Attribute).
DirectDestroyAttribute(PyOccurrenceLocator_destroy, PyOccurrenceLocator)
// ---------------------------------------------------------------
// Attribute Method : "PyOccurrenceLocator_Progress ()"
// Attribute Method : "PyOccurrenceLocator_progress ()"
static PyObject* PyOccurrenceLocator_Progress ( PyOccurrenceLocator *self ) {
trace << "OccurrenceLocator.Progress()" << endl;
static PyObject* PyOccurrenceLocator_progress ( PyOccurrenceLocator *self ) {
trace << "OccurrenceLocator.progress()" << endl;
HTRY
METHOD_HEAD ( "OccurrenceLocator.Progress()" )
METHOD_HEAD ( "OccurrenceLocator.progress()" )
locator->Progress ();
locator->progress ();
HCATCH
Py_RETURN_NONE;
@ -150,8 +150,8 @@ extern "C" {
// PyOccurrenceLocator Attribute Method table.
PyMethodDef PyOccurrenceLocator_Methods[] =
{ { "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." }
{ { "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." }
, { "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." }
, { "destroy" , (PyCFunction)PyOccurrenceLocator_destroy , METH_NOARGS
@ -168,7 +168,7 @@ extern "C" {
LocatorPyTypeObjectLinkPyType(Occurrence, Occurrence)
# else // End of Python Module Code Part.
#else // End of Python Module Code Part.
// x=================================================================x

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

@ -85,7 +85,7 @@ extern "C" {
// Standart Predicates (Attributes).
DirectGetBoolAttribute(PyPinLocator_IsValid,IsValid,PyPinLocator,Locator<Pin*>)
DirectGetBoolAttribute(PyPinLocator_isValid,isValid,PyPinLocator,Locator<Pin*>)
// Standart Locator Accessors (Attributes).
@ -104,8 +104,8 @@ extern "C" {
// PyPinLocator Attribute Method table.
PyMethodDef PyPinLocator_Methods[] =
{ { "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." }
{ { "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." }
, { "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." }
, { "destroy" , (PyCFunction)PyPinLocator_destroy , METH_NOARGS

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

@ -86,7 +86,7 @@ extern "C" {
// Standart Predicates (Attributes).
DirectGetBoolAttribute(PyPlugLocator_IsValid,IsValid,PyPlugLocator,Locator<Plug*>)
DirectGetBoolAttribute(PyPlugLocator_isValid,isValid,PyPlugLocator,Locator<Plug*>)
// Standart Locator Accessors (Attributes).
@ -101,8 +101,8 @@ extern "C" {
// PyPlugLocator Attribute Method table.
PyMethodDef PyPlugLocator_Methods[] =
{ { "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." }
{ { "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." }
, { "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." }
, {NULL, NULL, 0, NULL} /* sentinel */

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

@ -82,7 +82,7 @@ extern "C" {
// Standart Predicates (Attributes).
DirectGetBoolAttribute(PyReferenceLocator_IsValid,IsValid,PyReferenceLocator,Locator<Reference*>)
DirectGetBoolAttribute(PyReferenceLocator_isValid,isValid,PyReferenceLocator,Locator<Reference*>)
// Standart Locator Accessors (Attributes).
@ -101,8 +101,8 @@ extern "C" {
// PyReferenceLocator Attribute Method table.
PyMethodDef PyReferenceLocator_Methods[] =
{ { "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." }
{ { "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." }
, { "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." }
, { "destroy" , (PyCFunction)PyReferenceLocator_destroy , METH_NOARGS
@ -120,7 +120,7 @@ extern "C" {
LocatorPyTypeObjectLinkPyType(Reference, Reference*)
# else // End of Python Module Code Part.
#else // End of Python Module Code Part.
// x=================================================================x

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

@ -84,7 +84,7 @@ extern "C" {
// Standart Predicates (Attributes).
DirectGetBoolAttribute(PySegmentLocator_IsValid,IsValid,PySegmentLocator,Locator<Segment*>)
DirectGetBoolAttribute(PySegmentLocator_isValid,isValid,PySegmentLocator,Locator<Segment*>)
// Standart Locator Accessors (Attributes).
@ -103,8 +103,8 @@ extern "C" {
// PySegmentLocator Attribute Method table.
PyMethodDef PySegmentLocator_Methods[] =
{ { "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." }
{ { "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." }
, { "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." }
, { "destroy" , (PyCFunction)PySegmentLocator_destroy , METH_NOARGS