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

documentation in progress

This commit is contained in:
The Coriolis Project 2008-02-05 21:26:22 +00:00
parent aa405b5147
commit 898f7dfb81
101 changed files with 15016 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
hurricane/CMakeLists.txt
View File

@ -7,6 +7,10 @@ set(CMAKE_MODULE_PATH "${HURRICANE_SOURCE_DIR}/cmake_modules/")
find_package(Qt4 REQUIRED) # find and setup Qt4 for this project
find_package(BISON REQUIRED)
find_package(FLEX REQUIRED)
find_package(Doxygen)
add_subdirectory(src)
add_subdirectory(cmake_modules)
if(DOXYGEN_FOUND)
add_subdirectory(doc)
endif(DOXYGEN_FOUND)

1
hurricane/doc/CMakeLists.txt Normal file
View File

@ -0,0 +1 @@
add_subdirectory(hurricane)

353
hurricane/doc/hurricane/ASIM-bigfonts.css Normal file
View File

@ -0,0 +1,353 @@
/*
* x-----------------------------------------------------------------x
* | HTML Standart Tags |
* x-----------------------------------------------------------------x
*/
html, body, th, td, tr, p, li, h1, h2, h3, h4, h5, h6 {
font-size: 100%;
font-family: verdana, sans-serif;
}
body {
color: black;
background: white;
background-color: white;
background-position: top left;
background-attachment: fixed;
background-repeat: no-repeat;
margin-top: 2em;
margin-right: 10%;
margin-left: 10%;
}
hr {
height: 1px;
border: 0;
color: #004400;
background-color: #004400;
}
h1, h2, h3, h4, h5, h6 {
font-family: verdana, sans-serif;
}
h1 { text-align: center; }
h2, h3, h4, h5, h6 { text-align: left;
padding-top: 2em;
}
h1, h2, h3 { font-family: "Trebuchet MS", sans-serif;
color: #09550B;
}
h1 { font-weight: bold; font-size: 170%; }
h2 { font-weight: bold; font-size: 140%; }
h3 { font-weight: bold; font-size: 118%; }
h4 { font-weight: bold; font-size: 100%; }
h5 { font-style: italic; font-size: 100%; }
h6 { font-variant: small-caps; font-size: 100%; }
.hide {
display: none;
color: white;
}
p {
margin-top: 0.6em;
margin-bottom: 0.6em;
margin-left: 0.0em;
margin-right: 0.0em;
}
address {
text-align: right;
font-weight: bold;
font-style: italic;
font-size: 80%;
}
caption { font-weight: bold }
blockquote {
margin-left: 4em;
margin-right: 4em;
margin-top: 0.8em;
margin-bottom: 0.8em;
font-style: italic;
color: #003300;
}
blockquote p {
margin-bottom: 0;
}
blockquote address {
margin: 0;
}
table {
border-collapse: collapse;
}
dt, dd { margin-top: 0; margin-bottom: 0; }
dt { font-weight: bold; }
pre, tt, code {
font-family: "andale mono", monospace;
font-size: 100%;
white-space: pre;
}
pre {
font-size: 80%;
border: solid;
border-width: thin;
border-color: #003300;
background-color: #EEEEEE;
padding: 0.5em;
margin-left: 2em;
margin-right: 2em
}
tt { color: green; }
em { font-style: italic; font-weight: bold; }
strong { font-weight: bold; }
span.textit { font-style: italic; }
span.textbf { font-weight: bold; }
.small { font-size: 90%; }
.white { color: #FFFFFF; }
ul.toc {
list-style: disc;
list-style: none;
}
a:link img, a:visited img { border-style: none; }
a img { color: white; }
a:link, a:active, a:visited {
color: #09550B;
text-decoration: none;
}
a:hover, a:focus {
color: #FF9900;
text-decoration: underline;
}
/*
* x-----------------------------------------------------------------x
* | Doxygen Specific Classes |
* x-----------------------------------------------------------------x
*/
/* -------------------------------------------------------------------
* Header & Footer Classes (customized top page navigation bar).
*/
table.header {
width: 100%;
/*background-color: #EEEEEE;*/
background-color: #CCE6CA;
}
h1.header {
font-family: times, verdana, sans-serif;
}
td.header {
/*width: 14%;*/
text-align: center;
font-weight: bold;
font-family: verdana, sans-serif;
}
table.footer {
width: 100%;
}
td.leftFoot1, td.leftFoot2 {
text-align: left;
}
td.rightFoot1, td.rightFoot2 {
text-align: right;
}
td.leftFoot2 {
font-family: time;
font-weight: bold;
}
td.rightFoot2 {
font-weight: bold;
}
div.ah {
font-family: time;
font-size: 250%;
}
/* -------------------------------------------------------------------
* Quick Index Class (top page navigation bar).
*/
div.qindex, div.nav {
width: 100%;
/*background-color: #DADAEF;*/
/*background-color: #eeeeff;*/
/*background-color: #EEEEEE;*/
background-color: #CCE6CA;
border: 1px solid #003300;
text-align: center;
margin: 2px;
padding: 2px;
line-height: 140%;
}
a.qindex, a.qindex:visited, a.qindex:hover, a.qindexHL, a.el, a.elRef {
text-decoration: none;
font-weight: bold;
}
a.qindex, a.qindex:visited {
color: #09550B;
}
a.qindex:hover {
background-color: #ddddff;
}
a.qindexHL, a.qindexHL:hover, a.qindexHL:visited {
background-color: #0c780c;
color: #ffffff;
border: 1px double #9295C2;
}
a.code:link, a.code:visited, a.codeRef:link, a.codeRef:visited {
text-decoration: none;
font-weight: normal;
color: #0000ff;
}
.indexkey {
background-color: #eeeeff;
border: 1px solid #b0b0b0;
padding: 2px 15px;
}
.indexkey, .indexvalue {
background-color: #eeeeff;
border: 1px solid #b0b0b0;
padding: 2px 15px;
}
.indexkey {
width: 40%;
}
.indexvalue {
width: 80%;
}
/* -------------------------------------------------------------------
* Verbatim Source Code / Examples.
*/
pre.fragment { background-color: #EEEEEE; }
span.keyword { color: #008000 }
span.keywordtype { color: #604020 }
span.keywordflow { color: #e08000 }
span.comment { color: #800000 }
span.preprocessor { color: #806020 }
span.stringliteral { color: #002080 }
span.charliteral { color: #008080 }
/* -------------------------------------------------------------------
* Attributes Listing.
*/
.mdTable {
/*border: 1px solid #868686;*/
/*background-color: #DADAEF;*/
/*background-color: #F4F4FB;*/
border: 1px none #868686;
/*background-color: #B8E6B8;*/
background-color: #CCE6CA;
margin-top: 25px;
}
.mdRow {
padding: 5px 10px;
}
/* This Mozilla/Firefox bug has been corrected from v1.5.
* .mdname1 {
* padding: 3px 0px 0px 0px;
* }
*/
.mdescLeft, .mdescRight {
padding: 0px 8px 4px 8px;
font-size: 12px;
font-style: italic;
/*background-color: #FAFAFA;*/
border-top: 1px none #E0E0E0;
border-right: 1px none #E0E0E0;
border-bottom: 1px none #E0E0E0;
border-left: 1px none #E0E0E0;
margin: 0px;
}
.memItemLeft, .memItemRight, .memTemplItemLeft {
padding: 1px 0px 0px 8px;
margin: 4px;
border-top-width: 1px;
border-right-width: 1px;
border-bottom-width: 1px;
border-left-width: 1px;
border-top-color: #0c0c0c;
border-right-color: #0c0c0c;
border-bottom-color: #0c0c0c;
border-left-color: #0c0c0c;
border-top-style: solid;
border-right-style: none;
border-bottom-style: none;
border-left-style: none;
/*background-color: #DADAEF;*/
/*background-color: #eeeeff;*/
/*background-color: #EEEEEE;*/
background-color: #CCE6CA;
}
.memItemLeft { font-size: 12px; }
.memItemRight { font-size: 13px; }
.memTemplItemLeft { font-size: 12px; }
.memTemplItemRight { font-size: 13px; }
.memTemplParams {
color: #606060;
background-color: #DADAEF;
font-size: 12px;
}

485
hurricane/doc/hurricane/ASIM.css Normal file
View File

@ -0,0 +1,485 @@
/*
* x-----------------------------------------------------------------x
* | HTML Standart Tags |
* x-----------------------------------------------------------------x
*/
html, body, th, td, tr, p, li, h1, h2, h3, h4, h5, h6 {
font-size: 96%;
font-family: verdana, sans-serif;
}
body {
color: black;
background: white;
background-color: white;
background-position: top left;
background-attachment: fixed;
background-repeat: no-repeat;
margin-top: 2em;
margin-right: 8%;
margin-left: 8%;
}
hr {
height: 1px;
border: 0;
color: #004400;
background-color: #004400;
}
h1, h2, h3, h4, h5, h6 {
font-family: verdana, sans-serif;
}
h1 { text-align: center; }
h2, h3, h4, h5, h6 { text-align: left;
padding-top: 2em;
}
h1, h2, h3 { font-family: "Trebuchet MS", sans-serif;
color: #09550B;
}
h1 { font-weight: bold; font-size: 170%; }
h2 { font-weight: bold; font-size: 140%; }
h3 { font-weight: bold; font-size: 118%; }
h4 { font-weight: bold; font-size: 100%; }
h5 { font-style: italic; font-size: 100%; }
h6 { font-variant: small-caps; font-size: 100%; }
h2.classHierarchy {
/*border: 1px none #008500;*/
border: 1px none #000000;
border-top-width: 2px;
border-top-style: solid;
padding-top: 1em;
}
.hide {
display: none;
color: white;
}
p {
margin-top: 0.6em;
margin-bottom: 0.6em;
margin-left: 0.0em;
margin-right: 0.0em;
}
address {
text-align: right;
font-weight: bold;
font-style: italic;
font-size: 80%;
}
caption { font-weight: bold }
blockquote {
margin-left: 4em;
margin-right: 4em;
margin-top: 0.8em;
margin-bottom: 0.8em;
font-style: italic;
color: #003300;
}
blockquote p {
margin-bottom: 0;
}
blockquote address {
margin: 0;
}
table {
border-collapse: collapse;
}
dt, dd { margin-top: 0; margin-bottom: 0; }
dt { font-weight: bold; }
pre, tt, code {
font-family: "andale mono", monospace;
font-size: 100%;
white-space: pre;
}
pre {
font-size: 80%;
border: dashed;
border-width: thin;
border-color: #003300;
/*
background-color: #EEEEEE;
*/
background-color: #FCFCE1;
padding: 0.5em;
margin-left: 2em;
margin-right: 2em
}
tt { color: green; }
em { font-style: italic;
font-weight: bold; }
strong { font-weight: bold; }
span.textit { font-style: italic; }
span.textbf { font-weight: bold; }
.small { font-size: 90%; }
.white { color: #FFFFFF; }
ul.toc {
list-style: disc;
list-style: none;
}
a:link img, a:visited img { border-style: none; }
a img { color: white; }
a:link, a:active, a:visited {
color: #09550B;
text-decoration: none;
}
a:hover, a:focus {
color: #FF9900;
text-decoration: underline;
}
/*
* x-----------------------------------------------------------------x
* | Doxygen Specific Classes |
* x-----------------------------------------------------------------x
*/
/* -------------------------------------------------------------------
* Header & Footer Classes (customized top page navigation bar).
*/
h1.header {
font-size: 200%;
font-family: times, verdana, sans-serif;
}
center.header {
background-color: #CCE6CA;
}
table.header {
/*width: 100%;*/
/*background-color: #EEEEEE;*/
background-color: #CCE6CA;
}
table.header td {
padding: 2px 14px;
text-align: center;
font-weight: bold;
font-family: verdana, sans-serif;
font-size: 110%;
}
table.footer1, table.footer2 { width: 100%; }
td.LFooter { text-align: left; }
td.RFooter { text-align: right; }
td.CFooter { text-align: center;}
table.footer2 td.RFooter { font-weight: bold; width: 35% }
table.footer2 td.CFooter { width: 30% }
table.footer2 td.LFooter { font-weight: bold; width: 35%; font-family: time; }
table.classHierarchy {
border-collapse: separate;
border-spacing: 5px;
font-size: 110%;
}
table.classHierarchy tr {
border: 1px solid blue;
}
table.classHierarchy td.normal {
border: 1px solid #CCE6CA;
width: 140pt;
text-align: center;
font-weight: bold;
background-color: #CCE6CA;
}
table.classHierarchy td.virtual {
border: 1px solid black;
width: 140pt;
text-align: center;
font-weight: bold;
}
table.classHierarchy td.wnormal {
border: 1px solid #CCE6CA;
width: 240pt;
text-align: center;
font-weight: bold;
background-color: #CCE6CA;
}
table.classHierarchy td.wvirtual {
border: 1px solid black;
width: 240pt;
text-align: center;
font-weight: bold;
}
div.ah {
font-family: time;
font-size: 250%;
}
/* -------------------------------------------------------------------
* Quick Index Class (top page navigation bar).
*/
div.qindex, div.nav {
width: 100%-4px;
/*background-color: #DADAEF;*/
/*background-color: #eeeeff;*/
/*background-color: #EEEEEE;*/
background-color: #CCE6CA;
border: 0px solid #003300;
text-align: center;
margin: 0px;
padding: 2px;
line-height: 140%;
}
a.qindex, a.qindex:visited, a.qindex:hover, a.qindexHL, a.el, a.elRef {
text-decoration: none;
font-weight: bold;
}
a.qindex, a.qindex:visited {
color: #09550B;
}
a.qindex:hover {
background-color: #ddddff;
}
a.qindexHL, a.qindexHL:hover, a.qindexHL:visited {
background-color: #0c780c;
color: #ffffff;
border: 1px double #9295C2;
}
a.code:link, a.code:visited, a.codeRef:link, a.codeRef:visited {
text-decoration: none;
font-weight: normal;
color: #0000ff;
}
.indexkey {
background-color: #eeeeff;
border: 1px solid #b0b0b0;
padding: 2px 15px;
}
.indexkey, .indexvalue {
background-color: #eeeeff;
border: 1px solid #b0b0b0;
padding: 2px 15px;
}
.indexkey {
width: 40%;
}
.indexvalue {
width: 80%;
}
h3 a[name="index__"],
h3 a[name="index_a"],
h3 a[name="index_b"],
h3 a[name="index_c"],
h3 a[name="index_d"],
h3 a[name="index_e"],
h3 a[name="index_f"],
h3 a[name="index_g"],
h3 a[name="index_h"],
h3 a[name="index_i"],
h3 a[name="index_j"],
h3 a[name="index_k"],
h3 a[name="index_l"],
h3 a[name="index_m"],
h3 a[name="index_n"],
h3 a[name="index_o"],
h3 a[name="index_p"],
h3 a[name="index_q"],
h3 a[name="index_r"],
h3 a[name="index_s"],
h3 a[name="index_t"],
h3 a[name="index_u"],
h3 a[name="index_v"],
h3 a[name="index_w"],
h3 a[name="index_x"],
h3 a[name="index_y"],
h3 a[name="index_z"],
h3 a[name="index_0"],
h3 a[name="index_1"],
h3 a[name="index_2"],
h3 a[name="index_3"],
h3 a[name="index_4"],
h3 a[name="index_5"],
h3 a[name="index_6"],
h3 a[name="index_7"],
h3 a[name="index_8"],
h3 a[name="index_9"]
{
font-family: time;
font-size: 250%;
}
/* -------------------------------------------------------------------
* Verbatim Source Code / Examples.
*/
/* pre.fragment { background-color: #EEEEEE; } */
span.keyword { color: #008000 }
span.keywordtype { color: #604020 }
span.keywordflow { color: #e08000 }
span.comment { color: #800000 }
span.preprocessor { color: #806020 }
span.stringliteral { color: #002080 }
span.charliteral { color: #008080 }
/* -------------------------------------------------------------------
* Attributes Listing.
*/
.mdTable {
/*border: 1px solid #868686;*/
/*background-color: #DADAEF;*/
/*background-color: #F4F4FB;*/
border: 1px none #008500;
border-left-width: 1px;
border-left-style: solid;
/*background-color: #B8E6B8;*/
/*background-color: #CCE6CA;*/
margin-top: 25px;
font-size: 105%;
}
.mdRow {
padding: 5px 10px;
}
/* This Mozilla/Firefox bug has been corrected from v1.5.
* .mdname1 {
* padding: 3px 0px 0px 0px;
* }
*/
.mdescLeft, .mdescRight {
padding: 0px 8px 4px 8px;
font-size: 11px;
font-style: italic;
/*background-color: #FAFAFA;*/
border-top: 1px none #E0E0E0;
border-right: 1px none #E0E0E0;
border-bottom: 1px none #E0E0E0;
border-left: 1px none #E0E0E0;
margin: 0px;
}
.memitem {
margin-bottom: 30px;
border: 1px none #008500;
}
.memproto {
background-color: #CCE6CA;
border-left-width: 4px;
border-left-style: solid;
border-color: #008500;
}
.memname {
white-space: nowrap;
padding-left: 5px;
font-size: 105%;
}
.memdoc{
padding-left: 5px;
/*margin-top: -8px;*/
border-left-width: 1px;
border-left-style: solid;
border-color: #008500;
}
.memItemLeft, .memItemRight, .memTemplItemLeft, .memTemplItemRight {
padding: 1px 0px 0px 8px;
margin: 4px;
border-top-width: 1px;
border-right-width: 1px;
border-bottom-width: 1px;
border-left-width: 1px;
border-top-color: #0c0c0c;
border-right-color: #0c0c0c;
border-bottom-color: #0c0c0c;
border-left-color: #0c0c0c;
border-top-style: solid;
border-right-style: none;
border-bottom-style: none;
border-left-style: none;
/*background-color: #DADAEF;*/
/*background-color: #eeeeff;*/
/*background-color: #EEEEEE;*/
background-color: #CCE6CA;
}
.memTemplItemLeft, .memTemplItemRight {
border-bottom-width: 2px;
border-bottom-style: solid;
font-weight: bold;
}
.memItemLeft { font-size: 11px; }
.memItemRight { font-size: 12px; }
.memTemplItemLeft { font-size: 11px; }
.memTemplItemRight { font-size: 12px; }
.memTemplParams {
color: #FFFFFF;
background-color: #000000;
font-size: 11px;
font-weight: bold;
}
.groupText, .groupHeader {
color: #09550B;
margin-top: 15px;
font-size: 130%;
font-weight: bold;
}

165
hurricane/doc/hurricane/BasicLayer.dox Normal file
View File

@ -0,0 +1,165 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class BasicLayer
* \brief BasicLayer description (\b API)
*
*/
/*! \typedef BasicLayer::Inherit
* Useful for calling upon methods of the base class without
* knowing it.
*/
/*! \name Constructors
*/
// \{
/*! \function BasicLayer* BasicLayer::Create(Technology* technology,const Name& name,const BasicLayer::Type& type,unsigned extractNumber,const Unit& minimalSize = 0,const Unit& minimalSpacing = 0);
* Creates and returns a new basic layer named \c \<name\>, of
* type \c \<type\> for the given technology (some geometrical
* characteristics can also be specified).
*
* \caution Throws an exception if the technology is null, if the name is
* empty, if a layer of same name already exists or if we
* overflow the capacity of the bit field associated to the
* layer mask.
*
* \remark The extract number is a kind of logic number. In example the
* CP layer which represent a poly layer should have the same
* extract number as the CPG layer which represent a poly layer
* used to realize the transistor gates. While extractions
* process, layers which have the same extract number are
* considered as equivalents. A null value indicates that the
* extraction should ignore this layer.
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function const BasicLayer::Type& BasicLayer::GetType() const;
* \Return the basic layer type.
*/
/*! \function unsigned BasicLayer::GetExtractNumber() const;
* \Return the extract number.
*/
/*! \function const unsigned short& BasicLayer::GetRedValue() const;
* No description.
*/
/*! \function const unsigned short& BasicLayer::GetGreenValue() const;
* No description.
*/
/*! \function const unsigned short& BasicLayer::GetBlueValue() const;
* No description.
*/
/*! \function const string& BasicLayer::GetFillPattern() const;
* Basic layers have graphic display characteristics which are
* defined by both a color and a filling pattern. The above
* methods provide the corresponding accessor functions.
*
* <b>Color :</b>
*
* A color is defined by its three RGB components (whose values
* lies in the 0, 255).
*
* <b>Pattern :</b>
*
* A filling pattern is a stiple (transparent bitmap) of 8 by 8
* pixels. The 64 bits of this stiple are defined by a string of
* 16 characters (allowed characters are 0123456789ABCDEF and
* abcdef). The 2 first characters describe the first line, the
* following 2 the second line and so forth. Pixels set to 1
* will be drawn with the color layer while pixels set to 0 are
* transparent. So the string "A5A5A5A5A5A5A5A5" represents a
* stipple with staggered pixel each two ones, while the
* "FFFFFFFFFFFFFFFF" stipple fills all the pixels (default
* value).
*/
/*! \function double BasicLayer::GetDisplayThreshold() const;
* In order to get an efficient graphic display we need :
*
* On one hand, when we are in close view, quickly filter
* objects which don't intersect the visible area. This is done
* by a quadtree geometrical access structure and also by the
* hierachy of cell assembly.
*
* On the other hand, when we are in an overview, not display
* very small objects (it is useless to display the internals of
* cells which represent few pixels on screen) and not display
* components laying on deep layers (because this doesn't help
* and probably the drawing will be hidden by upper layers).
*
* There is not a clear-cut between those two modes, so we
* change progressively the display behaviour.
*
* For that purpose we introduce for each basic layer a display
* threshold with shifting values, this makes appear
* progresively the different deep layers while we get closer
* and closer to the basic components
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function void BasicLayer::SetColor(unsigned short redValue, unsigned short greenValue, unsigned short blueValue);
* Sets the color of a basic layer.
*/
/*! \function void BasicLayer::SetFillPattern(const string& fillPattern);
* Sets the filling pattern of a basic layer.
*
* \caution Throws an exception if the string does't obey to the rules
* described above.
*/
/*! \function void BasicLayer::SetDisplayThreshold(double threshold);
* Sets the display threshold of a basic layer.
*/
// \}
/*! \name BasicLayer Collection
*/
// \{
/*! \typedef BasicLayers
* Generic collection representing a set of basic layers.
*/
/*! \typedef BasicLayerLocator
* Generic locator for traversing a collection of basic layers.
*/
/*! \typedef BasicLayerFilter
* Generic filter allowing to select a subset of basic layers
* matching some criteria.
*/
/*! \def for_each_basic_layer(basicLayer, basicLayers)
* Macro for visiting all the layers of a collection of basic
* layers.
*/
// \}
}

262
hurricane/doc/hurricane/Box.dox Normal file
View File

@ -0,0 +1,262 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Box
* \brief Box description (\b API)
*
* \section secBoxIntro Introduction
*
* Those objects represent rectangular boxes. They are defined
* by the values <b>XMin</b>, <b>YMin</b>, <b>XMax</b> and
* <b>YMax</b> which are representatives only when the box is
* not empty. A box is considered empty whenever it is not
* initialized or when it doesn't represent a real area like the
* intersection of two disjoint boxes.
*
*
* \section secBoxModifierRemark Remark on Modifiers
*
* All the function described in the modifiers section returns a
* reference on the modified box, providing so the capability to
* apply to it a new modification as illustrated in the
* following example :
\code
Box box1(0, 0, 100, 100);
Box box2(20, 20, 50, 150;
if (box1.Inflate(3).Merge(box2.Translate(10, 10).Inflate(-1, 1)).Contains(20, 20)) {
// do we reach here ? that is the question !
}
\endcode
*/
/*! \name Constructors
*/
// \{
/*! \function Box::Box();
* Default constructor : the returned box is empty.
*/
/*! \function Box::Box(const Unit& x, const Unit& y);
* Builds a box of null size centered on the point defined by
* \c \<x\> and \c \<y\>.
*/
/*! \function Box::Box(const Point& point);
* Builds a box of null size centered on the point.
*/
/*! \function Box::Box(const Unit& x1, const Unit& y1, const Unit& x2, const Unit& y2);
* Builds the minimal box enclosing the two points defined by
* the coordinates \c \<x1\>, \c \<y1\> and \c \<x2\>,
* \c \<y2\>.
*/
/*! \function Box::Box(const Point& point1, const Point& point2);
* Builds the minimal box enclosing the two points.
*/
/*! \function Box::Box(const Box& box);
* Copy constructor.
*/
// \}
/*! \name Operators
*/
// \{
/*! \function Box& Box::operator=(const Box& box);
* Assignment operator.
*/
/*! \function bool Box::operator==(const Box& box) const;
* Equality operator.
*
* \remark Two empty boxes are always different.
*/
/*! \function bool Box::operator!=(const Box& box) const;
* Difference operator.
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function const Unit& Box::GetXMin() const;
* \Return the XMin value : meaningful only for a non empty box.
*/
/*! \function const Unit& Box::GetYMin() const;
* \Return the YMin value : meaningful only for a non empty box.
*/
/*! \function const Unit& Box::GetXMax() const;
* \Return the XMax value : meaningful only for a non empty box.
*/
/*! \function const Unit& Box::GetYMax() const;
* \Return the YMax value : meaningful only for a non empty box.
*/
/*! \function Unit Box::GetXCenter() const;
* \Return the abscissa of the box center : meaningful only for a non
* empty box.
*/
/*! \function Unit Box::GetYCenter() const;
* \Return the ordinate of the box center : meaningful only for a non
* empty box.
*/
/*! \function Point Box::GetCenter() const;
* \Return the box center point : meaningful only for a non empty box.
*/
/*! \function Unit Box::GetWidth() const;
* \Return the box width : meaningful only for a non empty box.
*/
/*! \function Unit Box::GetHalfWidth() const;
* \Return the half box width : meaningful only for a non empty box.
*/
/*! \function Unit Box::GetHeight() const;
* \Return the box height : meaningful only for a non empty box.
*/
/*! \function Unit Box::GetHalfHeight() const;
* \Return the half box height : meaningful only for a non empty box.
*/
/*! \function Box Box::GetUnion(const Box& box) const;
* \Return the smallest enclosing box containing the boxes \c \<this\>
* and \c \<box\>. The returned box may be empty if both are.
*/
/*! \function Box Box::GetIntersection(const Box& box) const;
* \Return box representing the overlapping area. This box is empty if
* either one of the two boxes is empty or if they are disjoint.
*/
// \}
/*! \name Predicates
*/
// \{
/*! \function bool Box::IsEmpty() const;
* \Return \true if the box is empty, else \false.
*/
/*! \function bool Box::IsFlat() const;
* \Return \true if the box is non void and if we have either
* ((XMin==XMax) an (YMin\<YMax)) or ((XMin\<XMax) and
* (YMin==YMax)).
*/
/*! \function bool Box::IsPonctual() const;
* \Return \true if the box is reduced to a point, else \false.
*/
/*! \function bool Box::Contains(const Unit& x, const Unit& y) const;
* \Return \true if the box is non empty and contains the point defined
* by the coordinates \c \<x\>, \c \<y\> else \false.
*/
/*! \function bool Box::Contains(const Point& point) const;
* \Return \true if the box is non empty and contains the point
* \c \<point\>, else \false.
*/
/*! \function bool Box::Contains(const Box& box) const;
* \Return \true if the two boxes are non empty and if the box
* \c \<this\> contains the box \c \<box\>, else \false.
*/
/*! \function bool Box::Intersect(const Box& box) const;
* \Return \true if the two boxes are non empty and if they overlap,
* else \false.
*/
/*! \function bool Box::IsConstrainedBy(const Box& box) const;
* \Return \true if the two boxes are non empty, if the box \c \<this\>
* contains the box \c \<box\> and if those two boxes have at
* least a common border side, else \false.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function Box& Box::MakeEmpty();
* Transforms the box into an empty one.
*/
/*! \function Box& Box::Inflate(const Unit& d);
* Expands (or contracts) the box, if not empty, in each
* direction of the quantity \c \<d\>. This quantity might be
* negative enough to transform it into an empty box.
*/
/*! \function Box& Box::Inflate(const Unit& dx, const Unit& dy);
* Expands (or contracts) the box, if not empty, horizontaly of
* the quantity \c \<dx\> and vertically of the quatity
* \c \<dy\>. Those quantities might be negative enough to
* transform it into an empty box.
*/
/*! \function Box& Box::Inflate(const Unit& dxMin, const Unit& dyMin, const Unit& dxMax, const Unit& dyMax);
* Expands (or contracts) the box, if not empty, on the left of
* the quantity \c \<dxMin\>, on the bottom of the quantity
* \c \<dyMin\>, on the right of the quantity \c \<dxMax\> and
* on the top of the quantity \c \<dyMax\>. Those quantities
* might be negative enough to transform it into an empty box.
*/
/*! \function Box& Box::Merge(const Unit& x, const Unit& y);
* Expands the box in order that it encloses the point defined
* by coordinates \c \<x\> and \c \<y\>. If the box was
* initially empty it becomes reduced to the enclosed point.
*/
/*! \function Box& Box::Merge(const Point& point);
* Expands the box in order that it encloses the point
* \c \<point\>. If the box was initially empty it becomes
* reduced to the enclosed point.
*/
/*! \function Box& Box::Merge(const Unit& x1, const Unit& y1, const Unit& x2, const Unit& y2);
* Expands the box in order that it encloses the points defined
* by coordinates \c \<x1\>, \c \<y1\> and \c \<x2\>, \c \<y2\>.
*/
/*! \function Box& Box::Merge(const Box& box);
* Expands the box in order that it encloses, if not empty, the
* box \c \<box\>. If the box \c \<this\> was initially empty it
* becomes reduced to the enclosed box.
*/
/*! \function Box& Box::Translate(const Unit& dx, const Unit& dy);
* Translates the box, if not empty, of the quantities \c \<dx\>
* and \c \<dy\>.
*/
// \}
}

1
hurricane/doc/hurricane/CMakeLists.txt Normal file
View File

@ -0,0 +1 @@
EXEC_PROGRAM(${DOXYGEN_EXECUTABLE})

248
hurricane/doc/hurricane/Cell.dox Normal file
View File

@ -0,0 +1,248 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Cell
* \brief The model (\b API).
*/
/*! \name Constructors & Destructors
*/
// \{
/*! \function Cell* Cell::Create ( Library* library, const Name& name );
* Creates and returns a new Cell named \e name for the Library
* \e library.
*
* \caution Throws an exception if the Library is null, if the Name is
* empty or if a cell with same name already exists in the
* Library.
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function Library* Cell::GetLibrary () const;
* Returns the Library owning the Cell.
*/
/*! \function const Name& Cell::GetName () const;
* Returns the Name of the Cell.
*/
/*! \function Instance* Cell::GetInstance ( const Name& name ) const;
* Returns the Instance of name \e name if it exists, else \NULL.
*/
/*! \function Instances Cell::GetInstances () const;
* Returns the Collection of all instances called by the Cell.
*/
/*! \function Instances Cell::GetInstancesUnder ( const Box& area ) const;
* Returns the collection of all instances of the Cell intersecting the
* given rectangular \e area.
*/
/*! \function Instances Cell::GetSlaveInstances () const;
* Returns the Collection of instances whose master is this Cell.
*/
/*! \function Net* Cell::GetNet ( const Name& name ) const;
* Returns the Net of name \e name if it exists, else \NULL.
*/
/*! \function Nets Cell::GetNets () const;
* Returns the Collection of all nets of the Cell.
*/
/*! \function Nets Cell::GetGlobalNets () const;
* Returns the Collection of all global nets of the Cell.
*/
/*! \function Nets Cell::GetExternalNets () const;
* Returns the Collection of all external nets of the Cell.
*/
/*! \function Nets Cell::GetInternalNets () const;
* Returns the Collection of all internal nets of the Cell.
*/
/*! \function Nets Cell::GetClockNets () const;
* Returns the Collection of all clock nets of the Cell.
*/
/*! \function Nets Cell::GetSupplyNets () const;
* Returns the Collection of all supply nets of the Cell.
*/
/*! \function Slice* Cell::GetSlice ( const Layer* layer ) const;
* Returns the Slice associated with the Layer \e layer if it exists, else \NULL.
*/
/*! \function Slices Cell::GetSlices ( const Layer::Mask& mask = ~0 ) const;
* Returns the Collection of slices of a Cell.
*/
/*! \function Views Cell::GetViews () const;
* Returns the Collection of graphical views of a Cell.
*/
/*! \function Views Cell::GetMainViews () const;
* Returns the Collection of main graphical views of a Cell.
*/
/*! \function Views Cell::GetImpactedMainViews () const;
* Returns the Collection of main graphical views we should update after
* a Cell has been modified.
*
* When applying modifications upon a Cell, we need to update
* main graphical views of a cell but also main graphical views
* of cells which call directly or indirectly the Cell.
*/
/*! \function Rubbers Cell::GetRubbers () const;
* Returns the Collection of all Rubbers of a Cell.
*/
/*! \function Rubbers Cell::GetRubbersUnder ( const Box& area ) const;
* Returns the collection of all Rubbers of the Cell intersecting the
* given rectangular \e area.
*
* \caution Only currently materialized rubbers are taken into account
* in this collection.
*/
/*! \function Components Cell::GetComponents ( const Layer::Mask& mask = ~0 ) const;
* Returns the Collection of all Components of the Cell.
*/
/*! \function Components Cell::GetComponentsUnder ( const Box& area, const Layer::Mask& mask = ~0 ) const;
* Returns the collection of all Components of the Cell intersecting the
* given rectangular \e area.
*
* \caution Only currently materialized Components are taken into account
* in this collection.
*/
/*! \function Occurrences Cell::GetOccurrences ( unsigned searchDepth=(unsigned)-1 ) const;
* Returns the Collection of all Occurrences belonging to this Cell.
*
* \remark The search depth is decremented each time a hirearchical
* level is crossed. The search ends when depth becomes null
* (the value \c INFINITE is equal to \c (unsigned)-1) .
*/
/*! \function Occurrences Cell::GetOccurrencesUnder ( const Box& area, unsigned searchDepth=(unsigned)-1 ) const;
* Returns the Collection of all Occurrences belonging to this Cell and
* intersecting the given rectangular area.
*
* \remark The search depth is decremented each time a hirearchical
* level is crossed. The search ends when depth becomes null
* (the value \c INFINITE is equal to \c (unsigned)-1) .
*
* \caution Only occurences corresponding to currently materialized
* entities are taken into account in this Collection.
*/
/*! \function Box Cell::GetAbutmentBox () const;
* Returns Returns the abutment box of the cell (which is defined by the
* designer unlike the bounding box which is managed dynamically).
*/
/*! \function Symbol* Cell::GetSymbol () const;
* Returns the symbol associated to the cell.
*/
// \}
/*! \name Predicates
*/
// \{
/*! \function bool Cell::IsCalledBy ( Cell* cell ) const;
* Returns \true if the cell \this is directly or indirectly called by
* the Cell \e cell. This functions allows to check that there is
* no cyclic instance calls of cells (it is by default,
* automatically called when creating an instance).
*/
/*! \function bool Cell::IsTerminal () const;
* Returns \true if the Cell is marked as terminal (meaning that it has
* no inside or that we dont want to take it into account), else
* \false.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function void Cell::SetName ( const Name& name );
* Allows to change the Cell Name.
*
* \remark Throws an exception if the new \e name is empty or if the
* Library owning the Cell has already a Cell with the same
* name.
*/
/*! \function void Cell::SetAbutmentBox ( const Box& abutmentBox );
* Sets Cell abutment box.
*
* \remark At the Cell creation the abutment box is empty. This one must
* be set through this function. It is possible also, once
* fixed, to reset it to empty (undefined) by passing an empty
* Box as argument.
*/
/*! \function void Cell::SetTerminal ( bool state );
* Sets Cell terminal status to \e state.
*/
/*! \function void Cell::SetSymbol ( Symbol* symbol );
* Associates the symbol \e symbol to the Cell.
*/
/*! \function void Cell::Materialize ();
* Materializes all components of all the nets of the Cell.
*/
/*! \function void Cell::Unmaterialize ();
* De-materializes all components of all the nets of the Cell.
*/
// \}
/*! \name Cell Collection
*/
// \{
/*! \typedef typedef GenericCollection<Cell*> Cells;
* Generic collection representing a set of cell objects.
*/
/*! \typedef typedef GenericLocator<Cell*> CellLocator;
* Generic locator for visiting a cell objects Collection.
*/
/*! \typedef typedef GenericFilter<Cell*> CellFilter;
* Filter to selecting a subset of cell objects matching some criteria.
*/
/*! \def for_each_entity(entity,entities)
* Macro for visiting all objects of a cell objects collection.
*/
// \}
}

364
hurricane/doc/hurricane/Collection.dox Normal file
View File

@ -0,0 +1,364 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Collection
* \brief Collection description (\b API)
*
* \section secCollectionIntro Introduction
*
* Collections introduce the concept of set of elements.
*
* Strictly speaking collections are not containers (in the STL
* way) but indeed set descriptors. For example, the set of
* instances called by a cell, which are located within a given
* rectangular area, will be a subtype of
* Collection\<Instance*\> whose first attribute will be a
* pointer to the cell and a second attribute the rectangular
* area.
*
*
* \section secGenericGetCollection The Generic GetCollection
*
* The collections provide the generic \c GetCollection()
* function which allows to convert its argument into a generic
* collection. It has no specific interest for Hurricane
* collections, but this function is overloaded for STL containers.
*
* This allows to handle a STL containers like a normal
* collection as shown in the following example:
\code
set<Instance*> instanceSet;
// here we fill the set with the desired instances...
for_each_instance(instance, GetCollection(instanceSet)) {
// process here each instance of the set
// (the elements are visited according to the set ordering)
end_for;
}
\endcode
*
*
*
* \remark This approach is a little bit less efficient than the use of
* STL iterators, not much indeed, but has the advantage to be
* homogeneous with the remaining code (recall: the created
* collection doesn't make a copy of the STL container and its
* creation time is negligible).
*
* \caution The returned collection is valid whenever the STL container
* is valid. Then you should not do the following:
\code
GenericCollection<Instance*> GetInstances(...)
// *******************************************
{
set<Instance*> instanceSet;
// we fill the container with the appropriate instances
return GetCollection(instanceSet); // instanceSet deleted after return
}
\endcode
*
*
*
* The same will occur anyway if you do:
\code
Cell* cell = ... // we get the cell
Nets nets = cellGetNets();
cellDelete();
for_each_net(net, nets) {
...
end_for;
}
\endcode
*
*
*/
*/
/*! \section secCollectionImportant Important
*
* Collections are very light objects which are built, copied or
* destroyed very rapidly.
*/
/*! \section secCollectionLocators Locators
*
* Each type of collection provides an associated Locator for
* tracing through the corresponding set of elements.
*
* Each locator moves efficiently through the data structure
* without building (in the form of a list or any other
* container type) the set of elements defined by the collection
* (it may however use a stack (or something else) to manage
* recursive traces).
*
* The elements are therefore visited in the order with which
* they are internally stored. No assumptions must be made about
* this ordering. However, collections representing an STL
* container are visited in the same order than the container's
* one.
*
* If you need to visit the objects in a given order, you must
* first fill a STL container: either a vector to be sorted
* accordingly or a set with the given sort criteria (see the
* Fill method below).
*/
/*! \name Destructors
*/
// \{
/*! \function Collection::~Collection<Type>();
* Destroys the collection but doesn't acts on elements refered
* by this collection.
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function Collection<Type>* Collection::GetClone() const;
* Allocates and returns a clone (copy) of the collection
* (whatever be its type).
*
* \remark In principle there is no need to use this function. However,
* if you do so, don't forget to delete the clone after use. It
* is indeed much easier to use generic collections which do
* that for you, as we will see later.
*/
/*! \function Locator<Type>* Collection::GetLocator() const;
* Allocates and returns a locator adapted to visit the elements
* of the collection.
*
* \remark In principle there is no need to use this function. Use
* preferably the macro <b>for_each</b> described below.
* However, if you do so, don't forget to delete this locator
* after use, else use generic locators, which do that for you,
* as we will see later.
*/
/*! \function unsigned Collection::GetSize() const;
* \Return the number of objects identified within the collection.
*
* \remark Very fast in some cases, but may need to visit the collection
* in most ones.
*/
/*! \function Type Collection::GetFirst() const;
* \Return the first element of the collection.
*
* \remark The result is meaningful only when the collection is non
* empty.
*/
/*! \function GenericCollection<SubType> Collection::GetSubSet<SubType>() const;
* \Return the collection corresponding to the subset of elements of
* type \c \<SubType\>.
*
* \remark The returned collection is a collection of objects of type
* <b>SubType</b> and not of type <b>Type</b>.
*
\code
Contacts Net::GetContacts() const
// ******************************
{
return GetComponents().GetSubSet<Contact*>();
}
\endcode
*/
/*! \function GenericCollection<Type> Collection::GetSubSet(const Filter<Type>& filter) const;
* \Return the collection representing the subset of elements accepted
* by the filter.
\code
Nets Cell::GetExternalNets() const
// *******************************
{
return GetNets().GetSubSet(Net::GetIsExternalFilter());
}
\endcode
*/
/*! \function GenericCollection<SubType> Collection::GetSubSet<SubType>(const Filter<SubType>& filter) const;
* \Return the collection representing the subset of elements of type
* \c \<SubType\> accepted by the filter.
*
* \remark The returned collection is a collection of elements of type
* <b>SubType</b> and not of type <b>Type</b> and the filter
* must be a filter of elements of type <b>SubType</b>.
*
* \sample Filter Hurricane::Segment according to their Layer.
\code
class IsOnLayer : public Filter<Segment*> {
// **************************************
public:
Layer* _layer;
IsOnLayer(Layer* layer)
: _layer(layer)
{
if (!_layer)
throw Error("Can't create IsOnLayer filter : null layer");
};
IsOnLayer(const IsOnLayer& isOnLayer)
: _layer(isOnLayer._layer)
{
};
IsOnLayer& operator=(const IsOnLayer& isOnLayer)
{
_layer = isOnLayer._layer;
return *this;
};
virtual Filter<Net*>* GetClone() const
{
return new IsOnLayer(*this);
};
virtual bool Accept(Segment* segment) const
{
return (segmentGetLayer() == _layer);
};
};
\endcode
*
* And somewher later:
\code
Layer* metal = GetDataBase()GetTechnology()GetLayer("metal");
Segments segments = netGetComponents()->GetSubSet<Segment*>(IsOnLayer(metal));
// segments represents here the subset of net components
// which are of type Segment and located on layer metal
\endcode
*
*
*/
// \}
/*! \name Predicates
*/
// \{
/*! \function bool Collection::IsEmpty() const;
* This function returns \true if the collection designates no
* element and else \false.
*/
// \}
/*! \section secCollectionUtilitarians Utilitarians
*
*
* <b>Collection::Fill</b>
* <b>Collection::Fill</b>
* <b>Collection::Fill</b>
* \remark The elements are added to the container in the order with
* which the collection is visited. So the same order will
* appear in a list or a vector, but for a set they will be
* inserted according to the set ordering method.
*/
/*! \name Collection Collection
*/
// \{
/*! \def for_each_object(Type, element, collection)
* This powerful macro allows you to visit the set of elements
* designated by any type of collection. The first argument
* \c \<Type\> defines the type of elements that will be visited
* and the third argument \c \<collection\> is the traced
* collection. The code body located between macros
* <b>for_each</b> and <b>end_for</b> (that must not be
* forgotten) is then executed for each identified element, once
* this current element has been bound to the variable (you can
* exit prematurely with a traditional <b>break</b>). Sample use
* :
\code
Cell* cell = ...; // we get the cell
if (cell) {
for_each(Net*, net, cellGetExternalNets()) {
assert(netIsExternal());
assert(netGetCell() == cell);
end_for;
}
}
\endcode
* On this example the call to <b>cell-\>GetExternalNets()</b>
* returns the collection of all external nets of the cell. Here
* the loop does some consistency checks on each net. As we will
* see later on there exist macros for each type of object which
* might be an element of a collection. Therefore the following
* sequence is equivalent to the previous one:
\code
Cell* cell = ...; // we get the cell
if (cell) {
for_each_net(net, cellGetExternalNets()) {
assert(netIsExternal());
assert(netGetCell() == cell);
end_for;
}
}
\endcode
*/
// \}
/*! \name Collection Functions
*/
// \{
// \}
/* \name Others
*/
// \{
/* \function void Collection::Fill(list<Type>& list) const;
* No description.
*/
/* \function void Collection::Fill(vector<Type>& vector) const;
* No description.
*/
/* \function void Collection::Fill(set<Type, Comparator = less<Type>>& set) const;
* Those three functions allow to fill a STL container with the
* identified elements of a collection.
*/
// \}
}

421
hurricane/doc/hurricane/Command.dox Normal file
View File

@ -0,0 +1,421 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Command
* \brief Command description (\b API)
*
* \section secCommandIntro Introduction
*
* A command is an object which models the behaviour to be
* obtained in reaction to mouse or keyboard events within a
* view.
*
* In order to better understand the interaction between the
* view and the command we will study, at the end of this
* chapter, a specific and useful command : the zoom.
*
* Let us notice first that, in order to be active in a given
* view, a command must be installed within this view. Notice
* also that a command can be installed within many views.
* Therefore when a new type of command is needed only one
* instance has to be created, so we avoid dealing with
* allocation and deletion issues.
*
* Notice also that a view may have many commands installed :
* the first bound to the left mouse button (the zoom for
* instance) and a second one on the middle button (the
* selection command for instance). The right button is, in
* principle, reserved to a contextual pop-up menu, but could
* also be used to bind a third command.
*
* A command is associated to a mouse button and has a name.
* This name may be usefull within the graphic interface for
* informing the user about the currently installed command.
*
* A command being a data base object properties can be attached
* to it.
*
*
* \section secCommandInstallationAndUninstallation Installation and un-installation
*
* Please refer to theses functions :
* <ul>
* <li><b>Command::InstallOn</b>
* <li><b>Command::UninstallFrom</b>
* </ul>
*
*
* \section secCommandRemarks Remarks
*
* Commands are very powerful objects of which the zoom is a
* rudimentary embodiment. It is perfectly feasible, for
* instance, at click time to create a contact and display as a
* real drawing (not a ghost) and move this contact according to
* the mouse movements, always with a real display, and at last
* drop it in the right place when the button is released.
*
* Furthermore, commands manage perfectly the complex effects
* introduced by the auto-scroll and double buffering
* techniques, without having to worry about. On the same way it
* is perfectly possible, while the command is ongoing, to apply
* actions like zoom in, zoom out and pan, thanks to the
* available keyboard shortcuts (and even to spawn more complex
* actions). The system will manage all those contradictory
* events in an efficient and secure way (when an auto-scroll
* occurs, a part of the ghost may have been moved and it is
* worthwile that we don't need to care about, and still more,
* if a "zoom in" is being requested at the same time ...).
*
*
* \section secCommandImportant Important : Coordinates of Messages
*
* In those messages, the position, when provided, is in the
* client coordinate system of the view (and not in the screen
* pixel coordinates).
*
* But for obtaining the position in the cell coordinate system,
* the inverse of the tranformation associated to the view must
* be applied to the point.
*
*
* \section secCommandCaseStudyTheZoom Case study : the Zoom
*
* Extracted from the file ZoomCommand.h
\code
class ZoomCommand : public Command {
// *******************************
// Types
// *****
public: typedef Command Inherit;
// Attributes
// **********
private: bool _started; // flag indicating that the zoom has started
private: Point _origin; // mouse position when zoom started
private: Point _extremity; // current mouse position
// Constructors
// ************
protected: ZoomCommand();
public: static ZoomCommand* Create();
// Destructor and message handlers
// *******************************
protected: virtual void _PreDelete();
public: virtual void _OnDrawGhost(View* view);
public: virtual void _OnMouseMove(View* view, const Point& position);
public: virtual void _OnButtonPress(View* view, const Point& position);
public: virtual void _OnButtonRelease(View* view, const Point& position);
// all those messages are not overloaded
};
// global function returning the zoom command object
ZoomCommand* GetZoomCommand();
\endcode
* Extracted from the file ZoomCommand.cpp
\code
static ZoomCommand* ZOOM_COMMAND = NULL;
ZoomCommand* GetZoomCommand()
// **************************
{
// global function which gets the zoom command
// or creates it when needed
if (!ZOOM_COMMAND) ZOOM_COMMAND = ZoomCommand::Create();
return ZOOM_COMMAND;
}
ZoomCommand::ZoomCommand()
// ***********************
: Inherit("Zoom", 1),
_started(false),
_origin(),
_extremity()
{
// the zoom command has name "Zoom" (as expected)
// and is bound to the left mouse button (button 1)
}
ZoomCommand* ZoomCommand::Create()
// *******************************
{
// A command being a data base object
// the classical Create function must be provided
ZoomCommand* zoomCommand = new ZoomCommand();
if (!zoomCommand)
throw Error("Can't create ZoomCommand : allocation failed");
zoomCommand_PostCreate();
return zoomCommand;
}
void ZoomCommand::_PreDelete()
// ***************************
{
// A command being a data base object
// a pre-delete function must be provided
// (the function of post-creation being not needed here)
Inherit::_PreDelete();
if (ZOOM_COMMAND == this) ZOOM_COMMAND = NULL;
}
void ZoomCommand::_OnDrawGhost(View* view)
// ***************************************
{
// The drawing of the ghost must appear only when the zoom starts
// it is a simple rubber rectangle between the start and current points
if (_started) viewDrawRectangle(_origin, _extremity);
}
void ZoomCommand::_OnMouseMove(View* view, const Point& position)
// **************************************************************
{
// when the mouse moves and the zoom has already started
if (_started) {
// the ghost drawing must be erased by calling the function
// viewDrawGhost(this) which prepares the graphic context
// and calls upon the message _OnDrawGhost(view)
// (don't call directly the message _OnDrawGhost of the command)
viewDrawGhost(this);
// then change the position
_extremity = position;
// and at last draw the new ghost (same method)
viewDrawGhost(this);
}
}
void ZoomCommand::_OnButtonPress(View* view, const Point& position)
// ****************************************************************
{
// When the user presses the button bound to the command
// we set-up different attributs to start a new zoom
// the starting and current point are the same
// the zomm is flagged as started
_origin = position;
_extremity = position;
_started = true;
// we draw the new ghost (same method)
viewDrawGhost(this);
}
void ZoomCommand::_OnButtonRelease(View* view, const Point& position)
// ******************************************************************
{
// we erase the ghost (same method)
viewDrawGhost(this);
// we flag the zoom as ended
_started = false;
// if the defined rectangle is meaningful we can trigger
// the reframe and the refresh of the view
if (_extremity != _origin) {
viewReframe(Box(_origin, _extremity));
viewRefresh();
}
}
\endcode
* The following piece of code shows now how to proceed for
* installing the zoom command on a given view
\code
View* view = ...; // we get the view
GetZoomCommand()InstallOn(view);
assert(GetZoomCommand()IsInstalledOn(view));
\endcode
*/
/*! \name Accessors
*/
// \{
/*! \function const Name& Command::GetName() const;
* \Return the command name.
*/
/*! \function unsigned Command::GetButton() const;
* \Return the command mouse button.
*/
/*! \function Views Command::GetViews() const;
* \Return the collection of views where this command is installed.
*/
// \}
/*! \name Predicates
*/
// \{
/*! \function bool Command::IsInstalledOn(View* view) const;
* \Return \true if the command is installed within the view, else
* \false.
*/
// \}
/*! \name Messages
*/
// \{
/*! \function void Command::_OnInstalledOn(View* view);
* Message called upon to inform the command that it has been
* installed in the view.
*/
/*! \function void Command::_OnUninstalledFrom(View* view);
* Message called upon to inform the command that it has been
* un-installed from the view.
*/
/*! \function void Command::_OnDrawGhost(View* view);
* Message called upon to inform the command that it has to draw
* its ghost.
*
* \important This message must not be called directly, even inside the
* following commands.
*
* Indeed, the view must prepare the graphic context in order to
* set up the appropriate display mode (i.e. xor). Therefore a
* request must be done to the view to call upon this message,
* once it has made the preliminary preparations, by writing
* view-\>DrawGhost(this).
*/
/*! \function void Command::_OnMouseEnter(View* view, const Point& position);
* Message called upon to inform the command that the mouse has
* entered the window associated to the drawing area.
*/
/*! \function void Command::_OnMouseMove(View* view, const Point& position, unsigned state);
* Message called upon to inform the command that the mouse has
* just moved.
*
* \important This message is received whatever the command button is being
* pressed or not.
*/
/*! \function void Command::_OnMouseLeave(View* view, const Point& position);
* Message called upon to inform the command that the mouse has
* exited the window associated to the drawing area.
*/
/*! \function void Command::_OnButtonPress(View* view, const Point& position, unsigned state);
* Message called upon to inform the command that a mouse button
* has just been pressed.
*/
/*! \function void Command::_OnButtonRelease(View* view, const Point& position, unsigned state);
* Message called upon to inform the command that a mouse button
* has just been released.
*/
/* \function void Command::_OnKeyPress(View* view, unsigned key);
* Message called upon to inform the command that a key has just
* been pressed.
*/
/* \function void Command::_OnKeyRelease(View* view, unsigned key);
* Message called upon to inform the command that a key has just
* been released.
*/
// \}
/*! \name Command Collection
*/
// \{
/*! \typedef Commands
* Generic collection representing a set of commands.
*/
/*! \typedef CommandLocator
* Generic locator for traversing a collection of commands.
*/
/*! \typedef CommandFilter
* Filter for selecting a sub-set of commands matching some
* criteria.
*/
/*! \def for_each_command(command, commands)
* Macro for visiting all commands of a collection of commands.
*/
// \}
/* \name Installation/Uninstallation
*/
// \{
/*! \function void Command::InstallOn(View* view);
* Allows to install the command in the view.
*
* \caution An exception is thrown if the view is null.
*
* Does nothing if the command is already installed in the view.
* On the other hand, if a command bound to the same button was
* already installed in the view, this last is automatically
* un-installed.
*
* When the command is effectively installed in the view, in
* order to inform this command of its installation and let it
* handle possible additional processing, a message
* <b>_OnInstalledOn()</b> is issued by the view.
*/
/*! \function void Command::UninstallFrom(View* view);
* Allows to un-install the command in the view.
*
* \caution An exception is thrown if the view is null.
*
* In order to inform the command of its un-installation and let
* it handle possible additional processing, a message
* <b>_OnUnInstalledFrom()</b> is issued by the view.
*/
// \}
}

26
hurricane/doc/hurricane/Commons.dox Normal file
View File

@ -0,0 +1,26 @@
// -*- C++ -*-
namespace Hurricane {
/*! \addtogroup Generalities
* \{
*/
/*! \function string Demangle ( const char* symbol );
* Translate (demangle) a symbol from C++ (\c gnu-v3) internal format
* into a human readable \string.
*/
/*! \function string Demangle ( const type_info& info );
* \param info a type_info structure as returned by \c typeid().
*
* Translate (demangle) a symbol from C++ (\c gnu-v3) internal format
* into a human readable \string.
*/
// \}
}

230
hurricane/doc/hurricane/Component.dox Normal file
View File

@ -0,0 +1,230 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Component
* \brief Component description (\b API)
*
* \section secComponentIntro Introduction
*
* Components are the abstract objects representing the category
* of net components (segments, contacts, pads, plugs,...). Each
* component knows its net, its layer and has a "body".
*
*
* \section secComponentConceptOfLocation Concept of Location
*
* Some components (for instance the segments) bear on contacts
* or other segments, more precisely they bear an extremity (the
* origin or the extremity), possibly through an offset on other
* components. The real location of the concerned part is
* therefore relative to the location of the component on which
* this part bears.
*
* For that purpose each components must be able to return a
* location from which a relative calculations can be done. The
* methods <b>GetX()</b> and <b>GetY()</b> provide this
* information and must be overloaded for each sub-type of
* component in oder to get the desired effect.
*
*
* \remark The fact that a null value is systematically returned by one
* of this methods means that the locations are computed
* relative to a null value, which is equivalent to say they are
* absolute values (see for instance the Horizontal segment
* whose GetX() returns always null, while GetY() return the
* ordinate of its axis).
*
* \section secComponentDestruction Destruction
*
* When a component is destroyed, all components which are
* anchored on its body (through the body hook) are also
* destroyed. This may recursively propagate to other components
* anchored on the body of those last ones.
*
* Rings are reorganized such that the connectivity remains
* invariant.
*
*
* \section secComponentPredefinedFilters Predefined filters
*
* <b>Component::GetIsUnderFilter</b>
*/
/*! \typedef Component::Inherit
* Useful for calling upon methods of the base class without
* knowing it.
*/
/*! \class Component::BodyHook
* With the components, appears a new Hook type : The
* <b>BodyHook</b>, which represents the body of the component
* inside which it is nested (it is always a <b>"master"</b>
* hook).
*/
/*! \name Accessors
*/
// \{
/*! \function Net* Component::GetNet() const;
* \Return the net owning the component.
*/
/*! \function Rubber* Component::GetRubber() const;
* \Return the rubber associated to the component (may be NULL).
*/
/*! \function Net::BodyHook* Component::GetBodyHook();
* \Return the hook representing the component body.
*/
/*! \function Hooks Component::GetHooks() const;
* \Return the collection of component hooks, that is the collection of
* nested hooks within the component, each of them representing
* a part of the component.
*/
/*! \function Unit Component::GetX() const;
* \Return the abscissa of the component's body. This abscissa is a
* reference base for the components anchored, through an
* offset, on the component's body.
*/
/*! \function Unit Component::GetY() const;
* \Return the ordinate of the component's body. This ordinate is a
* reference base for the components anchored, through an
* offset, on the component's body.
*/
/*! \function Point Component::GetPosition() const;
* \Return the location of the component's body.
*
* This method returns, in principle, a point built from the two
* previous methods. As far as some similar calculations are
* done in both methods, it is wise to redefine the method as
* shown below for the Contact :
\code
Unit Contact::GetX() const
// ***********************
{
Component* anchor = GetAnchor();
return (!anchor) ? _dx : anchorGetX() + _dx;
}
Unit Contact::GetY() const
// ***********************
{
Component* anchor = GetAnchor();
return (!anchor) ? _dy : anchorGetY() + _dy;
}
Point Contact::GetPosition() const
// *******************************
{
Component* anchor = GetAnchor();
return (!anchor) ?
Point(_dx, _dy) :
anchorGetPosition().Translate(_dx, _dy);
}
\endcode
*
*
*
* Indeed, contacts can possibly bear on other components
* through an offset defined by two attributes _dx and _dy. In
* order to compute the abscissa of a contact the component on
* which it bears must be found. This component named the
* <b>anchor</b> is returned by the call to GetAnchor(). If the
* component has no anchor, its coordinates are considered as
* absolute and the attribute _dx gives directly its abscissa.
*
* The method GetAnchor() must loop through a ring in order to
* find the contact anchor. By overloading the function
* GetPosition(), only one loop will be needed. Furtermore we
* call directly anchor-\>GetPosition() and not both
* anchor-\>GetX() and anchor-\>GetY(), this will be faster
* (this anchor may be anchored itself on an other component).
*/
/*! \function Layer* Component::GetLayer() const;
* \Return the layer on which the component is located (may return NULL
* for some component types like the plugs).
*/
/*! \function Box Component::GetBoundingBox(BasicLayer* basicLayer) const;
* \Return the envelope of the component for the \c \<basicLayer\>, that
* is the smallest box enclosing all layout elements located on
* the specified basic layer.
*
* \Return an empty box for objects which are not physical layout ones
* (i.e. plugs) or for those which have no layout on the
* specified basic layer.
*/
/*! \function Components Component::GetSlaveComponents() const;
* \Return the collection of components whose existence depends directly
* or indirectly of the existence of the component \c \<this\>
* (a segment can't survive to the destruction of a contact on
* which it is anchored).
*/
/*! \function Components Component::GetConnexComponents() const;
* \Return the collection of "connex components" to the component
* \c \<this\> (which includes at least this one).
*
* \remark A componnent is said <b>connex</b> to an other one if it is
* attached directly or indirectly through hyper-hooks, that is
* if there exist a sequence of components whose parts
* (extremities or body) are either sharing the same anchor or
* anchored one upon the other.
*
* If the layout elements are correctly assembled and on the
* proper layers, this "connex components collection" represents
* an geometrically and electrically connected subset of layout
* elements
*
* On the other hand, if layout anchored objects don't overlap
* on the same conducting layers (either by a wrong contact
* layer or by an offset which forbids layout intersection)
* electrical continuity will not be ensured.
*/
/*! \function ComponentFilter Component::GetIsUnderFilter(const Box& area);
* \Return the filter allowing to select only components which intersect
* the rectangular \c \<area\>.
*/
// \}
/*! \name Component Collection
*/
// \{
/*! \typedef Components
* Generic collection representing a set of components.
*/
/*! \typedef ComponentLocator
* Generic locator for traversing a collection of components.
*/
/*! \typedef ComponentFilter
* Generic filter for selecting a subset of components matching
* some criteria.
*/
/*! \def for_each_component(component, components)
* Macro for visiting all components of a components collection.
*/
// \}
}

182
hurricane/doc/hurricane/CompositeLayer.dox Normal file
View File

@ -0,0 +1,182 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class CompositeLayer
* \brief CompositeLayer description (\b API)
*
* \section secCompositeLayerIntro Introduction
*
* Composite layers are an assembly of basic layers.
*
* Given a rectangular area filled with a composite layer we can
* determine, according to different geometrical parameters,
* which are the characteristics of the different pads filled
* with each basic layer building the composite layer. Those
* parameters are the following : ContactSize, SegmentSize,
* SegmentExtention and PadSize. They differ for each basic
* layer participating to a composite layer. Refer to the
* chapter ExpandRules in order to get more information on the
* meaning of those parameters.
*/
/*! \typedef CompositeLayer::Inherit
* Useful for calling upon methods of the base class without
* knowing it.
*/
/*! \class CompositeLayer::Type
* This enumeration defines the composite layer types. table:
* Composite Layer Types headers: Name Code Signification slots:
* UNDEFINED 0 Undefined type slots: METAL 4 Routing layer
* slots: VIA 5 Contact layer
*/
/*! \name Constructors
*/
// \{
/*! \function CompositeLayer* CompositeLayer::Create(Technology* technology,const Name& name,const CompositeLayer::Type& type,const Unit& minimalSize = 0,const Unit& minimalSpacing = 0);
* Creates and returns a new composite layer named \c \<name\>,
* of type \c \<type\> for the given technology (some
* geometrical characteristics can also be specified).
*
* \caution Throws an exception if the technology is null, if the name is
* empty or if a layer of same name already exists.
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function const CompositeLayer::Type& CompositeLayer::GetType() const;
* \Return the composite layer type.
*/
/*! \function Unit CompositeLayer::GetContactSize(BasicLayer* basicLayer) const;
* \Return the contact size associated to the basic layer
* \c \<basicLayer\> (0 if this basic layer doesn't pertains to
* composite one).
*/
/*! \function Unit CompositeLayer::GetSegmentSize(BasicLayer* basicLayer) const;
* \Return the segment size associated to the basic layer
* \c \<basicLayer\> (0 if this basic layer doesn't pertains to
* composite one).
*/
/*! \function Unit CompositeLayer::GetSegmentExtention(BasicLayer* basicLayer) const;
* \Return the segment extension associated to the basic layer
* \c \<basicLayer\> (0 if this basic layer doesn't pertains to
* composite one).
*/
/*! \function Unit CompositeLayer::GetPadSize(BasicLayer* basicLayer) const;
* \Return the pad size associated to the basic layer \c \<basicLayer\>
* (0 if this basic layer doesn't pertains to composite one).
*/
/*! \function const Unit& CompositeLayer::GetMaximalContactSize() const;
* \Return the maximum contact size for all the basic layers composing
* the composite layer.
*/
/*! \function const Unit& CompositeLayer::GetMaximalSegmentSize() const;
* \Return the maximum segment size for all the basic layers composing
* the composite layer.
*/
/*! \function const Unit& CompositeLayer::GetMaximalSegmentExtention() const;
* \Return the maximum segment extension for all the basic layers
* composing the composite layer.
*/
/*! \function const Unit& CompositeLayer::GetMaximalPadSize() const;
* \Return the maximum pad size for all the basic layers composing the
* composite layer.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function void CompositeLayer::Add(BasicLayer* basicLayer,const Unit& contactSize,const Unit& segmentSize,const Unit& segmentExtention,const Unit& padSize);
* Adds the basic layer with associated characteristics
* specified by the other arguments.
*
* \caution Throws an exception if the basic layer is null or already
* present in the composite layer.
*
* Usage example :
\code
DataBase* dataBase = GetDataBase();
Technology* technology = dataBaseGetTechnology();
CompositeLayer* metal2 = technologyGetCompositeLayer("metal2"):
Unit contactSize = GetUnit(0.5);
Unit segmentSize = GetUnit(1.0);
Unit segmentExtention = GetUnit(1.3);
Unit padSize = GetUnit(0);
BasicLayer* CM2 = technologyGetBasicLayer("CM2");
metal2Add(CM2, contactSize, segmentSize, segmentExtention, padSize);
assert(metal2GetContactSize(CM2) == contactSize);
assert(metal2GetSegmentSize(CM2) == segmentSize);
assert(metal2GetSegmentExtention(CM2) == segmentExtention);
assert(metal2GetPadSize(CM2) == padSize);
\endcode
*
*
*/
/*! \function void CompositeLayer::Remove(BasicLayer* basicLayer);
* Removes the basic layer from the composite layer.
*
* \caution Throws an exception if the basic layer is null or it doesn't
* pertain to the composite layer.
*/
// \}
/*! \name CompositeLayer Collection
*/
// \{
/*! \typedef CompositeLayers
* Generic collection representing a set of composite layers.
*/
/*! \typedef CompositeLayerLocator
* Generic locator for traversing a collection of composite
* layers.
*/
/*! \typedef CompositeLayerFilter
* Generic filter allowing to select a subset of composite
* layers matching some criteria.
*/
/*! \def for_each_composite_layer(compositeLayer, compositeLayers)
* Macro for visiting all the composite layers of a collection
* of composite layers.
*/
// \}
}

212
hurricane/doc/hurricane/Contact.dox Normal file
View File

@ -0,0 +1,212 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Contact
* \brief Contact description (\b API)
*
* \section secContactIntro Introduction
*
* Contacts are objects representing contact points within a
* net. A contact may have a null size, be a single layer
* contact or a multi-layer contact (i.e. a VIA).
*/
/*! \typedef Contact::Inherit
* Useful for calling upon methods of the base class without
* knowing it.
*/
/*! \class Contact::AnchorHook
* With contacts, a new type of Hook appears : the
* <b>AnchorHook</b>, which allows to attach a contact upon an
* other component, on which it is said to be "anchored". It
* becomes then a "relative contact" with respect of the
* coordinates of this component. The AnchorHook is always a
* slave hook.
*
*
* \remark A contact has two attributes \c \<Dx\> and \c \<Dy\> which
* represent the relative coordinates of the contact with
* respect to the coordinates of the component on which it is
* anchored (through this AnchorHook). When it is not anchored,
* those coordinates becomes relative to the origin of the cell,
* which means they are absolute.
*/
/*! \name Constructors
*/
// \{
/*! \function Contact* Contact::Create(Net* net, Layer* layer, const Unit& x, const Unit& y,const Unit& width = 0, const Unit& height = 0);
* Creates and returns a new contact belonging to the net
* \c \<net\>, on the layer \c \<layer\>, of size \c \<width\>
* and \c \<height\> and located at the absolute coordinates
* \c \<x\> and \c \<y\>.
*
* \caution Throws an exception if the layer or the net is null.
*/
/*! \function Contact* Contact::Create(Component* anchor, Layer* layer, const Unit& dx, const Unit& dy,const Unit& width = 0, const Unit& height = 0);
* Creates and returns a new contact on the layer \c \<layer\>,
* of size \c \<width\> and \c \<height\> attached upon the
* component \c \<anchor\> through an offset defined by
* \c \<dx\> et \c \<dy\>.
*
* \caution Throws an exception if the layer or the anchor is null or if
* the anchor is an unconnected plug.
*
* \remark The new contact belongs to the anchor's net.
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function Contact::AnchorHook* Contact::GetAnchorHook();
* \Return the hook through which the contact can be attached upon an
* anchor.
*/
/*! \function Component* Contact::GetAnchor() const;
* The anchor hook of the contact being a slave one, it may have
* a master hook representing the body of the anchor on which it
* is attached. This method returns the owner of this master
* hook if it exists else NULL (either the contact is an
* absolute one (its anchor hook is not inserted in a ring) or
* this ring doesn't contain a master hook (lowly probable,
* transitory)).
*/
/*! \function const Unit& Contact::GetDx() const;
* \Return the relative abscissa of the contact.
*
* \remark If you want to get the absolute one use the member function
* GetX() defined at the Component level.
*/
/*! \function const Unit& Contact::GetDy() const;
* \Return the relative ordinate of the contact.
*
* \remark If you want to get the absolute one use the member function
* GetY() defined at the Component level.
*/
/*! \function const Unit& Contact::GetWidth() const;
* \Return the contact width.
*/
/*! \function Unit Contact::GetHalfWidth() const;
* \Return the contact half width.
*/
/*! \function const Unit& Contact::GetHeight() const;
* \Return the contact height.
*/
/*! \function Unit Contact::GetHalfHeight() const;
* \Return the contact half height.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function void Contact::SetLayer(Layer* layer);
* Sets the contact layer.
*/
/*! \function void Contact::SetWidth(const Unit& width);
* Sets the contact width.
*/
/*! \function void Contact::SetHeight(const Unit& height);
* Sets the contact height.
*/
/*! \function void Contact::SetSizes(const Unit& width, const Unit& height);
* Sets both contact width and height.
*/
/*! \function void Contact::SetX(const Unit& x);
* Allows to change the absolute abscissa of the contact (if it
* has a location relative to an other component, only relative
* position to this last is accordingly changed).
*/
/*! \function void Contact::SetY(const Unit& y);
* Allows to change the absolute ordinate of the contact (if it
* has a location relative to an other component, only relative
* position to this last is accordingly changed).
*/
/*! \function void Contact::SetPosition(const Unit& x, const Unit& y);
* No description.
*/
/*! \function void Contact::SetPosition(const Point& position);
* Allows to change the absolute location of the contact (if it
* has a location relative to an other component, only relative
* position to this last is accordingly changed).
*/
/*! \function void Contact::SetDx(const Unit& dx);
* Allows to change the horizontal offset of the contact.
*
* \remark If the contact is absolute, this amounts to change its
* absolute abscissa.
*/
/*! \function void Contact::SetDy(const Unit& dy);
* Allows to change the vertical offset of the contact.
*
* \remark If the contact is absolute, this amounts to change its
* absolute ordinate.
*/
/*! \function void Contact::SetOffset(const Unit& dx, const Unit& dy);
* Allows to change the offset of the contact.
*
* \remark If the contact is absolute, this amounts to change its
* absolute location.
*/
// \}
/*! \name Contact Collection
*/
// \{
/*! \typedef Contacts
* Generic collection representing a set of contacts.
*/
/*! \typedef ContactLocator
* Generic locator for traversing a collection of contacts.
*/
/*! \typedef ContactFilter
* Generic filter allowing to select a subset of contacts
* matching some criteria.
*/
/*! \def for_each_contact(contact, contacts)
* Macro for visiting all the contacts of a collection of
* contacts.
*/
// \}
}

371
hurricane/doc/hurricane/DBo.dox Normal file
View File

@ -0,0 +1,371 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class DBo
* \brief DataBase object root class (\b API).
*
* \section sDBoIntro Introduction
*
* All data base objects must be created explicitely by using
* the provided creation functions and not by calling directly
* the new operator (which anyway is not provided).
*
* On the same way, they must not be deleted with the delete
* operator but by calling the destruction function described
* below.
*
* Those objects can't, either, be duplicated : the copy
* constructor and the assignment operator are not available.
*
* Properties can be attached to those objects (the principles
* driving the properties management are detailed in the
* Property class).
*
* \section sDBoCreation Creation process
*
* The data base objects are strongly linked between them and
* some relations can't be set-up by the constructors themselves
* but must be established a posteriori. <b>Those objects must
* therefore be built by special functions which take care of
* that obscure work</b>.
*
* Indeed, let us imagine a <b>Go</b> type representing the
* category of graphic objects and two sub-classes
* <b>Rectangle</b> and <b>Line</b> having specific geometric
* attributes. For eficiency reasons those <b>Go</b> are stored
* in a fast access geometric data structure like a
* <b>QuadTree</b>. It would be ideal that the insertion of the
* <b>Go</b> within its <b>QuadTree</b> be automatic. This could
* be done in the <b>Go</b> constructor for instance. But, when
* this constructor is called upon (by the constructor of
* sub-classes) it is impossible to determine the bounding box
* of the object because all geometric characteristics are not
* yet assigned (making the insertion unfeasible).
*
* A possible solution would be to do nothing within the
* <b>Go</b> constructor and let the work be done by the
* sub-classes constructors wich could call upon the right
* insertion function. This solution is neither smart nor
* consistent because an omission can happen. If a sub-type of
* <b>Line</b> is created, the insertion being already done in
* the <b>Line</b> constructor, it must not be re-done for the
* derived class. Conversely if a new type of <b>Go</b> is
* created, insertion processing must not be forgotten. Code
* omissions or duplications are bound to happen and the code is
* not homogeneous.
*
* Therefore this insertion must be realized by the <b>Go</b>,
* but a posteriori, that is once the object has been fully
* built. In order to realize such an operation it must, once
* all derived classes constructors have been called, call upon
* a function <b>_PostCreate</b> which realizes the additional
* work and then return the pointer on the new objects (let us
* recall that all member functions which must not be called
* directly are prefixed by an underscore).
*
* This process in two steps is realized by the <b>Create</b>
* function which is provided for each type of instanciable
* object. The following example shows its implementation for a
* net :
* \code
Net* Net::Create(Cell* cell, const Name&amp; name)
// *******************************************
{
Net* net = new Net(cell, name);
if (!net)
throw Error("Can't create Net : allocation failed");
net->_PostCreate();
return net;
}
\endcode
*
* Within this function, the net is created in a first time
* thanks to the constructor spawn by the new operator. If
* everything goes right the function <b>_PostCreate</b> is
* called upon the net. This one realizes the additional
* operations that the constructor couldn't realize and then
* calls the functions <b>_PostCreate</b> upon the base
* classe. If everything goes right the net is returned, else an
* exception is thrown if something abnormal or illegal occurs
* (i.e. a net with the same name already exists). For the
* example of a <b>Line</b> : the different called constructors
* will fully characterize the line, then the <b>_PostCreate</b>
* method on a line will do nothing else than call upon the
* <b>_PostCreate</b> method of the <b>go</b> which will insert
* the line within the <b>QuadTree</b> (this is now feasible,
* the line geometry being fully characterized).
*
* \section sDBoDelete Deletion process
*
* <b>The Delete() member function :</b>
*
* Data base ojects can be destroyed only by calling upon this
* function and not by calling the C++ standard destructor
* (which indeed is not provided).
*
* A process similar but opposite to the creation process is
* required. A function <b>_PreDelete</b> must be called upon
* before the effective object destruction. As a matter of fact,
* if we take again the case of the <b>Line</b> for example, the
* line must be removed from the <b>QuadTree</b> before the
* destruction of its geometric characteristics (inverse of the
* previous phenomenon). Therefore the Delete function is
* implemented that way :
* \code
void DBo::Delete()
// ***************
{
_PreDelete();
delete *this;
}
* \endcode
*
* \section sDBoExtentions Extentions
*
* For any new sub-type of DBo you must adhere to the same
* protocol. That is provide the methods _PostCreate and
* _PreDelete calling the methods _PostCreate and _PreDelete of
* their base class. Furthermore you must provide when this
* class is instantiable a creation function (caution : only the
* creation function, if any, must be \public (and \static) the
* others must be \protected).
*
* Extracted from the .h of a new type of cell.
* \code
class MyCell : public Cell {
// ***********************
// Types
// *****
public: typedef Cell Inherit;
// Construction
// ************
protected: MyCell(Library* library, const Name&amp; name);
public: static MyCell* Create(Library* library, const Name&amp; name);
// Others
// ******
protected: virtual void _PostCreate();
protected: virtual void _PreDelete();
};
* \endcode
* Extracted from the .cpp for this new type of cell.
* \code
MyCell::MyCell(Library* library, const Name&amp; name)
// ***********************************************
: Inherit(library, name)
{
}
MyCell* MyCell::Create(Library* library, const Name&amp; name)
// *******************************************************
{
MyCell* myCell = new MyCell(library, name);
if (!myCell)
throw Error("Can't create MyCell : allocation failed");
myCell->_PostCreate(); // must not be forgotten!
return myCell;
}
void MyCell::_PostCreate()
// ***********************
{
// complete here the post creation
Inherit::_PostCreate(); // must not be forgotten!
// posibly do something here
}
void MyCell::_PreDelete()
// **********************
{
// posibly do something here
Inherit::_PreDelete(); // must not be forgotten!
// complete here the pre deletion
}
* \endcode
*
* \remark The destructor, strictly speaking, is not defined because
* necessary operations are done within the method
* <b>_PreDelete</b>.
* In the implementation of the class <b>MyCell</b> we have only
* used the type <b>Inherit</b> (and never <b>Cell</b>). This opens
* the door to hierarchy changes without affecting the code already
* written.
*
* \section sDBoRemark Remark
*
* The construction and deletion process of property objects is the
* same. It is mandatory for any new type of property to adopt the
* same protocol.
*
*/
/*! \function void DBo::Delete ();
*
* The legal method to delete any DBo object (see \ref sDBoDelete).
*/
/*! \name Accessors
*/
// \{
/*! \function Property* DBo::GetProperty ( const Name& name ) const;
* \param name Name of the Property to return.
* \return The property of Name \e name attached to the object, if it exists, else \NULL.
*
* \remark When writting what follows :
* \code
for_each_dbo(dbo, dbos) {
Property* property = dbo->GetProperty("width");
if (property) {
// do something
}
end_for;
}
* \endcode
*
* There is construction of a name (from a character string) for
* each visited dbo in order to find the property. It's more
* efficient to write :
* \code
Name width = "width";
for_each_dbo(dbo, dbos) {
Property* property = dbo->GetProperty(width);
if (property) {
// do something
}
end_for;
}
* \endcode
* Or still better :
* \code
static Name WIDTH = "width";
for_each_dbo(dbo, dbos) {
Property* property = dbo->GetProperty(WIDTH);
if (property) {
// do something
}
end_for;
}
* \endcode
* This remark applies each time you handle names.
*/
/*! \function Propertes DBo::GetProperties () const;
* \return The property Collection associated to the object (possibly empty).
*/
// \}
/*! \name Predicates
*/
// \{
/*! \function bool DBo::HasProperty () const;
* \return \true if the object has at least a property, else \false.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function void DBo::Put ( Property* property );
*
* Adds the Property \e property to the set of object
* properties. Properties being named, if an other one already
* exists in the set, with the same name, this last will be in a
* first step removed from the set.
*
* \remark Does nothing if the Property object is already attached to the
* object.
*
* \caution An exception is thrown if the Property pointer is \NULL.
*/
/*! \function void DBo::Remove ( Property* property );
* Removes the property \e property from the set of object properties.
*
* \remark Does nothing if the Property object is not attached to the object.
*
* \caution An exception is thrown if the Property pointer is \NULL.
*/
/*! \function void DBo::RemoveProperty ( const Name& name );
* Removes the property of name \e name if it exists.
*/
/*! \function void DBo::ClearProperties ();
* Removes all properties attached to this object.
*/
// \}
/*! \name DBo Collection
*/
// \{
/*! \typedef typedef GenericCollection<DBo*> DBos;
* Generic collection representing a set of data base objects.
*/
/*! \typedef typedef GenericLocator<DBo*> DBoLocator;
* Generic locator for visiting a data base objects Collection.
*/
/*! \typedef typedef GenericFilter<DBo*> DBoFilter;
* Filter to selecting a subset of data base objects matching some criteria.
*/
/*! \def for_each_dbo(dbo,dbos)
* Macro for visiting all objects of a data base objects collection.
*/
// \}
}
/* \addtogroup GetStringFunctions
*/
// \{
/* \function string GetString ( const Hurricane::DBo& dbo );
* Convert any Hurricane::DBo object into a \string.
*/
/* \function inline ostream& operator<< ( ostream& o, const Hurricane::DBo& dbo );
* Print any Hurricane::DBo object into an output \stream.
*/
/* \function inline ostream& operator<< ( ostream& o, const Hurricane::DBo* dbo );
* Print any pointed Hurricane::DBo object into an output \stream.
*/
// \}

69
hurricane/doc/hurricane/DataBase.dox Normal file
View File

@ -0,0 +1,69 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class DataBase
* \brief The whole DataBase (\b API).
*
* The unique purpose of this object is to handle, at
* any time, directly or indirectly, the whole set of
* currently allocated objects of the data base.
*
* This is a singleton object, only one can exist at a
* given time.
*
* The data base must be created explicitely (it is
* possible to derive a sub-type with specific
* additional attributes, or use properties to store
* them).
*
* The Database object handles both the Technology
* and the root Library.
*
* \caution Destroying the DataBase object destroys all data base objects.
*/
/*! \name Constructors & Destructors
*/
// \{
/*! \function DataBase* DataBase::Create ();
* Creates and returns a pointer to a new DataBase.
*
* \caution An exception is thrown if a Database already exists.
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function Technology* DataBase::GetTechnology () const;
* \return the Technology if it exists, else \NULL.
*/
/*! \function Technology* DataBase::GetRootLibrary () const;
* \return the root Library if it exists, else \NULL.
*/
// \}
/*! \addtogroup Generalities
* \{
*/
/*! \function DataBase* GetDataBase ();
* This global generic function returns the current
* DataBase, if it has been created and not destroyed,
* else \NULL.
*/
// \}
}

10
hurricane/doc/hurricane/Editor.dox Normal file
View File

@ -0,0 +1,10 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Editor
* \brief Editor description (\b API)
*
}

62
hurricane/doc/hurricane/Entity.dox Normal file
View File

@ -0,0 +1,62 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Entity
* \brief Occurrenceable objects root class (\b API).
*
* \section sEntityIntro Introduction
*
* Entities are abstract objects representing the category of
* occurrenceable objects.
*/
/*! \name Accessors
*/
// \{
/*! \function Cell* Entity::GetCell () const;
* \return Returns the cell owning this entity (when the Entity is a Cell,
* the Cell itself is returned)
*/
/*! \function Box Entity::GetBoundingBox () const;
* \return Returns the bounding box of the entity. It is defined as the
* smallest box enclosing the entity or its constituents.
*
* \remark For the Plugs, which are not objects of the physical layout,
* the returned envelope is a Box of null dimensions (ponctual)
* centered on the location of the master Net of the Plug, to
* which has been applied the transformation associated to the
* Instance of the Plug.
*/
// \}
/*! \name Entity Collection
*/
// \{
/*! \typedef typedef GenericCollection<Entity*> Entities;
* Generic collection representing a set of data base objects.
*/
/*! \typedef typedef GenericLocator<Entity*> EntityLocator;
* Generic locator for visiting a data base objects Collection.
*/
/*! \typedef typedef GenericFilter<Entity*> EntityFilter;
* Filter to selecting a subset of data base objects matching some criteria.
*/
/*! \def for_each_entity(entity,entities)
* Macro for visiting all objects of a data base objects collection.
*/
// \}
}

108
hurricane/doc/hurricane/Error.dox Normal file
View File

@ -0,0 +1,108 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Error
* \brief Error description (\b API)
*
*
* \section secErrorPrintingFormat Printing format
*
* Errors are printed with different formats wether the
* error code is null or not : text: So the following code :
\code
try {
throw Error("Something strange");
}
catch {Exception& exception) {
cerr << exception << endl;
}
\endcode
* Will produce the message :
\code
[ERROR] Something strange
\endcode
* while the following code :
\code
try {
throw Error("Can't create Net : null cell", 3);
}
catch {Exception& exception) {
cerr << exception << endl;
}
\endcode
* Will produce the message :
\code
[ERROR:3] Can't create Net : null cell
\endcode
* You can always print something different as shown in
* the following code :
\code
try {
throw Error("Can't create Net : null cell", 3);
}
catch {Error& error) {
cerr << error.GetReason() << " (code " << error.GetCode() << ")" << endl;
}
catch {Exception& exception) {
cerr << exception << endl;
}
\endcode
* Which will produce the message :
\code
Can't create Net : null cell (code 3)
\endcode
*/
/*! \typedef Error::Inherit
* Useful for calling the base class methods without knowing
* this class.
*/
/*! \name Constructors
*/
// \{
/*! \function Error::Error(const string& reason, int code = 0);
* Builds an error characterized by a reason and an error code
* useful within a switch.
*/
/*! \function Error::Error(const Error& error);
* Copy constructor.
*/
// \}
/*! \name Operators
*/
// \{
/*! \function Error& Error::operator=(const Error& error);
* Assignment operator.
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function const string& Error::GetReason() const;
* \Return the reason for which the error was thrown.
*/
/*! \function int Error::GetCode() const;
* \Return the error code number.
*/
// \}
}

41
hurricane/doc/hurricane/Exception.dox Normal file
View File

@ -0,0 +1,41 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Exception
* \brief Exception description (\b API)
*
* \section secExceptionIntro Introduction
*
* The Exception class groups all exceptions thrown by functions
* from the API. This virtual class is only useful to catch
* exceptions originating from one of those functions.
*/
/*! \section secExceptionExample Example
*
\code
try {
// do something
}
catch (Exception& exception) {
// Go through here if the exception comes from a function of the API
cerr << exception << endl;
exit(1);
}
catch (...) {
// Go through here for all other system exceptions
cerr << Error("abnormal termination") << endl;
// We use the Error() in order to get the same kind of printing
exit(2);
}
\endcode
*/
}

10
hurricane/doc/hurricane/ExpandRules.dox Normal file
View File

@ -0,0 +1,10 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class ExpandRules
* \brief ExpandRules description (\b API)
*
}

208
hurricane/doc/hurricane/Filter.dox Normal file
View File

@ -0,0 +1,208 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Filter
* \brief Filter description (\b API)
*
* \section secFilterIntro Introduction
*
* A filter is a functional object which, used in conjunction
* with a collection, allows to get only the elements of this
* collection which meet some criteria.
*
* This class is an abstract class which must be derived in
* order to get the appropriate behaviour.
*
* You will have also to define the default constructor, the
* copy constructor, the assignment operator and overload the
* two following member functions :
*/
/*! \name Accessors
*/
// \{
/*! \function Filter<Type>* Filter::GetClone() const;
* \Return a filter copy.
*/
// \}
/*! \name Predicates
*/
// \{
/*! \function bool Filter::Accept(Type element) const;
* This member function returns \true if the filter accepts the
* element else \false.
*/
// \}
/*! \name Operators
*/
// \{
/*! \function GenericFilter<Type> Filter::operator ! () const;
* \Return the inverse filter of the filter \c \<this\> (accepted
* elements are those rejected and conversely).
*/
// \}
/*! \section secFilterSimpleExample Simple example
*
* Definition of the filter selecting external nets of a cell :
\code
class IsExternal : public Filter<Net*> {
// ***********************************
public:
IsExternal() {};
IsExternal(const IsExternal& isExternal) {};
IsExternal& operator=(const IsExternal& isExternal) {return *this;};
virtual Filter<Net*>* GetClone() const {return new IsExternal(*this);};
virtual bool Accept(Net* net) const {return netIsExternal();};
};
\endcode
* Implementation of the accessor <b>GetExternalNets</b> for the
* cells :
\code
Nets Cell::GetExternalNet() const
// ******************************
{
return GetNets().GetSubSet(IsExternal());
}
\endcode
* Similarly, the accessor <b>GetInternalNets</b> can be
* implemented using the <b>!</b> operator :
\code
Nets Cell::GetInternalNets() const
// *******************************
{
return GetNets().GetSubSet(!IsExternal());
}
\endcode
*/
/*! \section secFilterComplexExample Complex example
*
* In order to implement previous examples we could have used
* filter with a simpler interface. Now the filters as they are
* defined open the door to much more complex processing.
*
* As a matter of fact the function <b>Accept</b> receives only
* one argument which represents the element of the collection
* to be accepted or rejected.
*
* Sometimes the filter must take into account other criteria.
* For example to print the external nets of a cell whose name
* start with a given character. Those additional criteria will
* then become attributes of the filter as shown in the
* following example :
*
* Filter definition :
\code
class MyFilter : public Filter<Net*> {
// *********************************
public:
char _c;
MyFilter(char c) : _c(c) {};
MyFilter(const MyFilter& myFilter) : _c(myFilter._c) {};
MyFilter& operator=(const MyFilter& myFilter)
{
_c = myFilter._c;
return *this;
};
virtual Filter<Net*>* GetClone() const {return new MyFilter(*this);};
virtual bool Accept(Net* net) const
{
return netIsExternal() && (netGetName()[0] == _c);
};
};
\endcode
* Afterwards do
\code
for_each_net(net, cellGetNets().GetSubSet(MyFilter('k'))) {
assert(net->IsExternal());
assert(net->GetName()[0] == 'k');
cerr << "net: " << net << endl;
end_for;
}
\endcode
* Although this example is not of great interest, it
* illustrates the way to proceed to create a complex filter.
*/
/*! \section secFilterRemarks Remarks
*
* It is wise to use filters only when it is trully necessary,
* that is to produce useful collections to be used extensively.
*
* Indeed, for the previous example, preferably write it like
* this :
\code
for_each_net(net, cellGetNets()) {
if (netIsExternal() && (net->GetName()[0] == 'k'))
cerr << "net: " << net << endl;
end_for;
}
\endcode
* or more simply :
\code
for_each_net(net, cellGetExternalNets()) {
if (net->GetName()[0] == 'k')
cerr << "net: " << net << endl;
end_for;
}
\endcode
* Filters are objects like any other : they can be passed as
* function arguments as shown below :
\code
Nets Cell::GetNets(const GenericFilter<Net*>& filter) const
// ********************************************************
{
return GetNets().GetSubSet(filter);
}
\endcode
* As far as the type <b>NetFilter</b> is defined as being a
* <b>GenericFilter\<Net*\></b> the previous function can be
* written like this :
\code
Nets Cell::GetNets(const NetFilter& filter) const
// **********************************************
{
return GetNets().GetSubSet(filter);
}
\endcode
*/
}

191
hurricane/doc/hurricane/Generalities.dox Normal file
View File

@ -0,0 +1,191 @@
// -*- C++ -*-
namespace Hurricane {
/*! \defgroup Generalities Generalities
*
* \section secGeneralitiesIntro Introduction
*
* When documenting a given class, only member functions
* introducted by this class are documented, inherited ones are
* not repeated. This is made easier by the presence of the
* inheritance sub-tree containing the described object type.
*
* In the same way, some opetators or global functions are
* defined for all object types though they don't derive from a
* common base class. Those operators and generic functions will
* be described below.
*
* terminology In the following, we will describe operators and
* functions applying to objects of different types. Therefore
* we will name "Object" any of those types.
*
*
* \section secGeneralitiesNammingConventions Namming conventions
*
* The name of "C macros" are written with lower case letters
* and underscores (examples : <b>is_a</b>, <b>for_each_cell</b>
* or <b>end_for</b>) while the name of generic functions and
* member functions never use the underscore and always start
* with an Upper case letter (examples : <b>GetUnit</b>,
* <b>GetMasterCell</b>, <b>IsCalledBy</b>).
*
* \remark When examining \c .h include files for more detailed information
* you will find member functions which start with an
* underscore. <b>While being "public" those functions must
* never be called upon</b>. In principle, only here'after
* documented functions should be used by the application
* programmer.
*
*
* \section secGeneralitiesGetString GetString
*
\code
string GetString(const Object& object);
string GetString(const Object* object);
\endcode
* Thoses generic function allows you to get into a string an
* explicit description of any kind of Hurricane object pointer
* or reference.
\code
ostream& operator<< (ostream& stream, const Object& object);
ostream& operator<< (ostream& stream, const Object* object);
\endcode
* All Hurricane objects have printing operators for a reference
* or a pointer. Those printing operators use the generic
* function Hurricane::GetString() previously studied.
*
*
* \section secGeneralitiesPredicates Predicates
*
* The \c bool \c is_a<Type*>(object) function.
*
* For any kind of Hurricane object pertaining to a
* class with at least one "virtual" member, it is
* possible to determine if this object is a type or a
* sub-type of \c \<type\> as shown in the following
* example:
\code
DataBase* dataBase = GetDataBase();
Library* library = Library::Create(dataBase, "std");
Cell* cell = Cell::Create(library, "nand");
if (is_a<Cell*>(cell)) {
// will inevitably go through here
}
if (is_a<Entity*>(cell)) {
// will go through here also because Cell derives from Entity
}
if (is_a<Library*>(cell)) {
// will never go through here because Cell doesn't derive from Library
}
\endcode
*
*
* \section secGeneralitiesInheritance Inheritance
*
* All classes deriving directly from a base class define a new
* type named <b>Inherit</b> which represents this base class.
* <b>This one is unique because Hurricane doesn't use multiple
* inheritance</b>. This type is important because it allows to
* call upon the methods of the base class without knowing its
* name as shown in the following example:
\code
void MyObject::Draw() const
// ************************
{
Inherit::Draw();
DrawParticularities();
}
\endcode
*
*
* \section secGeneralitiesTraceUtilities Trace utilities
*
* The library provides some usefull utilities for generating
* trace printings with a natural indentation allowing better
* understanding of the processing sequences:
*
* <ul>
* <li><b>Hurricane::in_trace</b>
* <li><b>Hurricane::trace_on</b>
* <li><b>Hurricane::trace_off</b>
* <li><b>Hurricane::trace_in</b>
* <li><b>Hurricane::trace_out</b>
* <li><b>Hurricane::trace</b>
* </ul>
*
*
\code
void MyFunction(MyData* data)
// **************************
{
trace << "entering in MyFunction with " << data << endl;
trace_in();
...
trace << "exiting of MyFunction" << endl;
trace_out();
}
\endcode
* \remark Debugger enthousiastic users will probably ignore this trace
* capability which presents the annoying need to be inserted
* into the code... For myself, I do prefer those facilities...
*
*
* \section secGeneralitiesRemarks Remarks
*
* Many other global and generic functions exist. Each one will
* be studied within the description of the classes which create
* or specialize them (example: <b>Hurricane::GetUnit</b> will be
* introduced with the Unit class and <b>Hurricane::GetCollection</b> with
* the Collection class).
*/
/*! \addtogroup Generalities
*/
// \{
/*! \function bool in_trace();
* The trace being optional, this function informs wether the
* trace is active or not. This allows if necessary to execute
* additional operations.
*/
/*! \function void trace_on();
* Activates the trace.
*/
/*! \function void trace_off();
* Suspends the trace.
*/
/*! \function void trace_in();
* Allows to enter a new trace block. This appears visually by
* adding an identation level to the trace printing.
*/
/*! \function void trace_out();
* Allows to leave the current trace block. This decreases the
* level of indentation of the trace print.
*/
/*! \def trace
* To be used like a <b>cerr</b> or
* a <b>cout</b> but the trace printing will be effective and
* indented only when the trace is active.
*/
// \}
}

210
hurricane/doc/hurricane/GenericCollection.dox Normal file
View File

@ -0,0 +1,210 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class GenericCollection
* \brief GenericCollection description (\b API)
*
* \section secGenericCollectionIntro Introduction
*
* Collections are powerful objects but share a common weakness.
* Indeed they don't allow to bring within a variable of type
* Collection\c \<Type\> a subset collection whose descriptor,
* of course, has additional attributes. For instance, the
* following sequence is rejected by the compiler
\code
Collection<Net*> nets = cellGetExternalNets();
\endcode
* You must therefore imperatively go through a pointer type
* variable by generating a clone and must not forget to delete
* this allocated clone after use.
\code
Collection<Net*>* nets = cellGetExternalNets().GetClone();
...
// use
...
delete nets; // we delete the collection, not the nets
\endcode
* Fortunately, the GenericCollection\c \<Type\> type solves
* this weakness. For this purpose, a generic collection creates
* at its construction (or by assignment) a clone of the given
* collection and releases, when deleted (or when assigned to an
* other collection), the previously allocated clone. Now it is
* feasible to bring into a variable of type
* GenericCollection\c \<Type\> any collection of type Type (as
* well as an other generic collection).
\code
GenericCollection<Net*> nets = cellGetExternalNets();
...
// use it
...
\endcode
* The variable \c \<nets\> being an automatic one, it will be
* automatically deleted (when leaving the scope the block where
* it was declared) carrying with it the clone allocated by the
* assignment.
*
* As far as all defined global collection types (Cells, Nets,
* Occurences, ...) are GenericCollections (the type Nets being
* defined by GenericCollection\<Net*\>), the previous sequence
* is still simpler and becomes:
\code
Nets nets = cellGetExternalNets();
...
// use
...
\endcode
* Furthermore a generic collection being able to get any other
* collection, provided it handles the same type of elements,
* you may well write:
\code
Nets nets;
nets = cellGetExternalNets();
...
// use
...
// and somewhere later, with the same variable
nets = cellGetNets();
...
// use
...
\endcode
*
*
* \section secGenericCollectionRemark Remark
*
* When writing the following code :
\code
Collection<Net*>* nets = cellGetExternalNets().GetClone();
...
// use
...
delete nets;
\endcode
* If an exception happens in the use phase, the nets variable
* will never be released. This is not critical in most cases,
* but may become dramatic in some other ones : notably within
* graphic display phases where frequent interruptions may
* occur.
*
* On the other hand, when writting:
\code
GenericCollection<Net*> nets = cellGetExternalNets();
...
// use
...
\endcode
* If an exception occurs within the usage phase, the nets
* variable will be deleted as well as the allocated clone.
*
*
* \section secGenericCollectionDestruction Destruction
*
* When the generic collection is deleted, the clone (if any) is
* then deleted.
*
*
* \section secGenericCollectionRemark Remark
*
* On the following example you can see an interesting effect.
* We get two different Nets objects which represent the same
* set of nets. Any modification on the elements of one set has
* immediate repercussion on the elements of the other.
\code
Cell* cell = ...; // we get a cell
if (cell) {
Nets nets1 = cellGetNets();
Nets nets2 = cellGetNets();
for_each_net(net, nets1) netDelete(); end_for;
assert(nets1.IsEmpty());
assert(nets2.IsEmpty());
}
\endcode
* Therefore we can get the set of all nets of a cell at program
* begining, this set will remain, even after many cell changes,
* the set of nets of that cell (as much as, of course, the cell
* is not destroyed).
*/
/*! \typedef GenericCollection::Inherit
* Useful for calling methods on the base class without knowing
* it.
*/
/*! \name Constructors
*/
// \{
/*! \function GenericCollection<Type>::GenericCollection();
* Default constructor : The generic collection is unbound and
* therefore empty.
*/
/*! \function GenericCollection<Type>::GenericCollection(const Collection<Type>& collection);
* Standard constructor: the generic collection is initialized
* with a clone of \c \<collection\> (which may be empty).
*/
/*! \function GenericCollection<Type>::GenericCollection(Collection<Type>* collection);
* Standard constructor: the generic collection is here directly
* initialized with the collection (pointer) and not with a
* clone of it.
*
* \important In consequence this collection will be automatically
* destroyed by the generic collection when time comes. This may
* be useful when some collection clone has been created and
* needs to be automatically deleted, allocating it to a generic
* collection which will manage that.
*
* \remark You can do that only once ... else you get in trouble.
*/
/*! \function GenericCollection<Type>::GenericCollection(const GenericCollection<Type>& genericCollection);
* Copy constructor: the generic collection is here initialized
* with a clone of genericCollection (which, here also, may be
* empty).
*/
// \}
/*! \name Operators
*/
// \{
/*! \function GenericCollection<Type>& GenericCollection::operator=(const Collection<Type>& collection);
* Assignment operator : if the generic collection was bound to
* a clone, this one is first deleted and then a new clone of
* \c \<collection\> is allocated (which will be deleted when
* time comes either by a new assignment or by the generic
* collection deletion).
*/
/*! \function GenericCollection<Type>& GenericCollection::operator=(Collection<Type>* collection);
* Assignment operator : The behaviour is identical to the
* standard assignment, but it's the \c \<collection\>
* collection itself which is bound to the generic collection
* and not a clone.
*
* \important This \<collection&gt will be automatically deleted when the
* time comes.
*
* \remark Here, again, you can do that only once ...
*/
// \}
}

26
hurricane/doc/hurricane/GenericFilter.dox Normal file
View File

@ -0,0 +1,26 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class GenericFilter
* \brief GenericFilter description (\b API)
*
* \section secGenericFilterIntro Introduction
*
* When creating a clone of a collection with a filter, a clone
* of the filter must be created. This clone of course must be
* released after its use.
*
* The generic filters are provided to take in charge the
* deletion of the different clones allocated. They work like
* generic collections and locators.
*
* As far as we don't need to know much more about them, we
* don't detail this class. Kwowing that they exist is enough.
*/
}

159
hurricane/doc/hurricane/GenericLocator.dox Normal file
View File

@ -0,0 +1,159 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class GenericLocator
* \brief GenericLocator description (\b API)
*
* \section secGenericLocatorIntro Introduction
*
* Locators are powerful objects but present a major weakness.
* You must handle them through a pointer variable and not
* forget to release the allocated locator after use.
\code
Locator<Net*>* locator = cellGetNets().GetLocator();
...
// use
...
delete locator;
\endcode
* Fortunately, the type GenericLocator\c \<Type\> corrects this
* weakness. Indeed a generic locator creates at its
* construction (or by assignment) a clone of the given locator
* and releases, when deleted (or when assigned to an other
* locator) the previously allocated one. More, when initialized
* with an already allocated locator, it takes in charge to
* release it. Therefore you only need to write:
\code
GenericLocator<Net*> locator = cellGetNets().GetLocator();
...
// use
...
\endcode
* \remark It's possible to bring within a GenericLocator\c \<Type\>
* variable any kind of locator of elements of the same Type
* (and also an other generic locator).
*/
/*! \section secGenericLocatorUsageExamples Usage examples
*
* Let's take the examples used in the Locator class and see
* what they become.
*
* The following example shows how to visit the nets of a given
* cell.
\code
Cell* cell = ...; // we get a cell
if (cell) {
GenericLocator<Net*> locator = CellGetNets().GetLocator();
while (locator.IsValid()) {
Net* net = locator.GetElement();
assert(netGetCell() == cell);
locator.Progress();
}
}
\endcode
* And this one, how to print all net pairs.
\code
Cell* cell = ...; // we get a cell
if (cell) {
GenericLocator<Net*> locator1 = CellGetNets().GetLocator();
while (locator1.IsValid()) {
Net* net1 = locator1.GetElement();
GenericLocator<Net*> locator2 = locator1;
// or GenericLocator<Net*> locator2 = locator1.GetClone();
while (locator2.IsValid()) {
Net* net2 = locator2.GetElement();
cerr << net1 << " " << net2 << endl;
locator2.Progress();
}
locator1Progress();
}
}
\endcode
* \remark Those examples are used here to describe generic locator
* behaviours. We will see later how code them in a much simpler
* way with the for_each macros.
*/
/*! \section secGenericLocatorHowWorksTheMacroFor_each How works the macro for_each
*
* When explaining Collection class we used some macros. We can
* now describe the way they are implemented.
*
* <b>Macro for_each implementation</b>
\code
#define for_each(Type, variable, collection)\
/*******************************************/\
{\
GenericLocator<Type> _locator = collection.GetLocator();\
while (_locator.IsValid()) {\
Type variable = _locator.GetElement();\
_locator.Progress();
\endcode
* This macro stores within a generic locator type variable the
* locator provided by the given collection. The remaining code
* is classic.
*
*
* \remark The locator allocated by the GetLocator() call is released by
* the destructor of the generic locator which, itself, will be
* called automatically because it is allocated within the
* execution stack.
*
* <b>Macro end_for implementation</b> This macro is mandatory
* in order to close the lexical blocks opened by the for_each
* macro.
\code
#define end_for\
/**************/\
}\
}
\endcode
* <b>Important observation</b> When you write the following :
\code
for_each(Net*, net, cellGetNets()) {
// body
end_for;
}
\endcode
* The body is processed between for_each and end_for macros,
* therefore after the binding of the variable to its element,
* but also once the locator has progressed. It is therefore
* possible to write, without risk the following :
\code
for_each(Net*, net, cellGetNets()) {
netDelete();
end_for;
}
\endcode
* Nevertheless you must take care in some cases. For instance
* you should not write :
\code
for_each(Component*, component, netGetComponents()) {
componentDelete();
end_for;
}
\endcode
* Because the deletion of a component might lead to the
* deletion of some related component, which could be the next
* one, where the locator is currently positionned. The locator
* becomes then invalid and the issue is fatal. It is cleaner to
* write :
\code
Components components = netGetComponents();
while (!components.IsEmpty()) components.GetFirst()Delete();
\endcode
*/
}

310
hurricane/doc/hurricane/Go.dox Normal file
View File

@ -0,0 +1,310 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Go
* \brief Go description (\b API)
*
* \section secGoIntro Introduction
*
* The Gos represent the category of graphical objects.
*
* They are stored in a fast geometric access data structure : a
* quadtree (let us recall that the organization of each
* quadtree depends essentially of the geometrical envelope of
* those objects and of their number).
*
*
* \section secGoMaterialization Materialization
*
* A graphical object can be materialized or not.
*
* A graphical object is said materialized when it is
* effectively inserted into a quadtree. It has then a graphical
* appearance (it's the least it can do) but also it will be
* taken into account within each collection which uses
* quadtrees in order to find its constituents (like the
* collection returned by the call
* cell-\>GetComponentsUnder(area) for instance).
*
* On the other hand, non materialized graphic objects will
* neither be visible nor taken into account by those
* collections. This may be a significant advantage in some
* situations and a great drawback in others.
*
* \remark <b>Plugs are never materialized</b>.
*
*
* \section secGoUpdateSessions Update sessions
*
* The location of an object within its quadtree depends of its
* bounding box, if a modification of this one must occur for
* any reason, the object must be removed from the quadtree
* before doing the modification and re-inserted after, at the
* right place, according to its new bounding box.
*
* Furthermore the change on an object may lead to changes on
* other ones. For instance the move of a contact will
* forcefully affect the components which are anchored on it,
* and so forth ...
*
* Furthermore it may be interesting to apply many modifications
* at the same time, avoiding so intermediate or useless
* multiple updates (many changes on the same object but also on
* different objects lying in different unrelated cells).
*
* type: In order to control this process we must operate in
* three steps
*
* Open an update session. Do all the needed modifications.
* Close the update session.
*
* type: Let us examine the following piece of code which
* illustrates that
\code
OpenUpdateSession();
contact->SetLayer(...);
contact->SetSizes(...);
contact->SetPosition(...);
CloseUpdateSession();
\endcode
* The call to the generic function <b>OpenUpdateSession()</b>
* allows to open a new update_session.
*
* The three following lines call upon functions which modify
* the contact and, for the last one, also the components which
* directly or indirectly bear on it.
*
* At last the call to the generic function
* <b>CloseUpdateSession()</b> allows to close the last update
* session currently open.
*
* type: What does really happen ?
*
* The update sesion is a shared property which is put at its
* creation on the top of a FIFO stack. The last update cession
* placed on the top of this stack represents the current
* session.
*
* When the object is modified : the method <b>Invalidate</b>
* which we will detail later is called upon. The purpose of
* this method is to de-materialize all materialized objects
* affected directly or indirectly by this modification and
* notify those objects to the current update session. Each of
* those objects then becomes an owner of this update session
* which is, let us recall it, a shared property.
*
* Finally, when the current update session is closed, it is
* simply unstacked and destroyed. While being destroyed, it
* materializes again the objects which are still attached to
* it, that is those which were de-materialized within the
* modification phase (and only those ones) and which were not
* destroyed in between (invaluable contribution of the shared
* property).
*
* \section secGoConstructionAndDestruction Construction and destruction
*
* Graphic objects are, by default, automatically materialized
* at their creation (unless the plugs which are never
* materialized) and forcefully de-materialized at their
* destruction.
*
* Nevertheless it is possible to inhibit temporarily the
* automatic materialization in some cases (like within the
* loading phase for instance) and to execute the
* materialization a posteriory and in a global way.This allows
* to avoid multiple updates of the quadtree.
*/
/*! \name Predicates
*/
// \{
/*! \function bool Go::AutoMaterializationIsDisabled();
* No description.
*/
/*! \function bool Go::IsMaterialized() const;
* No description.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function void Go::EnableAutoMaterialization();
* \see Go::DisableAutoMaterialization().
*/
/*! \function void Go::DisableAutoMaterialization();
* Those two static member functions allows to inhibit
* or restore the automatic materialization of all
* graphic objects.
*
* When the automatic materialization is inhibited,
* the postponed materialization of dematerialized
* objects has to be taken in charge explicitely by
* the developper (it will not be automatically done
* at the restore of the automatic mode).
*
* The following sample code shows how to proceed :
\code
Cell* LoadCellFromFile(...)
// ************************
{
Cell* cell = Cell::Create(...);
bool enabledFlag = ! AutoMaterializationIsDisabled();
DisableAutoMaterialization(); // we force the mode
... // we open the file and load the cell
if (enabledFlag) // we restore the initial state if needed
EnableAutoMaterialization();
cell->Materialize(); // delayed materialization of cell content
return cell;
}
\endcode
*/
/*! \function void Go::Materialize();
* No description.
*/
/*! \function void Go::Unmaterialize();
* No description.
*/
/*! \function void Go::Invalidate(bool propagateFlag = true);
* This method must be called before a change of the
* object geometry.
*
* It is within this function that the object captures
* or not the current update session, which involves
* its future re-materialization when the time commes.
*
* It is also within this function that all objects,
* whose geometry will be affected directly or
* indirectly by the object change, must be
* invalidated. The flag \c \<propagateFlag\> allows to
* limit the propagation in some cases (i.e. when the
* contact size changes, objects anchored on it are
* not affected and there is no need to invalidate
* them).
*
* An already dematerialized object must not be taken
* in count in the current update session, but its
* propagation, if required, must be systematically
* executed.
*
* \sample We give as an example the implementation for the instances :
\code
void Instance::Invalidate(bool propagateFlag)
// ******************************************
{
Inherit::Invalidate(false);
if (propagateFlag) {
for_each_plug(plug, GetConnectedPlugs()) {
plugInvalidate(true);
end_for;
}
}
}
\endcode
\code
void Component::Invalidate(bool propagateFlag)
// *******************************************
{
Inherit::Invalidate(false);
if (propagateFlag) {
for_each_component(component, GetSlaveComponents()) {
componentInvalidate(false);
end_for;
}
}
}
\endcode
\code
void Contact::SetLayer(Layer* layer)
// *********************************
{
if (!layer)
throw Error("Can't set layer : null layer");
if (layer != _layer) {
// we do the change only if necessary
Invalidate(false); // done before the modification
_layer = layer;
}
}
\endcode
\code
void Instance::SetTransformation(const Transformation& transformation)
// *******************************************************************
{
if (transformation != _transformation) {
// we do the change only if necessary
Invalidate(true); // done before the modification
_transformation = transformation;
}
}
\endcode
*/
/*! \function void Go::Translate(const Unit& dx, const Unit& dy);
* Translate the graphic object of the quantity \c \<dx\> and
* \c \<dy\>.
*
* This virtual method should be specialized for a new kind of
* graphic object.
*/
// \}
/*! \name Go Collection
*/
// \{
/*! \typedef Gos
* Generic collection representing a set of graphic objects.
*/
/*! \typedef GoLocator
* Generic locator for visiting a collection of graphic objects.
*/
/*! \typedef GoFilter
* Filter to selecting a subset of graphic objects matching some
* criteria.
*/
/*! \def for_each_go(go, gos)
* Macro for visiting all graphic objects of a graphic objects
* collection.
*/
// \}
}

295
hurricane/doc/hurricane/Hook.dox Normal file
View File

@ -0,0 +1,295 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Hook
* \brief Hook description (\b API)
*
* \section secHookIntro Introduction
*
* The hook is an object which is nested inside a component and
* which represents some specific part of this component (like
* its body, its origin or its extremity ...).
*
* The Hook class is an abstract one, that means that for any
* new type of <b>part</b> a new hook subclass must be derived.
* Each hook specialization will be described altogether with
* the component which includes it.
*
* The Component for instance introduces the concept of
* <b>BodyHook</b> representing the body of the component (which
* can be assimilated to the component itself).
*
*
* \section secHookRings Rings
*
* Hooks are assembled into a <b>ring</b> (circular link) thanks
* to a special field pointing to the next hook within the ring.
*
* This field is never NULL, by default it points to itself,
* generating a minimal ring.
*
*
* \section secHookMasterAndSlaveHookTypes Master and Slave hook types
*
* There are two kinds of hooks : the <b>masters</b> and the
* <b>slaves</b>.
*
* Rings are organized such that all slave hooks of a master
* hook are placed in the ring immediately before it (the
* ordering of slaves is not significant).
*
* Therefore, to find the master of a given slave, it's enough
* to follow the ring pointers, starting from the slave, until a
* master is found.
*
*
* \section secHookExplicitConnections Explicit connections
*
* This dependency between a slave and its master means that the
* part of the component represented by the slave is anchored on
* the part of the component represented by the master.
*
* This dependence relationship is indeed an explicit
* connection.
*
*
* \section secHookImplicitConnections Implicit connections
*
* Within a ring many relationships master-slaves can cohabit.
*
* This cohabitation has a specific meaning for the different
* masters of the ring. In fact, the ring must be considered as
* a connection request between the different masters of the
* ring.
*
* In other words, this means that the different masters remains
* to be connected together, or more generaly stated, that the
* different connected subsets of components associated to those
* masters remains to be connected together.
*
* The ordering of masters within a ring has no particular
* signification.
*
*
* \section secHookConceptsOfHyperhooksAndHyperrings Concepts of HyperHooks and HyperRings
*
* We can imagine the master-slaves relation as a kind of
* hyper-hook representing the associated sub-ring, and the ring
* containing multiple master-slaves relations as an hyper-ring
* made up of hyper-hooks needing to be connected.
*
* Therefore there will be two different levels of ring
* processing functions depending on wether we handle hooks
* stricktly speaking or we handle hyper-hooks representing
* multiple master hooks.
*
* \section secHookConstructorAndDestructor Constructor and Destructor
*
* There is no Hook constructor available because they are created by
* the components themselves.
*
* On the same way, hooks disapear automatically with their owner.
*/
/*! \name Accessors
*/
// \{
/*! \function Component* Hook::GetComponent() const;
* \Return the component whose hook represents a part.
*
* \remark The result is never NULL because hooks are byforce nested
* objects in their component.
*/
/*! \function Hook* Hook::GetNextHook() const;
* \Return the next hook within the ring.
*
* \remark The result is never NULL because every hook has by
* construction its next one (which may be itself is the ring is
* empty).
*/
/*! \function Hook* Hook::GetPreviousHook() const;
* \Return the previous hook within the ring.
*
* \remark Less efficient than GetNextHook because it requires a
* complete ring loop.
*/
/*! \function Hook* Hook::GetMasterHook() const;
* \Return the master of the relation master-slaves identified by the
* hook.
*
* \remark May return itself if the hook is a master and return NULL if
* the hook is a slave and has no associated master.
*/
/*! \function Hook* Hook::GetNextMasterHook() const;
* \Return the first master found when starting the search immediately
* after the given hook.
*
* \remark May return NULL if there is no master within the ring or
* return the hook itself if it is a master and the only one in
* the ring.
*/
/*! \function Hook* Hook::GetPreviousMasterHook() const;
* \Return the first master found when starting a backwards search
* immediately before the given hook.
*
* \remark May return NULL if there is no master within the ring or
* return the hook itself if it is a master and the only one in
* the ring.
*
* \remark Of course the search is done in the natural forward direction
* (else it would be trully inefficient).
*/
/*! \function Hooks Hook::GetHooks() const;
* \Return the collection of hooks of the ring containing the given
* hook.
*
* \remarks Hooks are always visited in the natural order starting from
* the hook itself.
*/
/*! \function Hooks Hook::GetSlaveHooks() const;
* \Return the hook collection which are slaves of the given hook.
*
* \remarks This collection will be empty if the given hook is not a
* master or if it has no attached slaves.
*
* When visiting the slaves of a master, those are accessed in
* the assembly order : the first one is the oldest inserted
* (they are accessed starting from the first slave found when
* starting a ring loop from the master itself).
*
* The master is not included in this collection.
*/
// \}
/*! \name Predicates
*/
// \{
/*! \function bool Hook::IsMaster() const;
* \Return \true if the hook must be considered as a master, else
* \false.
*
* \remark For any new kind of hook this predicate must be overloaded.
*/
/*! \function bool Hook::IsAttached() const;
* If the hook is a slave :
*
* \Return \true if the hook has an associated master, else \false.
*
* \remark You can't find two slaves in the same ring without at least a
* master.
*
* If the hook is a master :
*
* Let us consider the hyper-ring made upon hyper-hooks. Then
* the function returns \true if the ring contains at least an
* other master else \false.
*
* \caution The meaning here is very different than for a slave hook!
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function Hook* Hook::Detach();
* If the hook is a slave :
*
* Detaches the hook from its ring and returns its old
* predecessor.
*
* \remark Will return NULL if the hook is the only one in the ring.
*
* If the hook is a master :
*
* Let us consider the hyper-ring made upon hyper-hooks. Then,
* the function detaches the hyper-hook (the sub-ring made up of
* the master and its slaves, if any) from the hyper-ring and
* returns the old predecessor of the hyper-hook.
*
* Within the detached hyper-hook, the relationship master hook
* - slave hooks remains unaltered and forms a new ring.
*
* \remarks May return NULL if the hook is the only master of the ring.
*
* The returned hook, if not NULL, is byforce a master.
*/
/*! \function Hook* Hook::Attach(Hook* masterHook);
* If the hook (this) is a slave :
*
* The function inserts the hook immediately before
* \c \<masterHook\> and returns this masterHook.
*
* \caution Might throw an exception if the hook already has a master or
* if \c \<masterHook\> is not a master hook.
*
* If the hook (this) is a master :
*
* Let us consider the hyper-ring made upon hyper-hooks. Then,
* the function attaches the the hyper-hook (the sub-ring made
* up of this master hook and its slaves, if any) before the
* \c \<masterHook\> and returns this masterHook.
*
* \caution Might throw an exception if the hyper-hook is already
* attached within a ring including an other master or if
* \c \<masterHook\> is not a master hook.
*/
/*! \function Hook* Hook::Merge(Hook* masterHook);
* Merges the rings represented by the two hooks which both must
* be masters, returns \c \<masterHook\>.
*
* \remark Throws an exception if both hooks are not masters.
*
* This function doesn't change the two relatioships
* master-slaves but modifies the connection request between
* corresponding hyper-hooks.
*/
// \}
/*! \name Hook Collection
*/
// \{
/*! \typedef Hooks
* Collection representing a set of hooks.
*/
/*! \typedef HookLocator
* Locator for traversing a collection of hooks.
*/
/*! \typedef HookFilter
* Fiter for selecting a sub-set of hooks matching a given
* criteria.
*/
/*! \def for_each_hook(hook, hooks)
* Macro for visiting the set of all hooks of a hook collection.
*/
// \}
}

123
hurricane/doc/hurricane/Horizontal.dox Normal file
View File

@ -0,0 +1,123 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Horizontal
* \brief Horizontal description (\b API)
*
* \section secHorizontalIntro Introduction
*
* A horizontal has, in addition to inherited attributes, a
* specific one : its ordinate. The horizontal extend of the
* segment is defined by the "source" and "target" components on
* which it is anchored.
*
* This ordinate allows, among other things, to anchor a
* horizontal segment extremity on a component (i.e. a contact)
* with a small vertical offset without the need to materialize
* it, because it is implicitely equal to the difference between
* the horizontal ordinate and the component ordinate. It allows
* also, and it not the least interesting feature, to anchor an
* extremity of a horizontal directly on a vertical segment (and
* conversely) without the need to create an intermediate
* contact (unless they are on different layers!). The ordinate
* of the implicit contact point is the one of the horizontal
* and the abscissa the one of the vertical).
*/
/*! \typedef Horizontal::Inherit
* Useful for calling upon methods of the base class without
* knowing it.
*/
/*! \name Constructors
*/
// \{
/*! \function Horizontal* Horizontal::Create(Component* source, Component* target, Layer* layer,const Unit& y, const Unit& width = 0,const Unit& dxSource = 0, const Unit& dxTarget = 0);
* No description.
*/
/*! \function Horizontal* Horizontal::Create(Net* net, Layer* layer, const Unit& y, const Unit& width = 0,const Unit& dxSource = 0, const Unit& dxTarget = 0);
* Creates and returns an absolute horizontal segment with layer
* \c \<layer\>, located at ordinate \c \<y\> and of width
* \c \<width\>. The differents extremities abscissas are given
* by \c \<dxSource\> and \c \<dxTarget\>.
*
* \caution Throws an exception if any of the net or layer pointers is
* null.
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function const Unit& Horizontal::GetDxSource() const;
* \Return the relative source abscissa of the segment (may be absolute
* if the source extremity isn't anchored).
*
* \remark If you want to get the absolute one use the member function
* GetSourceY() defined at the Segment level.
*/
/*! \function const Unit& Horizontal::GetDxTarget() const;
* \Return the relative target abscissa of the segment (may be absolute
* if the target extremity isn't anchored).
*
* \remark If you want to get the absolute one use the member function
* GetTargetY() defined at the Segment level.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function void Horizontal::SetY(const Unit& x);
* Sets the ordinate of the segment.
*/
/*! \function void Horizontal::Translate(const Unit& dy);
* Translate verticaly the horizontal segment of the quantity
* \c \<dy\>.
*/
// \}
/*! \name Horizontal Collection
*/
// \{
/*! \typedef Horizontals
* Generic collection representing a set of horizontal segments.
*/
/*! \typedef HorizontalLocator
* Generic locator for traversing a collection of horizontal
* segments.
*/
/*! \typedef HorizontalFilter
* Generic filter allowing to select a subset of horizontals
* matching some criteria.
*/
/*! \def for_each_horizontal(horizontal, horizontals)
* Macro for visiting all the horizontals of a collection of
* horizontal segments.
*/
// \}
}

11
hurricane/doc/hurricane/Hurricane.dox Normal file
View File

@ -0,0 +1,11 @@
// -*- C++ -*-
namespace Hurricane {
/*! \namespace Hurricane
* \brief The namespace dedicated to Hurricane.
*/
}

195
hurricane/doc/hurricane/Instance.dox Normal file
View File

@ -0,0 +1,195 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Instance
* \brief Instance description (\b API)
*
* \section secInstanceIntro Introduction
*
* Instances provide the capability to build hierarchical
* assemblies. An instance belongs to a cell (the "<b>owner
* cell</b>") and references (calls) a model cell which we will
* call the "<b>mater cell</b>". Seen from the other hand, a
* cell may be the master cell of many instances belonging to
* other cells, this set of instances is named the "<b>slave
* instances</b>" of this cell (it is empty for the top most
* cell of a hierachical assembly, as well as for all cells from
* the library which are not instanciated in the current
* design).
*
*
* \section secInstancePredefinedFilters Predefined filters
*
* <b>Hurricane::Instance::GetIsUnderFilter</b>
*/
/*! \typedef Instance::Inherit
* Useful for calling upon methods of the base class without
* knowing it.
*/
/*! \name Constructors
*/
// \{
/*! \function Instance* Instance::Create(Cell* cell, const Name& name, Cell* masterCell, bool secureFlag = true);
* No description.
*/
/*! \function Instance* Instance::Create(Cell* cell, const Name& name, Cell* masterCell,const Transformation& transformation, const PlacementStatus& placementstatus, bool secureFlag = true);
* Create and return a pointer to a new instance of name
* \c \<name\> belonging to the cell \c \<cell\> and refering
* the cell \c \<masterCell\> through a transformation
* \c \<transformation\> if it is provided (else the identity
* transform is assumed).
*
* \caution Throws an exception if the cell \c \<cell\> is null, if the
* \c \<masterCell\> is null, if an instance of same name
* already exists or if a cyclic assembly is detected.
*
* \remark If the \c \<secureFlag\> is set to \false the verification of
* the lack of cyclic assembly is skipped (you save some cpu
* time, but at your own risks).
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function const Name& Instance::GetName() const;
* \Return the instance name.
*/
/*! \function Cell* Instance::GetMasterCell() const;
* \Return the cell model referenced by the instance.
*/
/*! \function const Transformation& Instance::GetTransformation() const;
* \Return the transformation associated to the instance.
*/
/*! \function Plug* Instance::GetPlug(const Net* masterNet) const;
* \Return the plug associated to the \c \<masterNet\> if it exists or
* else NULL (if the net is not external).
*/
/*! \function Plugs Instance::GetPlugs() const;
* \Return the collection of instance plugs.
*
* \important Each external net of the master cell of the instance has by
* construction an associated plug. This one may be connected or
* not to a net in the owner cell of the instance.
*/
/*! \function Plugs Instance::GetConnectedPlugs() const;
* \Return the collection of instance plugs which are effectively
* connected.
*/
/*! \function Plugs Instance::GetUnconnectedPlugs() const;
* \Return the collection of instance plugs which are not connected.
*/
/*! \function Path Instance::GetPath(const Path& tailPath=Path()) const;
* \Return the path composed of the instance solely.
*/
/*! \function Path Instance::GetPath(const Path& tailPath) const;
* \Return the path resulting of the concatenation of the instance and
* the tail path (possibly empty).
*
* \caution An exception will be thrown if the tail path is not
* consistent with the instance (that is if the owner cell of
* the tail path is not the master cell of the instance).
*/
/*! \function Box Instance::GetAbutmentBox() const;
* \Return the abutment box of the instance, that is the abutment box of
* the master cell to which has been applied the instance
* transformation.
*/
/*! \function InstanceFilter Instance::GetIsUnderFilter(const Box& area);
* \Return the filter selecting instances which intersect the given
* area.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function void Instance::SetName(const Name& name);
* Allows to change the instance name.
*
* \remark Throws an exception if the name is empty or if an instance
* with the same name exists in the owner cell.
*/
/*! \function void Instance::SetTransformation(const Transformation& transformation);
* Allows to modify the instance transformation.
*/
/*! \function void Instance::SetMasterCell(Cell* masterCell, bool secureFlag = true);
* Allows to change the cell referenced by this instance.
*
* \caution Throws an exception if either the cell is null, a cyclic
* assembly is detected or the substitution can't succeed.
*
* \remark If the \c \<secureFlag\> is set to \false the verification of
* the lack of cyclic assembly is skipped (you save some cpu
* time, but at your own risks).
*
* \important In order to succeed with the substitution, it is necessary
* that for each connected plug, refering an external net of the
* old master cell, a net of same name can be found in the new
* master cell.
*
* The properties of the instance, of its existing plugs and of
* the different occurences of those ones are preserved. On the
* other hand, all the hierarchical pathes going through that
* instance and not ending on it, as well as all associated
* occurences, become obsolete. The properties attached to those
* occurences are therefore deleted.
*/
// \}
/*! \name Instance Collection
*/
// \{
/*! \typedef Instances
* Generic collection representing a set of instances.
*/
/*! \typedef InstanceLocator
* Generic locator for traversing a collection of instances.
*/
/*! \typedef InstanceFilter
* Generic filter allowing to select a subset of instances
* matching some criteria.
*/
/*! \def for_each_instance(instance, instances)
* Macro for visiting all the instances of a collection of
* instances.
*/
// \}
}

67
hurricane/doc/hurricane/Interruption.dox Normal file
View File

@ -0,0 +1,67 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Interruption
* \brief Interruption description (\b API)
*
* \section secInterruptionIntro Introduction
*
* Interruptions are neither errors nor warnings. They are used
* to suspend a potentially lengthy action (like a display
* refresh). We could have used errors or warning but it is
* wiser to use a specific type.
*/
/*! \typedef Interruption::Inherit
* Useful for calling the base class methods without knowing
* this class.
*/
/*! \name Constructors
*/
// \{
/*! \function Interruption::Interruption(const string& reason, int code = 0);
* Builds an interruption characterized by a reason and a code
* useful within a switch.
*/
/*! \function Interruption::Interruption(const Interruption& interruption);
* Copy constructor.
*/
// \}
/*! \name Operators
*/
// \{
/*! \function Interruption& Interruption::operator=(const Interruption& interruption);
* Assignment operator.
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function const string& Interruption::GetReason() const;
* \Return the reason for which the interruption was thrown.
*/
/*! \function int Interruption::GetCode() const;
* \Return the interruption code number.
*/
// \}
}

211
hurricane/doc/hurricane/Interval.dox Normal file
View File

@ -0,0 +1,211 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Interval
* \brief Interval description (\b API)
*
* \section secIntervalIntro Introduction
*
* Those objects represent intervals. They are defined by the
* values <b>VMin</b> and <b>VMax</b> which are representatives
* only when the interval is not empty. An interval is
* considered empty whenever it is not initialized or when it
* doesn't represent a real interval like the intersection of
* two disjoint intervals.
*
*
* \section secIntervalRemark Remark
*
* All the function described in the chapter above return a
* reference on the modified interval, providing so the
* capability to apply to it a new modification.
*/
/*! \name Constructors
*/
// \{
/*! \function Interval::Interval(bool makeEmpty=true);
* Default constructor : the returned interval is empty if
* <b>makeEmpy</b> is set to <b>true</b> (default) or full span
* otherwise.
*/
/*! \function Interval::Interval(const Unit& v);
* Builds an interval of null size centered on the value defined
* by \c \<v\>.
*/
/*! \function Interval::Interval(const Unit& v1, const Unit& v2);
* Builds the minimal interval enclosing the two values defined
* by \c \<v1\> and \c \<v2\>.
*/
/*! \function Interval::Interval(const Interval& interval);
* Copy constructor.
*/
// \}
/*! \name Operators
*/
// \{
/*! \function Interval& Interval::operator=(const Interval& interval);
* Assignment operator.
*/
/*! \function bool Interval::operator==(const Interval& interval) const;
* Equality operator.
*
* \remark Two empty intervals are always different.
*/
/*! \function bool Interval::operator!=(const Interval& interval) const;
* Difference operator.
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function const Unit& Interval::GetVMin() const;
* \Return the VMin value : meaningful only for a non empty interval.
*/
/*! \function const Unit& Interval::GetVMax() const;
* \Return the VMax value : meaningful only for a non empty interval.
*/
/*! \function Unit Interval::GetCenter() const;
* \Return the interval center value : meaningful only for a non empty
* interval.
*/
/*! \function Unit Interval::GetSize() const;
* \Return the interval size : meaningful only for a non empty interval.
*/
/*! \function Unit Interval::GetHalfSize() const;
* \Return the half interval width : meaningful only for a non empty
* interval.
*/
/*! \function Interval Interval::GetUnion(const Interval& interval) const;
* \Return the smallest enclosing interval containing the intervals
* \c \<this\> and \c \<interval\>. The returned interval may be
* empty if both are.
*/
/*! \function Interval Interval::GetIntersection(const Interval& interval) const;
* \Return interval representing the overlapping region. This interval
* is empty if either one of the two intervals is empty or if
* they are disjoint.
*/
// \}
/*! \name Predicates
*/
// \{
/*! \function bool Interval::IsEmpty() const;
* \Return \true if the interval is empty, else \false.
*/
/*! \function bool Interval::IsPonctual() const;
* \Return \true if the interval is reduced to a value, else \false.
*/
/*! \function bool Interval::Contains(const Unit& v) const;
* \Return \true if the interval is non empty and contains the value
* defined by \c \<v\> else \false.
*/
/*! \function bool Interval::Contains(const Interval& interval) const;
* \Return \true if the two intervals are non empty and if the interval
* \c \<this\> contains the interval \c \<interval\>, else
* \false.
*/
/*! \function bool Interval::Intersect(const Interval& interval) const;
* \Return \true if the two intervals are non empty and if they overlap,
* else \false.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function Interval& Interval::MakeEmpty();
* Transforms the interval into an empty one.
*/
/*! \function Interval& Interval::Inflate(const Unit& dv);
* Expands (or contracts) the interval, if not empty, in each
* direction of the quantity \c \<dv\>. This quantity might be
* negative enough to transform it into an empty interval.
*/
/*! \function Interval& Interval::Inflate(const Unit& dvMin, const Unit& dvMax);
* Expands (or contracts) the interval, if not empty, on the
* left of the quantity \c \<dvMin\> and on the right of the
* quantity \c \<dvMax\>. Those quantities might be negative
* enough to transform it into an empty interval.
*/
/*! \function Interval& Interval::Merge(const Unit& v);
* Expands the interval in order that it encloses the value
* defined \c \<v\>. If the interval was initially empty it
* becomes reduced to the enclosed value.
*/
/*! \function Interval& Interval::Merge(const Interval& interval);
* Expands the interval in order that it encloses, if not empty,
* the interval \c \<interval\>. If the interval \c \<this\> was
* initially empty it becomes reduced to the enclosed interval.
*/
/*! \function Interval& Interval::Intersection(const Unit& vMin, const Unit& vMax);
* The interval becomes the intersection of itself and
* <b>[vMin,vMax]</b>.
*/
/*! \function Interval& Interval::Intersection(const Interval& interval);
* The interval becomes the intersection of itself and
* <b>interval</b>.
*/
/*! \function Interval& Interval::Translate(const Unit& dv);
* Translates the interval, if not empty, of the quantity
* \c \<dv\>.
*
* Exemple :
\code
Interval interval1 = Interval(10, 100);
Interval interval2 = interval1;
assert(interval1.Translate(10) == interval2.Inflate(-10, 10));
\endcode
*
*
*/
// \}
}

145
hurricane/doc/hurricane/Layer.dox Normal file
View File

@ -0,0 +1,145 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Layer
* \brief Layer description (\b API)
*
* \section secLayerIntro Introduction
*
* There are two layer types : Basic layers which are indeed the
* real process layers (GDS ones) and composite layers on which
* are located components of the layout. A composite layer
* groups a set of basic layers. For example, the contact layer
* VIA12 is built of the basic layers CM1 (metal1), CM2 (metal2)
* and C12 (contact cuts between CM1 and CM2).
*
* Like for the Technology object, a layer must not be deleted,
* else all components located on it will have a dangling
* pointer to an deleted object ...
*/
/*! \typedef Layer::Inherit
* Useful for calling upon methods of the base class without
* knowing it.
*/
/*! \typedef Layer::Mask
* This type represents a mask bit field characterising
* efficiently the constituents of any kind of layer. It
* associates to each basic layer a bit and to each composite
* layer the union of the bits corresponding to its basic
* layers.
*/
/*! \name Accessors
*/
// \{
/*! \function Technology* Layer::GetTechnology() const;
* \Return the technolgy owning the layer.
*/
/*! \function const Name& Layer::GetName() const;
* \Return the name of the layer.
*/
/*! \function const Layer::Mask& Layer::GetMask() const;
* \Return the mask associated to the layer.
*/
/*! \function const Layer::Mask& Layer::GetExtractMask() const;
* \Return the mask used for extraction.
*
* Two differents basic layers have different masks but may have
* same extraction masks (ie CP layer which represent poly and
* CPG which represent poly used to realize transistor gates).
*/
/*! \function const Unit& Layer::GetMinimalSize() const;
* \Return the minimal size allowed for a rectangular layout pad on this
* layer.
*/
/*! \function const Unit& Layer::GetMinimalSpacing() const;
* \Return the minimal spacing between two pads on this layer.
*/
/*! \function BasicLayers Layer::GetBasicLayers() const;
* \Return the collection of basic layers within this layer.
*
* \remark For a basic layer the collection contains this one only.
*/
// \}
/*! \name Predicates
*/
// \{
/*! \function bool Layer::Contains(Layer* layer) const;
* \Return \true if the \c \<layer\> is completely included in the layer
* \c \<this\> (that is if the basic layers of \c \<layer\> are
* a sub-set of the basic layers of \c \<this\>), else \false.
*/
/*! \function bool Layer::Intersect(Layer* layer) const;
* \Return \true if the \c \<layer\> and the layer \c \<this\> have at
* least a common basic layer, else \false.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function void Layer::SetName(const Name& name);
* Sets or changes the layer name.
*
* \remark An exception is thrown if the name is empty or if there is an
* other layer with that name.
*/
/*! \function void Layer::SetMinimalSize(const Unit& minimalSize);
* Sets the minimal size of a pad on this layer.
*/
/*! \function void Layer::SetMinimalSpacing(const Unit& minimalSpacing);
* Sets the minimal spacing between two pads on this layer.
*/
// \}
/*! \name Layer Collection
*/
// \{
/*! \typedef Layers
* Generic collection representing a set of layers.
*/
/*! \typedef LayerLocator
* Generic locator for traversing a collection of layers.
*/
/*! \typedef LayerFilter
* Generic filter allowing to select a subset of layers matching
* some criteria.
*/
/*! \def for_each_layer(layer, layers)
* Macro for visiting all the layers of a collection of layers.
*/
// \}
}

134
hurricane/doc/hurricane/Library.dox Normal file
View File

@ -0,0 +1,134 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Library
* \brief Library description (\b API)
*
* \section secLibraryIntro Introduction
*
* A library contains a set of symbols, a set of cells and may
* also contains a set of sub libraries.
*
* A root library exists directly attached to the data_base.
* This root library is the only one which has no parent
* library.
*/
/*! \typedef Library::Inherit
* Useful for calling upon methods of the base class without
* knowing it.
*/
/*! \name Constructors
*/
// \{
/*! \function Library* Library::Create(DataBase* dataBase, const Name& name);
* Creates and returns a new root library named \c \<name\> for
* the data base \c \<dataBase\>.
*
* \caution Throws an exception if the data base is null, if the name is
* empty or if the data base already contains a root library.
*/
/*! \function Library* Library::Create(Library* library, const Name& name);
* Creates and returns a new sub library named \c \<name\> for
* the library \c \<library\>.
*
* \caution Throws an exception if the library is null, if the name is
* empty or if a sub library with same name already exists in
* the library.
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function DataBase* Library::GetDataBase() const;
* \Return the data base owning directly or indirectly the library.
*/
/*! \function Library* Library::GetLibrary() const;
* \Return the library owning the library (NULL for the root library).
*/
/*! \function const Name& Library::GetName() const;
* \Return the name of the library.
*/
/*! \function Library* Library::GetLibrary(const Name& name) const;
* \Return the sub library of name \c \<name\> if it exists, else NULL.
*/
/*! \function Libraries Library::GetLibraries() const;
* \Return the collection of all sub libraries of the library.
*/
/*! \function Cell* Library::GetCell(const Name& name) const;
* \Return the cell of name \c \<name\> if it exists, else NULL.
*/
/*! \function Cells Library::GetCells() const;
* \Return the collection of all cells of the library.
*/
/*! \function Symbol* Library::GetSymbol(const Name& name) const;
* \Return the symbol of name \c \<name\> if it exists, else NULL.
*/
/*! \function Symbols Library::GetSymbols() const;
* \Return the collection of all symbols of the library.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function void Library::SetName(const Name& name);
* Allows to change the library name.
*
* \remark Throws an exception if the new name is empty or if the
* library owning the library (if any) has already a sub library
* with the same name.
*/
// \}
/*! \name Library Collection
*/
// \{
/*! \typedef Libraries
* Generic collection representing a set of libraries.
*/
/*! \typedef LibraryLocator
* Generic locator for traversing a collection of libraries.
*/
/*! \typedef LibraryFilter
* Generic filter allowing to select a subset of libraries
* matching some criteria.
*/
/*! \def for_each_library(library, libraries)
* Macro for visiting all the libraries of a libraries
* collection.
*/
// \}
}

79
hurricane/doc/hurricane/ListCollection.dox Normal file
View File

@ -0,0 +1,79 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class ListCollection
* \brief ListCollection description (\b API)
*
* \section secListCollectionIntro Introduction
*
* This collection allows you to handle a STL list as a
* collection.
*
* In priciple you don't need to handle directly this
* collection, you only need to handle a generic collection
* bound to a <b>ListCollection</b> as created by the generic
* function <b>GetCollection</b>(...) which builds one when its
* argument is a STL list (for that reason we will not describe
* it).
*
*
* \section secListCollectionOverloadingsOfTheGetcollectionGenericFunction Overloadings of the GetCollection generic function
*
* <b>Hurricane::ListCollection::GetCollection</b>
* <b>Hurricane::ListCollection::GetCollection</b>
*
*
* \section secListCollectionRemarks Remarks
*
* Like for the other collections, there is no copy of the
* elements included in the list, but instead a link from the
* collection to the list.
*
* Once the collection as been built, you can perfectly modify
* the list; the added or deleted elements will be taken into
* account when visiting the list, as shown in the following
* example :
\code
list<Net*> netList;
Nets nets = GetCollection(netList);
// nets is bound here to the list netList
// and will reflect its content until the end
// so we can :
assert(nets.IsEmpty());
Cell* cell = ... // we get a cell
if (cell) {
Net* net = cellGetNet("vdd");
if (net) {
netList.push_back(net);
// and now :
assert(nets.GetSize() == 1);
}
}
\endcode
*/
/* \name Accessors
*/
// \{
/*! \function GenericCollection<Element> ListCollection::GetCollection(const list<Element>& elementList);
* \see below.
*/
/*! \function GenericCollection<Element> ListCollection::GetCollection(const list<Element>* elementList);;
* Those two function return into generic collection bound to a
* <b>ListCollection</b> the content of the STL list given in
* argument.
*/
// \}
}

144
hurricane/doc/hurricane/Locator.dox Normal file
View File

@ -0,0 +1,144 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Locator
* \brief Locator description (\b API)
*
* \section secLocatorIntro Introduction
*
* Locators are objects which allow to walk efficiently through
* the data structure.
*/
/*! \section secLocatorGeneralConcepts General concepts
*
* <b>Initialization</b> In order to get a locator, you must :
* either ask the collection to provide a locator for visiting
* the elements of its described set, or build a clone of an
* existing locator allowing to visit the remaining elements
* starting from the current position of that locator.
*
* <b>End of walk indicator</b> The predicate <b>IsValid()</b>
* returns \true if the locator refers an element of the set,
* \false when all the elements have been visited.
*
* <b>Getting the current element</b> The current element is
* obtained by the accessor <b>GetElement()</b>. There is no
* risk to call this function when the visit is finished or the
* locator is non initialized (the returned value is
* meaningless).
*
* <b>Walk progression</b> The function <b>Progress()</b> moves
* forward the locator on the next element of the set (does
* nothing if called after the last element).
*/
/*! \section secLocatorUsageExamples Usage examples
*
* The following sample code shows how to trace the nets of a
* given cell
\code
Cell* cell = ...; // we get the cell
if (cell) {
// CellGetNets()
// returns the nets collection of the cell
// and GetLocator()
// allocates and returns a locator for traversing those nets
Locator<Net*>* locator = CellGetNets().GetLocator();
while (locatorIsValid()) {
Net* net = locatorGetElement();
assert(netGetCell() == cell);
locatorProgress();
}
// don't forget to release the allocated locator
delete locator;
}
\endcode
* And this one how to print all pairs of nets of a given cell
\code
Cell* cell = ...; // we get a cell
if (cell) {
Locator<Net*>* locator1 = CellGetNets().GetLocator();
while (locator1IsValid()) {
Net* net1 = locator1GetElement();
Locator<Net*>* locator2 = locator1GetClone();
while (locator2IsValid()) {
Net* net2 = locator2GetElement();
cerr << net1 << " " << net2 << endl;
locator2Progress();
}
delete locator2;
locator1Progress();
}
delete locator1;
}
\endcode
* \remark Those examples are given in order to explain how locators
* work. We will see in the following how to do that more simply
* by using generic locators, or even simpler by using the
* for_each macros.
*/
/*! \name Accessors
*/
// \{
/*! \function Type Locator::GetElement() const;
* \Return the current element (or the value <b>Type()</b> when the
* locator is not or no longer valid).
*/
/*! \function Locator<Type>* Locator::GetClone() const;
* This function allocates and returns a new locator that will
* have the same visiting course than the remaining one of the
* locator being cloned.
*
* \remark In principle there is no need to call this function, but if
* you do so you must not forget to release the clone after its
* use or, from it, build a generic locator which will do that
* for you (to be explained later).
*/
// \}
/*! \name Predicates
*/
// \{
/*! \function bool Locator::IsValid() const;
* \Return \true while the walk has not exhausted the set of elements,
* else \false.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function void Locator::Progress();
* Moves forward the locator to the following element.
*/
// \}
}

184
hurricane/doc/hurricane/MIGRATE.txt Normal file
View File

@ -0,0 +1,184 @@
G u i d e d e M i g r a t i o n
1. Arborescence
Les sources de la nouvelle documentation se trouvent dans :
~/hurricane/documentation/hurricane/doc.new
Elle est intallée dans :
~/coriolis/Linux.SLA4x/install/share/doc/en/html/hurricane.new
2. Ajout d'un nouveau fichier
Il faut modifier les fichiers de configuration suivants :
2.1 doc.new/doxyfile
Ajouter a la variable INPUT les fichiers ".h" et ".dox" associés.
Sauf en cas de documentation d'une fonction ou d'un objet entièrement
local au ".cpp" il n'est pas nécessaire de l'inclure dans la liste.
Merci de respecter l'indentation et l'alignement pour qu'on y voie
clair.
2.2 doc.new/Makefile.am
Ajouter le fichier de documentation (".dox") uniquement à la cible :
doc_en_hurricane_EXTRA
3. Ajout d'une figure
Les figures doivent être mises dans le sous-répertoire "images", au format
.fig, si possible (sinon png/gif & pdf pour chaque image).
3.1 doc.new/images/Makefile.am
Ajouter le .fig OU les png/gif & pdf à la cible EXTRA_DIST.
3.2 doc.new/Makefile.am
Dans le cas des .fig, il faut générer à la volée les png et pdf
associés. Pour pouvoir préciser des zooms spécifiques, il faut ajouter
un petit morceau de shell script au Makefile.am :
for figure in DummyFig*.fig; do \
zoom="0.7"; \
case $$figure in \
DummyFig-1.fig) zoom="0.7";; \
DummyFig-2.fig) zoom="0.9";; \
esac; \
fig2dev -L png -m $$zoom $$figure `basename $$figure .fig`.png; \
fig2dev -L pdf -p dummy $$figure `basename $$figure .fig`.pdf; \
done; \
C'est la version la plus complexe, on la simplifiera suivant les
besoins.
4. Modification du ".h"
Pour éviter de voir apparaître tous les membres et fonctions membres
il est nécessaire de répartir membres documentés et membres non documentés
de part et d'autre de la macro "__DOXYGEN_PROCESSOR__".
Identification correcte du namespace : les macros BEGIN_HURRICANE_NAMESPACE
et END_HURRICANE_NAMESPACE empèche doxygen d'identifier les membres de ce
namespace. Il faut les remplacer par leur version expansée :
namespace Hurricane {
} // End of Hurricane namespace
Je pense que de toute façons, ce n'est pas plus mal pour la clarté du code.
Remarque : Si une classe ou une fonction n'est absolument pas documentée
(c.a.d. ni la classe, ni aucun de ses attributs ni aucunes de
ses fonctions membres) elle ne sera pas prise en compte dans
doxygen et il est donc inutile de faire un partage entre
partie documentée ou non.
Exemple, pour la DataBase :
namespace Hurricane {
class DataBase : public DBo {
# if !defined(__DOXYGEN_PROCESSOR__)
// Fonctions & membres non documentés.
// Attributes
private: Technology* _technology;
private: Library* _rootLibrary;
// Constructors
protected: DataBase();
// Others
protected: virtual void _PostCreate();
protected: virtual void _PreDelete();
public: virtual string _GetTypeName() const {return _TName("DataBase");};
public: virtual string _GetString() const;
public: virtual Record* _GetRecord();
public: void _SetTechnology(Technology* technology) {_technology = technology;};
public: void _SetRootLibrary(Library* rootLibrary) {_rootLibrary = rootLibrary;};
public: virtual string _GetHeaderName() const {return "DB";};
public: virtual void _SaveHeaderTo(OutputFile& outputFile);
public: virtual void _SaveContentTo(OutputFile& outputFile);
public: virtual void _Realize(Hurricane::Builder* builder, InputFile& inputFile);
# endif
// Fonctions & membres documentés.
public: static DataBase* Create();
// Accessors
public: Technology* GetTechnology() const {return _technology;};
public: Library* GetRootLibrary() const {return _rootLibrary;};
};
} // End of Hurricane namespace.
5. Ecriture du ".dox"
IMPORTANT : D'un point de vue syntaxique le ".dox" est un fichier C/C++,
il est donc impératif de respecter les règles de syntaxe.
Pour éviter d'avoir à préfixer toutes les fonctions/classes par le
namespace Hurricane, il plus élégant d'inclure les documentations dans
le namespace lui même.
Indentation : Pour plus de clarté, on réserve la marge de gauche
pour les mots clés principaux (\class, \fonction, \section, ...)
Le texte doit commencer sur la 20ième colonne.
Reconnaissance des classes : il n'est plus nécessaire d'écrire une
classe entre '@' pour qu'elle soit reconnue comme mot clé et transformée
en hyperlien. Par exemple : @DBo@ devient simplement DBo.
Les commandes @remark@ et @caution@ deviennent \remark et \caution.
Les caractères '>' et '<' peuvent être utilisés directement, au lieu
de &gt; et &lt; .
Classement des fonctions membres par genre : pour cela on utilise
les techniques de "grouping". La structure se compose de trois morceaux :
\name donne le nom du groupe, immédiatement après on ouvre le groupe
avec \{ et on le ferme par \} après les fonctions membres du groupe.
/*! \name Constructors & Destructors
*/
// \{
/*! \function DataBase* DataBase::Create ();
* Creates and returns a pointer to a new DataBase.
*
* \caution An exception is thrown if a Database already exists.
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function Technology* DataBase::GetTechnology () const;
* \return the Technology if it exists, else \NULL.
*/
/*! \function Technology* DataBase::GetRootLibrary () const;
* \return the root Library if it exists, else \NULL.
*/
// \}
6. Génération de la documentation
Pour éviter de recompiler à chaque fois Hurricane on peu directement
faire un "make install" dans le répertoire de build :
(cd ~/coriolis/Linux.SLA4x/build/hurricane/documentation/hurricane/doc.new; make install)
NB: Il faut avoir fait tourner huitre au moins une fois avant de pouvoir
utiliser la commande précédente.
7. Enjoy!

84
hurricane/doc/hurricane/MainView.dox Normal file
View File

@ -0,0 +1,84 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class MainView
* \brief MainView description (\b API)
*
* \section secMainViewIntro Introduction
*
* There are two categories of views : the main views and the
* maps.
*
* The main view provides global or partial display of a cell
* while the map view (which is always attached to a main view)
* visualizes always the globality of the cell (in a simplified
* mode) and furthermore locates the part being currently
* visible within the main view.
*
* \section secMainViewCreators Creators
*
* <b>Hurricane::MainView::Create</b>
*/
/*! \name Accessors
*/
// \{
/*! \function MapView* MainView::GetMapView() const;
* \Return the associated map (never null).
*
* \remark An exception is thrown is you try to delete the map
* associated to the main view.
*/
// \}
/*! \name MainView Collection
*/
// \{
/*! \typedef MainViews
* Generic collection representing a set of main views.
*/
/*! \typedef MainViewLocator
* Generic locator for traversing a collection of main views.
*/
/*! \typedef MainViewFilter
* Filter for selecting a sub-set of main views matching some
* criteria.
*/
/*! \def for_each_main_view(mainView, mainViews)
* Macro for visiting all main views of a collection of main
* views.
*/
// \}
/* \name Constructors
*/
// \{
/*! \function MainView* MainView::Create();
* The default constructor (no cell is yet associated to the
* main view, but the drawing area is created).
*
* The map is also created as well as its drawing area.
*
* While the drawing areas are not inserted in a parent widget
* the display is not effective (it is therefore possible to
* activate only the display of the main view).
*/
// \}
}

135
hurricane/doc/hurricane/Makefile.am Normal file
View File

@ -0,0 +1,135 @@
SUBDIRS = images
doc_en_latex_hurricanedir = $(datadir)/doc/en/latex/hurricane.new
doc_en_html_hurricanedir = $(datadir)/doc/en/html/hurricane.new
doc_en_rtf_hurricanedir = $(datadir)/doc/en/rtf/hurricane.new
doc_en_man_hurricanedir = $(datadir)/man
doc_en_hurricane_CLEAN =
doc_en_hurricane_EXTRA = doxyfile \
asimbook.cls \
header.tex \
ASIM.css \
header.html \
footer.html \
customSummary.html \
customHierarchy.html \
BasicLayer.dox \
Box.dox \
Cell.dox \
Collection.dox \
Command.dox \
Commons.dox \
Component.dox \
CompositeLayer.dox \
Contact.dox \
DataBase.dox \
DBo.dox \
Editor.dox \
Entity.dox \
Error.dox \
Exception.dox \
ExpandRules.dox \
Filter.dox \
Generalities.dox \
GenericCollection.dox \
GenericFilter.dox \
GenericLocator.dox \
Go.dox \
Hook.dox \
Horizontal.dox \
Hurricane.dox \
Instance.dox \
Interruption.dox \
Interval.dox \
Layer.dox \
Library.dox \
ListCollection.dox \
Locator.dox \
MainView.dox \
MapCollection.dox \
MapView.dox \
Name.dox \
Net.dox \
NotFilter.dox \
Occurrence.dox \
Pad.dox \
Path.dox \
Pin.dox \
Plug.dox \
Point.dox \
Primitive.dox \
PrivateProperty.dox \
Property.dox \
QuadTree.dox \
Quark.dox \
Relation.dox \
Rubber.dox \
Segment.dox \
SelectCommand.dox \
SelectNetCommand.dox \
Selector.dox \
SetCollection.dox \
SharedProperty.dox \
Slice.dox \
SlotAdapter.dox \
StandardPrivateProperty.dox \
StandardRelation.dox \
StandardSharedProperty.dox \
SubSetCollection.dox \
SubTypeCollection.dox \
Symbol.dox \
Tabulation.dox \
Technology.dox \
Transformation.dox \
Unit.dox \
UpdateSession.dox \
VectorCollection.dox \
Vertical.dox \
View.dox \
Warning.dox \
ZoomCommand.dox
install-data-hook: $(DESTDIR)$(doc_en_html_hurricanedir)/index.html
$(DESTDIR)$(doc_en_html_hurricanedir)/index.html: $(doc_en_hurricane_EXTRA)
@if [ `which doxygen 2>/dev/null` ]; then \
cd $(top_srcdir)/documentation/hurricane/doc.new/images; \
for figure in DummyFig*.fig; do \
zoom="0.7"; \
case $$figure in \
DummyFig-1.fig) zoom="0.7";; \
DummyFig-2.fig) zoom="0.9";; \
esac; \
fig2dev -L png -m $$zoom $$figure `basename $$figure .fig`.png; \
fig2dev -L pdf -p dummy $$figure `basename $$figure .fig`.pdf; \
done; \
cd ..; \
cd $(top_srcdir)/documentation/hurricane/doc.new; mkdir -p en/hurricane; doxygen; \
cp asimbook.cls en/hurricane/latex; \
cp custom*.html en/hurricane/html; \
cd en/hurricane; \
$(mkinstalldirs) $(DESTDIR)$(doc_en_latex_hurricanedir); \
$(mkinstalldirs) $(DESTDIR)$(doc_en_html_hurricanedir); \
$(mkinstalldirs) $(DESTDIR)$(doc_en_rtf_hurricanedir); \
$(mkinstalldirs) $(DESTDIR)$(doc_en_man_hurricanedir)/man3; \
$(INSTALL) -m 664 latex/* $(DESTDIR)$(doc_en_latex_hurricanedir); \
$(INSTALL) -m 664 html/*.{html,css,png,tag} $(DESTDIR)$(doc_en_html_hurricanedir); \
$(INSTALL) -m 664 ../../html.entry $(DESTDIR)$(doc_en_html_hurricanedir); \
$(INSTALL) -m 664 rtf/*.rtf $(DESTDIR)$(doc_en_rtf_hurricanedir); \
$(INSTALL) -m 664 man/man3/*.3 $(DESTDIR)$(doc_en_man_hurricanedir)/man3; \
if [ -x $(datadir)/doc/en/html/generateIndex.sh ]; then \
$(datadir)/doc/en/html/generateIndex.sh --prefix=${prefix} --destdir=$(DESTDIR); \
fi \
else \
echo "warning: doxygen was not found, skipping doc generation."; \
fi
EXTRA_DIST = $(doc_en_hurricane_EXTRA)
CLEANFILES = $(doc_en_hurricane_CLEAN)

609
hurricane/doc/hurricane/Makefile.in Normal file
View File

@ -0,0 +1,609 @@
# Makefile.in generated by automake 1.9.6 from Makefile.am.
# @configure_input@
# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
# 2003, 2004, 2005 Free Software Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
srcdir = @srcdir@
top_srcdir = @top_srcdir@
VPATH = @srcdir@
pkgdatadir = $(datadir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
top_builddir = ../../..
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
INSTALL = @INSTALL@
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
subdir = documentation/hurricane/doc.new
DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/configure.in
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
mkinstalldirs = $(install_sh) -d
CONFIG_CLEAN_FILES =
SOURCES =
DIST_SOURCES =
RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \
html-recursive info-recursive install-data-recursive \
install-exec-recursive install-info-recursive \
install-recursive installcheck-recursive installdirs-recursive \
pdf-recursive ps-recursive uninstall-info-recursive \
uninstall-recursive
ETAGS = etags
CTAGS = ctags
DIST_SUBDIRS = $(SUBDIRS)
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = @ACLOCAL@
AMDEP_FALSE = @AMDEP_FALSE@
AMDEP_TRUE = @AMDEP_TRUE@
AMTAR = @AMTAR@
AR = @AR@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
CLEANER_DLL_VERSION = @CLEANER_DLL_VERSION@
CPEDITOR_DLL_VERSION = @CPEDITOR_DLL_VERSION@
CPHURRICANE_DLL_VERSION = @CPHURRICANE_DLL_VERSION@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CXX = @CXX@
CXXCPP = @CXXCPP@
CXXDEPMODE = @CXXDEPMODE@
CXXFLAGS = @CXXFLAGS@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
DEPDIR = @DEPDIR@
DROOPY_DLL_VERSION = @DROOPY_DLL_VERSION@
ECHO = @ECHO@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
EXEEXT = @EXEEXT@
EXTRACTOR_DLL_VERSION = @EXTRACTOR_DLL_VERSION@
F77 = @F77@
FFLAGS = @FFLAGS@
GENDOC_DLL_VERSION = @GENDOC_DLL_VERSION@
GTK_CFLAGS = @GTK_CFLAGS@
GTK_CONFIG = @GTK_CONFIG@
GTK_LIBS = @GTK_LIBS@
HURRICANE_DLL_VERSION = @HURRICANE_DLL_VERSION@
INSPECTOR_DLL_VERSION = @INSPECTOR_DLL_VERSION@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
LDFLAGS = @LDFLAGS@
LEX = @LEX@
LEXLIB = @LEXLIB@
LEX_OUTPUT_ROOT = @LEX_OUTPUT_ROOT@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
LN_S = @LN_S@
LTLIBOBJS = @LTLIBOBJS@
MAKEINFO = @MAKEINFO@
OBJEXT = @OBJEXT@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
RANLIB = @RANLIB@
SED = @SED@
SET_MAKE = @SET_MAKE@
SHELL = @SHELL@
STRIP = @STRIP@
VERSION = @VERSION@
YACC = @YACC@
ac_ct_AR = @ac_ct_AR@
ac_ct_CC = @ac_ct_CC@
ac_ct_CXX = @ac_ct_CXX@
ac_ct_F77 = @ac_ct_F77@
ac_ct_RANLIB = @ac_ct_RANLIB@
ac_ct_STRIP = @ac_ct_STRIP@
am__fastdepCC_FALSE = @am__fastdepCC_FALSE@
am__fastdepCC_TRUE = @am__fastdepCC_TRUE@
am__fastdepCXX_FALSE = @am__fastdepCXX_FALSE@
am__fastdepCXX_TRUE = @am__fastdepCXX_TRUE@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
datadir = @datadir@
exec_prefix = @exec_prefix@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localstatedir = @localstatedir@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
prefix = @prefix@
program_transform_name = @program_transform_name@
root_prefix = @root_prefix@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
sysconfdir = @sysconfdir@
target_alias = @target_alias@
SUBDIRS = images
doc_en_latex_hurricanedir = $(datadir)/doc/en/latex/hurricane.new
doc_en_html_hurricanedir = $(datadir)/doc/en/html/hurricane.new
doc_en_rtf_hurricanedir = $(datadir)/doc/en/rtf/hurricane.new
doc_en_man_hurricanedir = $(datadir)/man
doc_en_hurricane_CLEAN =
doc_en_hurricane_EXTRA = asimbook.cls \
header.tex \
ASIM.css \
header.html \
footer.html \
customSummary.html \
customHierarchy.html \
BasicLayer.dox \
Box.dox \
Cell.dox \
Collection.dox \
Command.dox \
Commons.dox \
Component.dox \
CompositeLayer.dox \
Contact.dox \
DataBase.dox \
DBo.dox \
Editor.dox \
Entity.dox \
Error.dox \
Exception.dox \
ExpandRules.dox \
Filter.dox \
Generalities.dox \
GenericCollection.dox \
GenericFilter.dox \
GenericLocator.dox \
Go.dox \
Hook.dox \
Horizontal.dox \
Hurricane.dox \
Instance.dox \
Interruption.dox \
Interval.dox \
Layer.dox \
Library.dox \
ListCollection.dox \
Locator.dox \
MainView.dox \
MapCollection.dox \
MapView.dox \
Name.dox \
Net.dox \
NotFilter.dox \
Occurence.dox \
Pad.dox \
Path.dox \
Pin.dox \
Plug.dox \
Point.dox \
Primitive.dox \
PrivateProperty.dox \
Property.dox \
QuadTree.dox \
Quark.dox \
Relation.dox \
Rubber.dox \
Segment.dox \
SelectCommand.dox \
SelectNetCommand.dox \
Selector.dox \
SetCollection.dox \
SharedProperty.dox \
Slice.dox \
SlotAdapter.dox \
StandardPrivateProperty.dox \
StandardRelation.dox \
StandardSharedProperty.dox \
SubSetCollection.dox \
SubTypeCollection.dox \
Symbol.dox \
Tabulation.dox \
Technology.dox \
Transformation.dox \
Unit.dox \
UpdateSession.dox \
VectorCollection.dox \
Vertical.dox \
View.dox \
Warning.dox \
ZoomCommand.dox
EXTRA_DIST = $(doc_en_hurricane_EXTRA)
CLEANFILES = $(doc_en_hurricane_CLEAN)
all: all-recursive
.SUFFIXES:
$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh \
&& exit 0; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign documentation/hurricane/doc.new/Makefile'; \
cd $(top_srcdir) && \
$(AUTOMAKE) --foreign documentation/hurricane/doc.new/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
mostlyclean-libtool:
-rm -f *.lo
clean-libtool:
-rm -rf .libs _libs
distclean-libtool:
-rm -f libtool
uninstall-info-am:
# This directory's subdirectories are mostly independent; you can cd
# into them and run `make' without going through this Makefile.
# To change the values of `make' variables: instead of editing Makefiles,
# (1) if the variable is set in `config.status', edit `config.status'
# (which will cause the Makefiles to be regenerated when you run `make');
# (2) otherwise, pass the desired values on the `make' command line.
$(RECURSIVE_TARGETS):
@failcom='exit 1'; \
for f in x $$MAKEFLAGS; do \
case $$f in \
*=* | --[!k]*);; \
*k*) failcom='fail=yes';; \
esac; \
done; \
dot_seen=no; \
target=`echo $@ | sed s/-recursive//`; \
list='$(SUBDIRS)'; for subdir in $$list; do \
echo "Making $$target in $$subdir"; \
if test "$$subdir" = "."; then \
dot_seen=yes; \
local_target="$$target-am"; \
else \
local_target="$$target"; \
fi; \
(cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
|| eval $$failcom; \
done; \
if test "$$dot_seen" = "no"; then \
$(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
fi; test -z "$$fail"
mostlyclean-recursive clean-recursive distclean-recursive \
maintainer-clean-recursive:
@failcom='exit 1'; \
for f in x $$MAKEFLAGS; do \
case $$f in \
*=* | --[!k]*);; \
*k*) failcom='fail=yes';; \
esac; \
done; \
dot_seen=no; \
case "$@" in \
distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
*) list='$(SUBDIRS)' ;; \
esac; \
rev=''; for subdir in $$list; do \
if test "$$subdir" = "."; then :; else \
rev="$$subdir $$rev"; \
fi; \
done; \
rev="$$rev ."; \
target=`echo $@ | sed s/-recursive//`; \
for subdir in $$rev; do \
echo "Making $$target in $$subdir"; \
if test "$$subdir" = "."; then \
local_target="$$target-am"; \
else \
local_target="$$target"; \
fi; \
(cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
|| eval $$failcom; \
done && test -z "$$fail"
tags-recursive:
list='$(SUBDIRS)'; for subdir in $$list; do \
test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \
done
ctags-recursive:
list='$(SUBDIRS)'; for subdir in $$list; do \
test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) ctags); \
done
ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) ' { files[$$0] = 1; } \
END { for (i in files) print i; }'`; \
mkid -fID $$unique
tags: TAGS
TAGS: tags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
tags=; \
here=`pwd`; \
if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \
include_option=--etags-include; \
empty_fix=.; \
else \
include_option=--include; \
empty_fix=; \
fi; \
list='$(SUBDIRS)'; for subdir in $$list; do \
if test "$$subdir" = .; then :; else \
test ! -f $$subdir/TAGS || \
tags="$$tags $$include_option=$$here/$$subdir/TAGS"; \
fi; \
done; \
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) ' { files[$$0] = 1; } \
END { for (i in files) print i; }'`; \
if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \
test -n "$$unique" || unique=$$empty_fix; \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
$$tags $$unique; \
fi
ctags: CTAGS
CTAGS: ctags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
tags=; \
here=`pwd`; \
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) ' { files[$$0] = 1; } \
END { for (i in files) print i; }'`; \
test -z "$(CTAGS_ARGS)$$tags$$unique" \
|| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
$$tags $$unique
GTAGS:
here=`$(am__cd) $(top_builddir) && pwd` \
&& cd $(top_srcdir) \
&& gtags -i $(GTAGS_ARGS) $$here
distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
distdir: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's|.|.|g'`; \
list='$(DISTFILES)'; for file in $$list; do \
case $$file in \
$(srcdir)/*) file=`echo "$$file" | sed "s|^$$srcdirstrip/||"`;; \
$(top_srcdir)/*) file=`echo "$$file" | sed "s|^$$topsrcdirstrip/|$(top_builddir)/|"`;; \
esac; \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
dir=`echo "$$file" | sed -e 's,/[^/]*$$,,'`; \
if test "$$dir" != "$$file" && test "$$dir" != "."; then \
dir="/$$dir"; \
$(mkdir_p) "$(distdir)$$dir"; \
else \
dir=''; \
fi; \
if test -d $$d/$$file; then \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
fi; \
cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
else \
test -f $(distdir)/$$file \
|| cp -p $$d/$$file $(distdir)/$$file \
|| exit 1; \
fi; \
done
list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
if test "$$subdir" = .; then :; else \
test -d "$(distdir)/$$subdir" \
|| $(mkdir_p) "$(distdir)/$$subdir" \
|| exit 1; \
distdir=`$(am__cd) $(distdir) && pwd`; \
top_distdir=`$(am__cd) $(top_distdir) && pwd`; \
(cd $$subdir && \
$(MAKE) $(AM_MAKEFLAGS) \
top_distdir="$$top_distdir" \
distdir="$$distdir/$$subdir" \
distdir) \
|| exit 1; \
fi; \
done
check-am: all-am
check: check-recursive
all-am: Makefile
installdirs: installdirs-recursive
installdirs-am:
install: install-recursive
install-exec: install-exec-recursive
install-data: install-data-recursive
uninstall: uninstall-recursive
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-recursive
install-strip:
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
`test -z '$(STRIP)' || \
echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
mostlyclean-generic:
clean-generic:
-test -z "$(CLEANFILES)" || rm -f $(CLEANFILES)
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean: clean-recursive
clean-am: clean-generic clean-libtool mostlyclean-am
distclean: distclean-recursive
-rm -f Makefile
distclean-am: clean-am distclean-generic distclean-libtool \
distclean-tags
dvi: dvi-recursive
dvi-am:
html: html-recursive
info: info-recursive
info-am:
install-data-am:
@$(NORMAL_INSTALL)
$(MAKE) $(AM_MAKEFLAGS) install-data-hook
install-exec-am:
install-info: install-info-recursive
install-man:
installcheck-am:
maintainer-clean: maintainer-clean-recursive
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-recursive
mostlyclean-am: mostlyclean-generic mostlyclean-libtool
pdf: pdf-recursive
pdf-am:
ps: ps-recursive
ps-am:
uninstall-am: uninstall-info-am
uninstall-info: uninstall-info-recursive
.PHONY: $(RECURSIVE_TARGETS) CTAGS GTAGS all all-am check check-am \
clean clean-generic clean-libtool clean-recursive ctags \
ctags-recursive distclean distclean-generic distclean-libtool \
distclean-recursive distclean-tags distdir dvi dvi-am html \
html-am info info-am install install-am install-data \
install-data-am install-data-hook install-exec install-exec-am \
install-info install-info-am install-man install-strip \
installcheck installcheck-am installdirs installdirs-am \
maintainer-clean maintainer-clean-generic \
maintainer-clean-recursive mostlyclean mostlyclean-generic \
mostlyclean-libtool mostlyclean-recursive pdf pdf-am ps ps-am \
tags tags-recursive uninstall uninstall-am uninstall-info-am
install-data-hook: $(DESTDIR)$(doc_en_html_hurricanedir)/index.html
$(DESTDIR)$(doc_en_html_hurricanedir)/index.html: $(doc_en_hurricane_EXTRA)
@if [ `which doxygen 2>/dev/null` ]; then \
cd $(top_srcdir)/documentation/hurricane/doc.new/images; \
for figure in DummyFig*.fig; do \
zoom="0.7"; \
case $$figure in \
DummyFig-1.fig) zoom="0.7";; \
DummyFig-2.fig) zoom="0.9";; \
esac; \
fig2dev -L png -m $$zoom $$figure `basename $$figure .fig`.png; \
fig2dev -L pdf -p dummy $$figure `basename $$figure .fig`.pdf; \
done; \
cd $(top_srcdir)/documentation/hurricane/doc.new; mkdir -p en/hurricane; doxygen; \
cp asimbook.cls en/hurricane/latex; \
cp custom*.html en/hurricane/html; \
cd en/hurricane; \
$(mkinstalldirs) $(DESTDIR)$(doc_en_latex_hurricanedir); \
$(mkinstalldirs) $(DESTDIR)$(doc_en_html_hurricanedir); \
$(mkinstalldirs) $(DESTDIR)$(doc_en_rtf_hurricanedir); \
$(mkinstalldirs) $(DESTDIR)$(doc_en_man_hurricanedir)/man3; \
$(INSTALL) -m 664 latex/* $(DESTDIR)$(doc_en_latex_hurricanedir); \
$(INSTALL) -m 664 html/*.{html,css,png,tag} $(DESTDIR)$(doc_en_html_hurricanedir); \
$(INSTALL) -m 664 ../../html.entry $(DESTDIR)$(doc_en_html_hurricanedir); \
$(INSTALL) -m 664 rtf/*.rtf $(DESTDIR)$(doc_en_rtf_hurricanedir); \
$(INSTALL) -m 664 man/man3/*.3 $(DESTDIR)$(doc_en_man_hurricanedir)/man3; \
if [ -x $(datadir)/doc/en/html/generateIndex.sh ]; then \
$(datadir)/doc/en/html/generateIndex.sh --prefix=${prefix} --destdir=$(DESTDIR); \
fi \
else \
echo "warning: doxygen was not found, skipping doc generation."; \
fi
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:

83
hurricane/doc/hurricane/MapCollection.dox Normal file
View File

@ -0,0 +1,83 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class MapCollection
* \brief MapCollection description (\b API)
*
* \section secMapCollectionIntro Introduction
*
* This collection allows you to handle a STL map as a
* collection.
*
* In priciple you don't need to handle directly this
* collection, you only need to handle a generic collection
* bound to a <b>MapCollection</b> as created by the generic
* function <b>GetCollection</b>(...) which builds one when its
* argument is a STL map (for that reason we will not describe
* it).
*
*
* \section secMapCollectionOverloadingsOfTheGetcollectionGenericFunction Overloadings of the GetCollection generic function
*
* <b>Hurricane::MapCollection::GetCollection</b>
* <b>Hurricane::MapCollection::GetCollection</b>
*
*
* \section secMapCollectionRemarks Remarks
*
* Like for the other collections, there is no copy of the
* elements included in the map, but instead a link from the
* collection to the map.
*
* Once the collection as been built, you can perfectly modify
* the map; the added or deleted elements will be taken into
* account when visiting the map, as shown in the following
* example :
\code
map<Name, Net*> netMap;
Nets nets = GetCollection(netMap);
// nets is then bound to the map netMap
// and will reflect its content until the end
// so we can :
assert(nets.IsEmpty());
Cell* cell = ... // we get a cell
if (cell) {
Net* net = cellGetNet("vdd");
if (net) {
netMap[netGetName()] = net;
// and now :
assert(nets.GetSize() == 1);
}
}
\endcode
* You can trace the collection and reach the elements of the
* map, but you can't know to which key they are associated
* (seldom useful). If this is required, you must use STL
* iterators and not this collection.
*/
/* \name Accessors
*/
// \{
/*! \function GenericCollection<Element> MapCollection::GetCollection(const map<Key, Element, Compare>& elementMap);
* \see below.
*/
/*! \function GenericCollection<Element> MapCollection::GetCollection(const map<Key, Element, Compare>* elementMap);;
* Those two function return into generic collection bound to a
* <b>MapCollection</b> the content of the STL map given in
* argument.
*/
// \}
}

62
hurricane/doc/hurricane/MapView.dox Normal file
View File

@ -0,0 +1,62 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class MapView
* \brief MapView description (\b API)
*
* \section secMapViewIntro Introduction
*
* There are two categories of views : the main views and the
* maps.
*
* The main view provides global or partial display of a cell
* while the map view (which is always attached to a main view)
* visualizes always the globality of the cell (in a simplified
* mode) and furthermore locates the part being currently
* visible within the main view.
*
* The cell displayed in the map is the one attached to the main
* view. The same holds for the transformation.
*/
/*! \section secMapViewConstructionAndDestruction Construction and destruction
*
* Maps are automatically created by their main view and
* disapear with them.
*
* So if you try to delete a map view an exception is thrown.
*/
/*! \name Accessors
*/
// \{
/*! \function MainView* MapView::GetMainView() const;
* \Return the main view associated to the map (never null).
*/
// \}
/*! \section secMapViewRemark Remark
*
* Like for all views, you can install commands on a map, but
* the reactions to the events occuring within a map must be
* sent to the main view.
*
* For instance you can define a rubber rectangle of the zoom
* command within the map, but the scale change must occur
* within the main view which will automatically update the map
* by localizing the new visible area.
*/
}

162
hurricane/doc/hurricane/Name.dox Normal file
View File

@ -0,0 +1,162 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Name
* \brief Name description (\b API)
*
* \section secNameIntro Introduction
*
* Those objects provide an automatic management of shared name
* (character strings).
*
* The underlying representation is based on a string shared by
* the different names. Each shared string is automatically
* released when the last name referencing it disapears (managed
* by a reference count technic).
*/
/*! \name Constructors
*/
// \{
/*! \function Name::Name();
* Default constructor (initialized with an empty string).
*/
/*! \function Name::Name(const char* s);
* Standard constructor, from a C like character string.
*/
/*! \function Name::Name(const string& s);
* Standard constructor, from a STL string.
*/
/*! \function Name::Name(const Name& name);
* Copy constructor.
*/
// \}
/*! \name Destructors
*/
// \{
/*! \function Name::~Name();
* The destructor releases the shared string if it no longer
* referenced.
*/
// \}
/*! \name Operators
*/
// \{
/*! \function Name& Name::operator=(const Name& name);
* Assignment operator. Very fast because there is only an
* assignement of pointer to the shared string and an
* incrementation of its reference counter.
*/
/*! \function bool Name::operator==(const Name& name) const;
* Equality operator. Very fast because it only tests the
* equality of pointers to the two shared strings (and not the
* equality of the two strings).
*
* \remark Don't loose on one side what you save on the other as shown
* in the following code :
\code
Cell* cell = ...; // we get the cell
for_each_net(net, cellGetNets()) {
if (netGetName() == "vdd") {
... ;
}
end_for;
}
\endcode
* Indeed, for each equality test, a name will be created from
* the string "vdd". If the equality test is very fast, it is
* not the same for the name construction. So it is faster to
* write :
\code
Cell* cell = ...; // we get the cell
Name vdd = "vdd";
for_each_net(net, cellGetNets()) {
if (netGetName() == vdd) {
...
}
end_for;
}
\endcode
* Or yet faster :
\code
Cell* cell = ...; // we get the cell
static Name VDD = "vdd";
for_each_net(net, cellGetNets()) {
if (netGetName() == VDD) {
...
}
end_for;
}
\endcode
*/
/*! \function bool Name::operator!=(const Name& name) const;
* Difference operator. Very fast because it only tests the
* difference of pointers to the two shared strings (and not the
* difference of the two strings).
*/
/*! \function bool Name::operator<(const Name& name) const;
* No description.
*/
/*! \function bool Name::operator<=(const Name& name) const;
* No description.
*/
/*! \function bool Name::operator>(const Name& name) const;
* No description.
*/
/*! \function bool Name::operator>=(const Name& name) const;
* Those operators need to process the two shared strings and
* are not as fast as the previous ones.
*/
/*! \function char Name::operator[](unsigned index) const;
* Indexation operator (for reading the character of rank
* index). Throws an exception if index is out of bounds.
*/
/* \function operator Name::const string& () const;
* Cast operator. In fact it returns a reference to the shared
* string (which is not modifiable [and should not be
* modified]).
*/
// \}
/*! \name Predicates
*/
// \{
/*! \function bool Name::IsEmpty () const;
* \Return \true if the shared string is empty, else \false.
*/
// \}
}

310
hurricane/doc/hurricane/Net.dox Normal file
View File

@ -0,0 +1,310 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Net
* \brief Net description (\b API)
*
* \section secNetPredefinedFilters Predefined filters
*
* <b>Hurricane::Net::GetIsGlobalFilter</b>
* <b>Hurricane::Net::GetIsExternalFilter</b>
* <b>Hurricane::Net::GetIsInternalFilter</b>
* <b>Hurricane::Net::GetIsClockFilter</b>
* <b>Hurricane::Net::GetIsSupplyFilter</b>
*/
/*! \typedef Net::Inherit
* Useful for calling upon methods of the base class without
* knowing it.
*/
/*! \typedef Net::Arity
* This type allows to represent the number of bits associated
* to a net (a null value meaning undefined).
*/
/*! \class Net::Type
* This enumeration defines the signal category. table:
* Available Signal Types headers: Name Code Signification
* slots: UNDEFINED 0 Type undefined slots: LOGICAL 1 Type
* assigned to ordinary signals slots: CLOCK 2 Type assigned to
* clock signals slots: SUPPLY 3 Type assigned to supply signals
*/
/*! \class Net::Direction
* This enumeration defines the signal direction. This direction
* is meaningful for external nets only. table: Available
* Directions headers: Name Code Signification slots: UNDEFINED
* 0 Undefined direction slots: IN 1 There must be no driver
* inside and a single permanent driver outside slots: OUT 2
* There must be no driver outside and a single permanent driver
* inside slots: INOUT 3 No constraint slots: TRISTATE 4 Type
* assigned to logical tri-states signals
*/
/*! \name Constructors
*/
// \{
/*! \function Net* Net::Create(Cell* cell, const Name& name);
* Creates and returns a new net named \c \<name\> for the cell
* \c \<cell\>.
*
* \caution Throws an exception if the cell is null, if the name empty or
* if a net with same name already exists.
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function const Name& Net::GetName() const;
* \Return the net name.
*/
/*! \function const Net::Arity& Net::GetArity() const;
* \Return the signal arity (by default set to 1).
*/
/*! \function const Net::Type& Net::GetType() const;
* \Return the signal type (by default set to UNDEFINED).
*/
/*! \function const Net::Direction& Net::GetDirection() const;
* \Return the signal direction (by default set to UNDEFINED).
*
* \remark This direction is meaningfull only for external nets.
*/
/*! \function const Point& Net::GetPosition() const;
* \Return the X,Y position of the net. This position is used for
* computing the location of the plugs (on slave instances
* calling the cell owning this net) having that net as master.
*/
/*! \function const Unit& Net::GetX() const;
* \Return net abscissa.
*/
/*! \function const Unit& Net::GetY() const;
* \Return net ordinate.
*/
/*! \function Rubbers Net::GetRubbers() const;
* \Return the collection of net's rubbers.
*/
/*! \function Components Net::GetComponents() const;
* \Return the collection of net's components.
*/
/*! \function Plugs Net::GetPlugs() const;
* \Return the collection of net's plugs.
*/
/*! \function Contacts Net::GetContacts() const;
* \Return the collection of net's contacts.
*/
/*! \function Segments Net::GetSegments() const;
* \Return the collection of net's segments.
*/
/*! \function Verticals Net::GetVerticals() const;
* \Return the collection of net's vertical segments.
*/
/*! \function Horizontals Net::GetHorizontals() const;
* \Return the collection of net's horizontal segments.
*/
/*! \function Pads Net::GetPads() const;
* \Return the collection of net's pads.
*/
/*! \function Plugs Net::GetSlavePlugs() const;
* \Return the collection of plugs which have this net as master.
*
* \remark Meaningfull only for external nets.
*/
/*! \function Plugs Net::GetConnectedSlavePlugs() const;
* \Return the collection of connected plugs which have this net as
* master.
*
* \remark Meaningfull only for external nets.
*/
/*! \function Plugs Net::GetUnconnectedSlavePlugs() const;
* \Return the collection of unconnected plugs which have this net as
* master.
*
* \remark Meaningfull only for external nets.
*/
// \}
/*! \name Predicates
*/
// \{
/*! \function bool Net::IsGlobal() const;
* \Return \true if the net is global else \false.
*/
/*! \function bool Net::IsExternal() const;
* \Return \true if the net is external else \false.
*/
/*! \function bool Net::IsLogical() const;
* \Return \true if the net is logical else \false.
*/
/* \function bool Net::IsTriState() const;
* \Return \true if the net is tri-state else \false.
*/
/*! \function bool Net::IsClock() const;
* \Return \true if the net is a clock else \false.
*/
/*! \function bool Net::IsSupply() const;
* \Return \true if the net is a supply else \false.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function void Net::SetName(const Name& name);
* Allows to change net name.
*
* \remark Throws an exception if the new name is empty, or if a net
* with same net already exists in the cell.
*/
/*! \function void Net::SetArity(const Net::Arity& arity);
* Sets the signal arity to \c \<arity\>.
*/
/*! \function void Net::SetGlobal(bool state);
* Sets global signal status to \c \<state\>.
*/
/*! \function void Net::SetExternal(bool state);
* Sets the external net status to \c \<state\>.
*
* \remark This function will throw an exception if the net switches to
* internal and there is a plug refering to it.
*/
/*! \function void Net::SetType(const Net::Type& type);
* Sets the signal type of the net.
*/
/*! \function void Net::SetDirection(const Net::Direction& direction);
* Sets the signal direction of the net.
*/
/*! \function void Net::SetPosition(const Point& position);
* Sets the X,Y location of the net. By default it is located at
* the coordinates origin of the cell (point 0,0).
*/
/*! \function void Net::Materialize();;
* Materializes all the rubbers and components of a net.
*/
/*! \function void Net::Unmaterialize();;
* De-materializes all rubbers and the components of a net.
*/
/*! \function void Net::Merge(Net* net);
* Merges the net \c \<net\> to the net \c \<this\> which keeps
* its characteristics (arity, global, external and direction).
*
* \caution An exception is thrown if the \c \<net\> is null or equal to
* \c \<this\>, if the two nets don't belong to the same cell or
* if \c \<net\> is external and master net of a connected plug
* while net \c \<this\> is not external.
*
* \remark All the rubbers and the components of the \c \<net\> (and
* also the plugs) become rubbers or components of the net
* \c \<this\>. Nevertheless if for a particular slave instance
* there was both a plug referencing the \c \<net\> and an other
* plug referencing \c \<this\>, the first is deleted to the
* advantage of the second, because a net can't have more than
* one plug for a given instance (the rings of the body hooks
* are then merged).
*
* \remark Once the merger done the net \c \<net\> is definitively
* deleted. Its properties and those of its deleted plugs, if
* any, are lost (as well as the ones which could be attached to
* their occurences).
*/
// \}
/*! \name Net Collection
*/
// \{
/*! \typedef Nets
* Generic collection representing a set of nets.
*/
/*! \typedef NetLocator
* Generic locator for traversing a collection of nets.
*/
/*! \typedef NetFilter
* Generic filter allowing to select a subset of nets matching
* some criteria.
*/
/*! \def for_each_net(net, nets)
* Macro for visiting all the nets of a collection of nets.
*/
// \}
/* \name Accessors
*/
// \{
/*! \function NetFilter Net::GetIsGlobalFilter();
* \Return the filter selecting global nets.
*/
/*! \function NetFilter Net::GetIsExternalFilter();
* \Return the filter selecting external nets.
*/
/*! \function NetFilter Net::GetIsInternalFilter();
* \Return the filter selecting internal nets.
*/
/*! \function NetFilter Net::GetIsClockFilter();
* \Return the filter selecting clock nets.
*/
/*! \function NetFilter Net::GetIsSupplyFilter();
* \Return the filter selecting supply nets.
*/
// \}
}

71
hurricane/doc/hurricane/NotFilter.dox Normal file
View File

@ -0,0 +1,71 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class NotFilter
* \brief NotFilter description (\b API)
*
* \section secNotFilterIntro Introduction
*
* This filter inverts the behaviour of an other filter.
* Accepted elements by one will be rejected by the other and
* conversely.
*
* In principle this filter is not used directly but by means of
* the operator <b>!</b> available for the filters.
*
* Therefore ther is no need to describe this filter.
*/
/*! \section secNotFilterExample Example
*
* If IsExternal is a filter for selecting the external nets of
* a cell (a possible implementation is given in the Filter
* description). Internal nets being the non external ones... In
* order to get the internal nets collection you could write :
\code
Nets Cell::GetInternalNets() const
// *******************************
{
return GetNets().GetSubSet(NotFilter<Net*>(IsExternal()));
}
\endcode
* or still better :
\code
Nets Cell::GetInternalNets() const
// *******************************
{
return GetNets().GetSubSet(!IsExternal());
}
\endcode
*/
/*! \section secNotFilterRemark Remark
*
* Most objects, as we shall see, define some practical filters.
* For instance, the nets define the filter
* <b>IsExternalFilter</b> which can be obtained by the static
* member function <b>Net::GetIsExternalFilter()</b>.
*
* The accessor <b>GetInternalNets</b> being written as follow :
\code
Nets Cell::GetInternalNets() const
// *******************************
{
return GetNets().GetSubSet(!Net::GetIsExternalFilter());
}
\endcode
* The nets provide of course the filter
* <b>IsInternalFilter</b>, but we didn't use it here in order
* to illustrate the operator <b>!</b>.
*/
}

261
hurricane/doc/hurricane/Occurence.dox Normal file
View File

@ -0,0 +1,261 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Occurrence
* \brief Occurrence description (\b API)
*
* \section secOccurrenceIntro Introduction
*
* Occurrences are objects providing the capability to designate
* any entity of the hierarchical assembly as if this one was
* virtually unfolded.
*
* For that purpose they handle, on one side the referenced
* entity and on the other side the hierarchical instanciation
* path which refers to the cell containing this entity.
*
* Those occurrences are handy, volatile and very light objects.
* Two different occurrences may designate the same entity of the
* virtually unfolded data structure, simplifying the creation
* and deletion of those objects.
*/
/*! \section secOccurrenceProperties Properties
*
* Anyway it is possible to attach properties to each occurrence.
*
* Of course, those properties are securely stored in order to
* access them unambiguously.
*
* Therefore, if a property is placed on an occurrence, we have
* access to it from a different occurrence provided it
* designates the same entity of the virtually unfolded data
* structure.
*/
/*! \section secOccurrenceTerminology Terminology
*
* An occurrence is said invalid if it refers no entity.
*
* When it is valid, an occurrence has : an <b>OwnerCell</b>
* which is either the cell owning the path if this one is non
* void, else the cell owning the entity itself. and a
* <b>MasterCell</b> which is always the cell owning the entity.
*/
/*! \name Constructors
*/
// \{
/*! \function Occurrence(Entity* entity = NULL);
* Builds an occurrence refering to an entity through a void
* path, in some way it is equivalent to the entity itself.
*
* \remark If the entity is null the occurrence is invalid.
*/
/*! \function Occurrence(Entity* entity, const Path& path);
* Builds an occurrence refering to an entity through a path
* (possibly void).
*
* \caution If the entity is null or if the path is uncompatible with the
* entity, an exception is thrown.
*
* \remark The entity and the path are compatible if the path is void or
* if the master cell of the path is the cell owning the entity.
*/
/*! \function Occurrence(const Occurrence& Occurrence);
* Copy constructor.
*/
// \}
/*! \name Destructors
*/
// \{
/*! \function Occurrence::~Occurrence();
* No description.
*/
// \}
/*! \name Operators
*/
// \{
/*! \function Occurrence& Occurrence::operator=(const Occurrence& occurrence);
* Assignment operator.
*/
/*! \function bool Occurrence::operator==(const Occurrence& occurrence) const;
* Two occurrences are equal if both are valid and refer to the
* same entity and have indentical instanciation pathes.
*/
/*! \function bool Occurrence::operator!=(const Occurrence& occurrence) const;
* Two occurrences are different if a least one is either invalid
* or both don't refer to the same entity or have differing
* instanciation pathes.
*/
/*! \function bool Occurrence::operator<(const Occurrence& occurrence) const;
* This comparator has no particular signification. It is just
* defined to be abble to use a STL set of occurrences which need
* a comparator.
*/
// \}
/*! \section secOccurrenceRemarks Remarks
*
* All constructors, the destructor and the different operators
* are very efficient.
*/
/*! \name Accessors
*/
// \{
/*! \function Entity* Occurrence::GetEntity() const;
* \Return the referenced entity or NULL if the occurrence is invalid.
*/
/*! \function const Path& Occurrence::GetPath() const;
* \Return the hierarchical instanciation path of the occurrence
* (possibly void, but always void when the occurrence id
* invalid).
*/
/*! \function Cell* Occurrence::GetOwnerCell() const;
* \Return the owner cell of the occurrence or NULL if the occurrence is
* invalid.
*/
/*! \function Cell* Occurrence::GetMasterCell() const;
* \Return the cell owning the referenced entity or NULL if the
* occurrence is invalid.
*/
/*! \function Property* Occurrence::GetProperty(const Name& name) const;
* \Return the property named \c \<name\> if it exists or NULL if not
* (or if the occurrence is invalid).
*/
/*! \function Properties Occurrence::GetProperties() const;
* \Return the collection of properties attached to the occurrence
* (always empty if the occurrence is invalid).
*/
/*! \function Box Occurrence::GetBoundingBox() const;
* \Return the bounding box of the occurrence (within the coordinate
* sysem of the owner cell) if it is valid or else the empty
* box.
*/
// \}
/*! \name Predicates
*/
// \{
/*! \function bool Occurrence::IsValid() const;
* \Return \true if the occurrence is valid, else \false (the occurrence
* refers no entity).
*/
/*! \function bool Occurrence::HasProperty() const;
* \Return \true if the occurrence owns some property else \false.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function void Occurrence::Put(Property* property);
* Adds the property \c \<property\> to the occurrence property
* set. The property being named, if another property already
* exists in the set it will be, in a first step, detached from
* this set.
*
* \remarks Does nothing if the occurrence already owns this property
* object.
*
* \caution If the occurrence is invalid or the property null, an
* exception is thrown.
*/
/*! \function void Occurrence::Remove(Property* property);
* Removes the property \c \<property\> from the occurrence
* property set.
*
* \remark Does nothing if the occurrence doesn't own this property
* object.
*
* \caution If the occurrence is invalid or the property null, an
* exception is thrown.
*/
/*! \function void Occurrence::RemoveProperty(const Name& name);
* Removes the property of name \c \<name\> if it exists.
*
* \caution If the occurrence is invalid an exception is thrown.
*/
/*! \function void Occurrence::ClearProperties();
* Removes all properties attached to the occurrence. As a
* consequence, the occurrence is deleted.
*
* \caution If the occurrence is invalid an exception is thrown.
*/
// \}
/*! \section secOccurrenceNouveauxTypesGlobaux Nouveaux types globaux
*
* type: <b>Occurrences</b> -\> Collection\<Occurrence*\>
* Collection representing a set of occurrences.
*
* type: <b>OccurrenceLocator</b> -\>
* GenericLocator\<Occurrence*\> Locator for traversing a set of
* occurrences.
*
* type: <b>OccurrenceFilter</b> -\> GenericFilter\<Occurrence*\>
* Filter for selecting a subset of occurrences matching some
* criteria.
*/
/*! \name Occurrence Collection
*/
// \{
/*! \def for_each_occurrence(occurrence, occurrences)
* Macro for visiting all occurrences of an occurrence collection.
*/
// \}
}

255
hurricane/doc/hurricane/Occurrence.dox Normal file
View File

@ -0,0 +1,255 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Occurrence
* \brief Occurrence description (\b API)
*
*
* \section secOccurrenceIntro Introduction
*
* Occurrences are objects providing the capability to designate
* any entity of the hierarchical assembly as if this one was
* virtually unfolded.
*
* For that purpose they handle, on one side the referenced
* entity and on the other side the hierarchical instanciation
* path which refers to the cell containing this entity.
*
* Those occurrences are handy, volatile and very light objects.
* Two different occurrences may designate the same entity of the
* virtually unfolded data structure, simplifying the creation
* and deletion of those objects.
*
*
* Anyway it is possible to attach properties to each occurrence.
*
* Of course, those properties are securely stored in order to
* access them unambiguously.
*
* Therefore, if a property is placed on an occurrence, we have
* access to it from a different occurrence provided it
* designates the same entity of the virtually unfolded data
* structure.
*
*
* \section secOccurrenceTerminology Terminology
*
* An occurrence is said invalid if it refers no entity.
*
* When it is valid, an occurrence has : an <b>OwnerCell</b>
* which is either the cell owning the path if this one is non
* void, else the cell owning the entity itself. and a
* <b>MasterCell</b> which is always the cell owning the entity.
*
*
* \section secOccurrenceRemarks Remarks
*
* All constructors, the destructor and the different operators
* are very efficient.
*
*/
/*! \name Constructors
*/
// \{
/*! \function Occurrence::Occurrence(const Entity* entity = NULL);
* Builds an occurrence refering to an entity through a void
* path, in some way it is equivalent to the entity itself.
*
* \remark If the entity is null the occurrence is invalid.
*/
/*! \function Occurrence::Occurrence(const Entity* entity, const Path& path);
* Builds an occurrence refering to an entity through a path
* (possibly void).
*
* \caution If the entity is null or if the path is uncompatible with the
* entity, an exception is thrown.
*
* \remark The entity and the path are compatible if the path is void or
* if the master cell of the path is the cell owning the entity.
*/
/*! \function Occurrence::Occurrence(const Occurrence& Occurrence);
* Copy constructor.
*/
// \}
/*! \name Destructors
*/
// \{
/* \function Occurrence::~Occurrence();
* No description.
*/
// \}
/*! \name Operators
*/
// \{
/*! \function Occurrence& Occurrence::operator=(const Occurrence& occurrence);
* Assignment operator.
*/
/*! \function bool Occurrence::operator==(const Occurrence& occurrence) const;
* Two occurrences are equal if both are valid and refer to the
* same entity and have indentical instanciation pathes.
*/
/*! \function bool Occurrence::operator!=(const Occurrence& occurrence) const;
* Two occurrences are different if a least one is either invalid
* or both don't refer to the same entity or have differing
* instanciation pathes.
*/
/*! \function bool Occurrence::operator<(const Occurrence& occurrence) const;
* This comparator has no particular signification. It is just
* defined to be abble to use a STL set of occurrences which need
* a comparator.
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function Entity* Occurrence::GetEntity() const;
* \Return the referenced entity or NULL if the occurrence is invalid.
*/
/*! \function const Path& Occurrence::GetPath() const;
* \Return the hierarchical instanciation path of the occurrence
* (possibly void, but always void when the occurrence id
* invalid).
*/
/*! \function Cell* Occurrence::GetOwnerCell() const;
* \Return the owner cell of the occurrence or NULL if the occurrence is
* invalid.
*/
/*! \function Cell* Occurrence::GetMasterCell() const;
* \Return the cell owning the referenced entity or NULL if the
* occurrence is invalid.
*/
/*! \function Property* Occurrence::GetProperty(const Name& name) const;
* \Return the property named \c \<name\> if it exists or NULL if not
* (or if the occurrence is invalid).
*/
/*! \function Properties Occurrence::GetProperties() const;
* \Return the collection of properties attached to the occurrence
* (always empty if the occurrence is invalid).
*/
/*! \function Box Occurrence::GetBoundingBox() const;
* \Return the bounding box of the occurrence (within the coordinate
* sysem of the owner cell) if it is valid or else the empty
* box.
*/
// \}
/*! \name Predicates
*/
// \{
/*! \function bool Occurrence::IsValid() const;
* \Return \true if the occurrence is valid, else \false (the occurrence
* refers no entity).
*/
/*! \function bool Occurrence::HasProperty() const;
* \Return \true if the occurrence owns some property else \false.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function void Occurrence::Put(Property* property);
* Adds the property \c \<property\> to the occurrence property
* set. The property being named, if another property already
* exists in the set it will be, in a first step, detached from
* this set.
*
* \remarks Does nothing if the occurrence already owns this property
* object.
*
* \caution If the occurrence is invalid or the property null, an
* exception is thrown.
*/
/*! \function void Occurrence::Remove(Property* property);
* Removes the property \c \<property\> from the occurrence
* property set.
*
* \remark Does nothing if the occurrence doesn't own this property
* object.
*
* \caution If the occurrence is invalid or the property null, an
* exception is thrown.
*/
/*! \function void Occurrence::RemoveProperty(const Name& name);
* Removes the property of name \c \<name\> if it exists.
*
* \caution If the occurrence is invalid an exception is thrown.
*/
/*! \function void Occurrence::ClearProperties();
* Removes all properties attached to the occurrence. As a
* consequence, the occurrence is deleted.
*
* \caution If the occurrence is invalid an exception is thrown.
*/
// \}
/*! \name Occurrence Collection
*/
// \{
/*! \typedef Occurrences
* Collection representing a set of occurrences.
*/
/*! \typedef OccurrenceLocator
* Locator for traversing a set of occurrences.
*/
/*! \typedef OccurrenceFilter
* Filter for selecting a subset of occurrences matching some
* criteria.
*/
/*! \def for_each_occurrence(occurrence, occurrences)
* Macro for visiting all occurrences of an occurrence collection.
*/
// \}
}

57
hurricane/doc/hurricane/Pad.dox Normal file
View File

@ -0,0 +1,57 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Pad
* \brief Pad description (\b API)
*
* \section secPadIntro Introduction
*
* A pad is an object representing a layout rectangle.
*/
/*! \typedef Pad::Inherit
* Useful for calling upon methods of the base class without
* knowing it.
*/
/*! \name Constructors
*/
// \{
/*! \function Pad* Pad::Create(Net* net, Layer* layer, const Box& boundingBox);
* No description.
*/
// \}
/*! \name Pad Collection
*/
// \{
/*! \typedef Pads
* Generic collection representing a set of pads.
*/
/*! \typedef PadLocator
* Generic locator for traversing a collection of pads.
*/
/*! \typedef PadFilter
* Generic filter allowing to select a subset of pads matching
* some criteria.
*/
/*! \def for_each_pad(pad, pads)
* Macro for visiting all the pads of a collection of pads.
*/
// \}
}

248
hurricane/doc/hurricane/Path.dox Normal file
View File

@ -0,0 +1,248 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Path
* \brief Path description (\b API)
*
* \section secPathIntro Introduction
*
* Pathes are objects representing an ordered sequence of
* instances through the hierarchy.
*
* They are represented by a head instance which defines the
* path start and tail path which defines the remaining path
* with respect to the cell model referenced by the head
* instance.
*
* terminology A non void path begins by an instance : this
* instance pertains to the top caller cell, named OwnerCell. On
* the other hand the path ends by an instance (which may be the
* same) : this instance refers to its model which will be named
* the MasterCell.
*
*
* \section secPathRemarks Remarks
*
* The different constructors (appart the one which analyses the
* names of the path) as welle as the destructor and the
* different operators are very efficient because the tail
* pathes being shared, only pointer assignments and pointer
* comparisons are realized.
*/
/*! \name Constructors
*/
// \{
/*! \function Path::Path(SharedPath* sharedPath=NULL);
* Default constructor : the path is then void.
*
* \remark This path has no instance and will be the tail terminal path
* of any other path.
*/
/*! \function Path::Path(Instance* instance);
* Builds the path made up of this unique instance.
*
* \caution If the instance is null an exception is thrown.
*/
/*! \function Path::Path(Instance* headInstance, const Path& tailPath);
* Builds the path with head instance \c \<headInstance\> and
* tail path \c \<tailPath\>.
*
* \caution If the instance is null, or if the tail path is not
* compatible with this head instance, an exception is thrown.
*
* \remark The head instance and the tail path are compatible if the
* tail path is void or if the owner cell of the tail path is
* the model cell referenced by the head instance.
*/
/*! \function Path::Path(const Path& headPath, Instance* tailInstance);
* Builds the path with head path \c \<headPath\> and tail
* instance \c \<tailInstance\>.
*
* \caution If the tail instance is null, or if the head path is not
* compatible with this tail instance, an exception is thrown.
*
* \remark The tail instance and the head path are compatible if the
* owner cell of the tail instance is the master cell of the
* head path (which is recall it, the model cell referenced by
* the last instance of the head path) or if the head path is
* empty (then compatible with any non null instance).
*/
/*! \function Path::Path(Cell* cell, const string& pathName);
* Builds the path representing the logic sequence of instance
* names described as a character string. Each instance name is
* separated from the preceeding one by a special delimiter
* (which can be defined with the function
* <b>SetPathNameSeparator</b> to be defined later). The cell
* given in argument defines where sarts the search (at each new
* instance identified, we go to its model cell to pursue the
* search within the \c \<pathName\>).
*
* \caution If the cell is null or if the name doesn't correspond to an
* existing hierarchical instanciation path an exception is
* thrown.
*/
/*! \function Path::Path(const Path& path);
* Copy constructor.
*/
// \}
/*! \name Destructors
*/
// \{
/*! \function Path::~Path();
* No description.
*/
// \}
/*! \name Operators
*/
// \{
/*! \function Path& Path::operator=(const Path& path);
* Assignment operator.
*/
/*! \function bool Path::operator==(const Path& path) const;
* Two pathes are equal if they have the same head instance and
* if their tail pathes are equal.
*/
/*! \function bool Path::operator!=(const Path& path) const;
* Two pathes are differents either if they have different head
* instance or if the tail pathes differ.
*/
/*! \function bool Path::operator<(const Path& path) const;
* This comparator has no particular signification. It is just
* defined to be abble to use a STL set of pathes which need a
* comparator.
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function Instance* Path::GetHeadInstance() const;
* \Return the head instance or NULL if the path is void.
*/
/*! \function Path Path::GetTailPath() const;
* \Return the tail path or a void path if the path has 1 or 0
* hierarchical depth.
*/
/*! \function Path Path::GetHeadPath() const;
* \Return the head path or a void path if the path has 1 or 0
* hierarchical depth.
*/
/*! \function Instance* Path::GetTailInstance() const;
* \Return the tail instance or NULL if the path is void.
*/
/*! \function string Path::GetName() const;
* \Return a string defined by the concatenation of instance names
* separated by a special character (which can be set up by the
* function <b>SetPathNameSeparator</b>).
*
* \Return the string <b>""</b> when the path is void.
*/
/*! \function Cell* Path::GetOwnerCell() const;
* Retruns the cell owning the head instance or NULL if the path
* is void.
*/
/*! \function Cell* Path::GetMasterCell() const;
* \Return the master cell referenced by the last instance of the path
* or NULL if the path is void.
*/
/*! \function Instances Path::GetInstances() const;
* \Return the collection of instances defining the path.
*/
/*! \function Transformation Path::GetTransformation(const Transformation& transformation = Transformation()) const;
* \Return the transform resulting of the composition of all transforms
* associated with the different instances of the path, applied
* to the given \c \<transformation\>.
*/
// \}
/*! \name Predicates
*/
// \{
/*! \function bool Path::IsEmpty() const;
* \Return \true if the path is void and else \false.
*/
// \}
/*! \name Path Functions
*/
// \{
/*! \function char Path::GetNameSeparator();
* \Return the special character used as a separator between the
* instance names of a path. By default it is the '.' (point).
*/
/*! \function void Path::SetNameSeparator(char separator);
* This function sets the special character used as a separator
* between the instance names of a path (choose it carrefully,
* it must not appear in any instance name).
*/
// \}
/*! \name Path Collection
*/
// \{
/*! \typedef Pathes
* Collection representing a set of pathes.
*/
/*! \typedef PathLocator
* Locator for traversing a collection of pathes.
*/
/*! \typedef PathFilter
* Filter for selecting a subset of pathes matching some
* criteria.
*/
/*! \def for_each_path(path, pathes)
* Macro for visiting all pathes of a path collection.
*/
// \}
}

12
hurricane/doc/hurricane/Pin.dox Normal file
View File

@ -0,0 +1,12 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Pin
* \brief Pin description (\b API)
*
*/
}

142
hurricane/doc/hurricane/Plug.dox Normal file
View File

@ -0,0 +1,142 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Plug
* \brief Plug description (\b API)
*
* \section secPlugIntro Introduction
*
* A plug can be assimilated to a "logical port instance" : it
* designates both the concerned instance and the net of the
* model cell instanciated to which it is connected. This net,
* which must be an external net, will be named "<b>master
* net</b>" because it is a net of the instance master cell
* (notice that this net can be asimilated to a "logical port").
*
* A plug is unique, that is, for a given instance there is one
* and only one plug refering to a given master net.
*
* \caution When created, an instance creates all plugs corresponding to
* the external nets of its master cell. So, some plugs may
* exist without being connected. Plugs are the only components
* which have this characteristic.
*
* \remark Plugs being completely managed by the system, you can't
* define sub-types of plugs.
*
*
* \section secPlugConstructors Constructors \& Destructors
*
* Plugs being completely managed by the system, there is no
* constructor nor destructor provided.
*
*
* \section secPlugPredefinedFilters Predefined filters
*
*
* <b>Hurricane::Plug::GetIsConnectedFilter</b>
* <b>Hurricane::Plug::GetIsUnconnectedFilter</b>
*/
/*! \typedef Plug::Inherit
* Useful for calling upon methods of the base class without
* knowing it.
*/
/*! \name Accessors
*/
// \{
/*! \function Instance* Plug::GetInstance() const;
* \Return the instance to which belongs the plug.
*/
/*! \function Net* Plug::GetMasterNet() const;
* \Return the external net referenced by the plug in the master cell of
* its instance.
*
* \remark Don't mistake with GetNet() which returns the net owning the
* plug (or NULL if is unconnected).
*/
// \}
/*! \name Predicates
*/
// \{
/*! \function bool Plug::IsConnected() const;
* \Return \true if the plug is connected, else \false.
*
* \remark A plug is connected if the call upon <b>GetNet()</b> doesn't
* return NULL.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function void Plug::SetNet(Net* net);
* This method allows to connect or change the net of a plug.
*
* \caution An exception is thrown if the net owner cell differs from the
* plug owner cell, or if there are components (contact,
* segments, ...) currently anchored on the plug.
*
* \remark The properties attached to this plug and its occurences are
* left unchanged.
*/
// \}
/*! \name Plug Collection
*/
// \{
/*! \typedef Plugs
* Generic collection representing a set of plugs.
*/
/*! \typedef PlugLocator
* Generic locator for traversing a collection of plugs.
*/
/*! \typedef PlugFilter
* Generic filter allowing to select a subset of plugs matching
* some criteria.
*/
/*! \def for_each_plug(plug, plugs)
* Macro for visiting all the plugs of a collection of plugs.
*/
// \}
/* \name Accessors
*/
// \{
/*! \function PlugFilter Plug::GetIsConnectedFilter();
* \Return a filter for selecting only connected plugs.
*/
/*! \function PlugFilter Plug::GetIsUnconnectedFilter();
* \Return a filter for selecting only unconnected plugs.
*/
// \}
}

70
hurricane/doc/hurricane/Point.dox Normal file
View File

@ -0,0 +1,70 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Point
* \brief Point description (\b API)
*
*/
/*! \name Constructors
*/
// \{
/*! \function Point::Point();
* Default constructor.
*/
/*! \function Point::Point(const Unit& x, const Unit& y);
* Creates the point defined by x and y coordinates.
*/
/*! \function Point::Point(const Point& point);
* Copy constructor.
*/
// \}
/*! \name Operators
*/
// \{
/*! \function Point& Point::operator=(const Point& point);
* Assignment operator.
*/
/*! \function bool Point::operator==(const Point& point) const;
* Equality operator.
*/
/*! \function bool Point::operator!=(const Point& point) const;
* Difference operator.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function void Point::SetX(const Unit& x);
* Modifies point abscissa.
*/
/*! \function void Point::SetY(const Unit& y);
* Modifies point ordinate.
*/
/*! \function Point& Point::Translate(const Unit& dx, const Unit& dy);
* Translates the point of dx and dy.
*/
// \}
}

12
hurricane/doc/hurricane/Primitive.dox Normal file
View File

@ -0,0 +1,12 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Primitive
* \brief Primitive description (\b API)
*
*/
}

85
hurricane/doc/hurricane/PrivateProperty.dox Normal file
View File

@ -0,0 +1,85 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class PrivateProperty
* \brief PrivateProperty description (\b API)
*
* \section secPrivatePropertyIntro Introduction
*
* Private properties are owned by only one data base object.
*
* When a new property is created, it is not yet assigned to any
* particular object. It becomes effectively the property of an
* object after the call <b>dbo-\>Put(property)</b>. The
* property then receives a message <b>OnCapturedBy</b> whose
* argument is the additional owner. From that time onwards,
* this object becomes partially responsible of the future of
* the property.
*
* <b>What can happen then ?</b>
*
* If the property is destroyed : The property, being private,
* informs its owner (if any) of its deletion which detaches it
* from its property list (if the object is a quark and if this
* was the last property owned, it has no more reason to exist
* and automatically deletes itself).
*
* If a property of same name already exist : Two properties
* with the same name can't cohabit, the older one is released
* by the object which receives the message <b>OnReleasedBy</b>
* from that old property and proceeds as required according to
* the type of property.
*
* If the property changes of owner : This one is first captured
* by the new owner and the released by the older owner (the
* reason why messages are called upon in this order will be
* explained later).
*
* If the property owner is destroyed : All properties owned by
* the object are then released. The future of each of those
* properties is fully driven by their respective messages
* <b>OnReleasedBy</b>.
*/
/*! \typedef typedef PrivateProperty::Inherit Property;
* Useful for calling upon methods of the base class without
* knowing it.
*/
/*! \section secPrivatePropertyDestruction Destruction
*
* The property has an owner, this one is informed of the
* property deletion and detaches it from its property list. If
* the object is a quark and if this was the last property owned
* it automatically deletes itself.
*
* \remark Once the property is attached to an object this one becomes
* responsible of its automatic destruction. When a property
* changes its owner, the old owner delegates this task to the
* new one. On the other hand, a property which has never been
* attached to an owner will never be deleted automatically.
*/
/*! \name Accessors
*/
// \{
/*! \function DBo* PrivateProperty::GetOwner() const;
* \Return the current owner of the property (or NULL if at not been
* assigned yet).
*/
// \}
/*! \name Messages
*/
// \{

438
hurricane/doc/hurricane/Property.dox Normal file
View File

@ -0,0 +1,438 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Property
* \brief Property description (\b API)
*
* \section secPropertyIntro Introduction
*
* Properties can be attached to the data base objects. Those
* properties must have a name in order to access them
* unambiguously. Of course only one property of a given name
* can be attached to an object.
*
* In a first step we define two great categories of properties
* : the private properties which can be attached to only one
* object and the shared properties which can be attached to a
* large number of objects.
*
* We will detail separately their respective behaviour, but we
* ensure that the management of each of those two property
* categories is absolutely secure. That is, on one side you can
* destroy explicitely a property (and the objects will be
* notified) and on the other side the properties will be
* automatically destroyed when no more object reference them.
*
* \remark By overloading some messages, as we will see later, it is
* possible to set up different behaviours (like avoid the
* automatic delete).
*
*
* \section secPropertyTheQuarks The Quarks
*
* As we shall see, the occurences are very simple objects which
* are used to designate some entity of the virtually unfolded
* hierarchy. Indeed, those occurences, which are built and
* deleted very quickly, are very volatile objects to which
* obvioulsy we can't attach properties directly.
*
* But the interest of occurences is precisely to be able to
* attach them properties. In order to be able to do that,
* properties must be stored in a secure place where we could
* find them when needed. The quarks are here for that purpose :
* they are subtypes of data base object and therefore can store
* the properties attached to occurences.
*
* \important Only one quark is attached to all occurences which refer the
* same entity of the virtually unfolded hierarchy. This means
* that a property placed on an occurence can be read by any
* other occurence which refers the same entity of the virtually
* unfolded hierarchy.
*
* \remark Those quarks are also volatile objects because their only
* reason to exist is that at least one property is attached to
* them.
*
*
* \section secPropertyHowThatWorks How that works
*
* We will detail the way properties are managed by analysing
* more precisely what happens at the level of property access
* functions both for data base objects and for occurences.
*
*
* <b>Accessing a property by its name</b>
\code
Property* DBo::GetProperty(const Name& name) const;
\endcode
* This member function returns the property of name \c \<name\>
* if there is one attached to the object, else NULL.
\code
Property* Occurrence::GetProperty(const Name& name) const;
\endcode
* This function searches in a first time the quark representing
* the occurence.
*
* If the quark doesn't exist, this means there is no property
* attached to that occurence, then the function returns NULL.
*
* If the quark does exist, the function returns the property of
* name \c \<name\> attached to the quark, if any, by calling
* the previous function (because quarks are data base objects).
*
*
* <b>Accessing the set of all properties</b>
\code
Properties DBo::GetProperties() const;
\endcode
* Return the collection of properties attached to the object (possibly
* empty).
\code
Properties Occurrence::GetProperties() const;
\endcode
* This function searches in a first time the quark representing
* the occurence.
*
* If the quark doesn't exist, this means there is no property
* attached to that occurence, then the function returns an
* empty property collection.
*
* If the quark does exist, the function returns the property
* collection attached to the quark, by calling the previous
* function (the returned collection is inevitably non empty,
* else the quark would not exist).
*
*
* <b>Does the object have properties ?</b>
\code
bool DBo::HasProperty() const;
\endcode
* Return \true if the object owns at least a property, else \false.
\code
bool Occurrence::HasProperty() const;
\endcode
* This function searches the quark representing the occurence.
*
* If the quark does exist it means there is at least a property
* assigned to it and the function returns \true, else it
* returns \false.
*
*
* <b>Adding a property : things becomes a little harder</b>
\code
void DBo::Put(Property* property);
\endcode
* Adds the property \c \<property\> to the set of properties of
* the object.
\code
void Occurence::Put(Property* property);
\endcode
* This function searches the quark representing the occurence.
*
* If the quark doesn't exist it is automatically created in
* order to attach this first property.
*
* Once the quark has been got or created, we can add the
* property with the previous function.
*
* Two important things might happen then : The property is
* already owned by an other object (may be a quark) and that
* property is not a shared one <b>and/or</b> the object owns
* already a property with the same name.
*
* Therefore it may happen, within this step, that adding a
* property to an object leads to the deletion of an other
* property on that object <b>(name unicity)</b> or on an other
* object <b>(unicity of owner for a private property)</b>.
*
* Which behaviour should we have in such conditions ? Shall we
* destroy the property which has been detached ? There is no
* unique behaviour which matches all needs. In order to solve
* this problem the properties must answer to two specific
* messages which are : <b>OnCapturedBy(DBo* dbo)</b> when the
* property is attached to an object and <b>OnReleasedBy(DBo*
* dbo)</b> when it is detached from the object. It is within
* that last message that the decision about the future of the
* property must be taken.
*
* \remark We will detail below those messages for both private and
* shared properties.
*
*
* <b>Removing a property</b>
\code
void DBo::Remove(Property* property);
\endcode
* Removes the property \c \<property\> from the set of
* properties of the object.
\code
void Occurence::Remove(Property* property);
\endcode
* The function searches for the quark associated to the
* occurence.
*
* If the quark doesn't exist, there is nothing to do, the
* occurence has no properties.
*
* Else the property is removed from the set of quark properties
* by calling the previous function. Furthermore if this removed
* property is the last one, the quark is automatically deleted.
*
* \important The message <b>OnReleasedBy</b> is called upon as explained
* above. This call will decide of the future of the removed
* property.
*
*
* <b>Clearing all properties</b>
\code
void DBo::ClearProperties();
\endcode
* Removes all properties attached to the object.
\code
void Occurence::ClearProperties();
\endcode
* First searches for the quark associated to the occurence.
*
* If the quark exist it is simply destroyed after removing all
* its private properties and detaching it from all its shared
* properties (wich may lead to their removal). Without quark
* the occurence looses all its properties.
*
* \important Here again the message <b>OnReleasedBy</b> is called upon for
* each removed property.
*
*
* \section secPropertyCreationProcess Creation process
*
* The creation process is similar to the data base objects
* creation one. Therefore a property must be created by the
* special function <b>Create</b> and not by the usual new
* (which is not available).
*
*
* \section secPropertyDeletionProcess Deletion process
*
* <b>Hurricane::Property::Delete</b>
*
*
* \section secPropertyNaming Naming Conventions
*
* Properties being named and the their management being based
* on that name, it could occur conflicts between Hurricane
* which use some properties and the different tools which will
* be plugged above, or between different tools themselves.
*
* In order to avoid that you must take some precautions in the
* choice of the property names.
*
* So Hurricane uses properties prefixed by the string
* "Hurricane::",like for instance "Hurricane::Selector" for the
* property of type Selector.
*
* So I suggest that different tools use a
* similar namming strategy which would keep confident all the
* community of <b><i>hurricaners</i></b>
*
* \remark Using names like "ZenTek::TimingNode" for the TimingNode type
* property managed by tools from the ZenTek society decreases
* name conflicts, unless with other tools from the same
* society. A property name
* "SocietyName::ToolName::PropertyName" would be more secure.
*
* Furthermore, if the community adopts this convention it will
* be possible to simplify some parts of the code by avoiding
* for example calls to the macro <b>is_a</b> to check that the
* collected property is of the expected type, as shown in the
* following example :
\code
Property* property = occurence.GetProperty("Hurricane::Selector");
if (property && is_a<Selector*>(property)) {
Selector* selector = (Selector*)property;
...
}
\endcode
* Which could become :
\code
Selector* selector = (Selector*)occurence.GetProperty("Hurricane::Selector");
if (selector) {
...
}
\endcode
*
*
* \section secPropertyRemarks Remarks
*
* The name of properties being of type Name and not of type
* string, the comparison between two names operates on their
* pointers and not on their character strings. The length of
* the name doesn't affect the comparison performance.
*
* On the other hand, the time to create a property name depends
* obviously of its length and of the number of names (which
* fortunately are managed by efficient map containers).
*
* Therefore in order to avoid building names at each property
* access, you must provide a specific function which returns a
* Name object allocated once and once only.
*
* As a matter of fact if you write, like in the previous
* example :
\code
Property* property = occurence.GetProperty("Hurricane::Selector");
\endcode
* Each time the name is built and this will degrade
* performance.
*
* On the other hand if the following static member function is
* provided :
\code
const Name& Selector::GetPropertyName()
// ************************************
{
static Name NAME = "Hurricane::Selector";
return NAME;
}
\endcode
* You could write later :
\code
Property* property = occurence.GetProperty(Selector::GetPropertyName());
\endcode
* This approach is much more efficient and presents an other
* interest : you don't need to know the name of the property
* being handled. This allows to change property names without
* affecting existing code.
*
* Therefore I propose, for every new
* instanciable property (whose name depends of the property
* type), that a static member function be systematically
* provided.
*
* Furthermore, both StandardPrivateProperty and
* StandardSharedProperty have, as we shall see later, an
* attribute giving their name. Here again, for accessing the
* propety, a name must be created.
*
* So I propose also that a global
* function (which can't be a static member function) be defined
* for each new property name.
*
* That way, by defining (i.e. for the property ObjectId) the
* function :
\code
const Name& GetObjectIdPropertyName()
// **********************************
{
static Name NAME = "Hurricane::ObjectId";
return NAME;
}
\endcode
* You can write later :
\code
Property* property = occurence.GetProperty(GetObjectIdPropertyName());
\endcode
*/
/*! \name Accessors
*/
// \{
/*! \function Name Property::GetName() const;
* \Return the name of the property : this method must absolutely be
* overloaded for all new property classes, because the property
* name is not a "wired in" attribute. A property being a real
* object, this name derives naturally from the property type
* name (so don't loose room uselessly to store it in a record
* slot).
*/
// \}
/*! \name Messages
*/
// \{
/*! \function void Property::OnCapturedBy(DBo* dbo);
* This message is called upon when the property is added to the
* properties of \c \<dbo\>.
*
* By default this function does nothing particular, but it must
* be overloaded for all property sub-classes. We will detail
* later the reaction to this message as taken by the private
* and shared property classes.
*
* \remark This message being already overloaded for private and shared
* property classes there is no need to overload it again when
* specializing any of those two classes.
*/
/*! \function void Property::OnReleasedBy(DBo* dbo);
* This message is called upon when the property is removed from
* the \c \<dbo\> properties.
*
* \important The argument \c \<dbo\> is not (or no more) necessarily the
* owner of the property which receives the message. The
* processing to be done in reaction to this message often
* depends on this observation. We will better understand this
* subtlety when studying private properties.
*
* \remark This message being already overloaded for private and shared
* property classes there is no need to overload it again when
* specializing any of those two classes.
*/
// \}
/*! \name Property Collection
*/
// \{
/*! \typedef Properties
* Generic collection representing a set of properties.
*/
/*! \typedef PropertyLocator
* Generic locator for visiting a property collection.
*/
/*! \typedef PropertyFilter
* Filter to selecting a subset of properties matching some
* criteria.
*/
/*! \def for_each_property(property, properties)
* Macro for visiting all properties of a property collection.
\code
Occurence occurence = ...; // we get an occurence
for_each_property(property, occurence.GetProperties()) {
cerr << property << endl;
end_for;
}
\endcode
*/
// \}
/* \name Destructors
*/
// \{
/*! \function void Property::Delete();
* Like the data base objects, properties can be destroyed by
* calling upon this function and not the standard C++
* destructor (which is not available).
*/
// \}
}

184
hurricane/doc/hurricane/QuadTree.dox Normal file
View File

@ -0,0 +1,184 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class QuadTree
* \brief QuadTree description (\b API)
*
* \section secQuadTreeIntro Introduction
*
* Quadtrees are efficient hierarchical data structures for the
* geometrical access of gos.
*
* \important You must not change the bounding box of an object already
* present in the quadtree, because its localization within the
* tree depends on it. Therefore, if an object is modified, you
* must in a firts time remove it from the quadtree, apply the
* changes then re-insert it in the quadtree, at the right place
* which depends of its new bounding box.
*/
/*! \name Constructors
*/
// \{
/*! \function QuadTree::QuadTree();
* Default constructor : the quadtree is initially empty
* (objects will be inserted or removed on demand).
*/
// \}
/*! \name Destructors
*/
// \{
/*! \function QuadTree::~QuadTree();
* Destroys the quadtree and its sub-quadtrees but doesn't touch
* to the contained objects, they will ibe only detached from
* their respective quadtree nodes.
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function Box QuadTree::GetBoundingBox() const;
* \Return the quadtree bounding box, that is the minimal bounding box
* including all objects of the quad tree (this bounding box is
* updated dynamically).
*/
/*! \function Gos QuadTree::GetGos() const;
* \Return the collection of graphical objects contained in the
* quadtree.
*/
/*! \function Gos QuadTree::GetGosUnder(const Box& area) const;
* \Return the collection of graphical objects contained in the quadtree
* and whose bounding box intersects the rectangular region
* defined by \c \<area\>.
*/
// \}
/*! \name Predicates
*/
// \{
/*! \function bool QuadTree::IsEmpty() const;
* \Return <b>true</b> if the quadtree doesn't contain any object, else
* <b>false</b>.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function void QuadTree::Insert(Go* go);
* Inserts the graphic object within the quadtree (if not yet
* inserted).
*
* \caution If the graphic object pointer is NULL an exception is thrown.
*
* \remark When the number of objects contained in a quadtree leaf is
* greater than some threshold, this leaf is split into four
* balanced sub-quadtrees. This recursive division provides a
* faster access even for very large quadtrees (to the detriment
* of some memory loss).
*/
/*! \function void QuadTree::Remove(Go* go);
* Removes the object from the quadtree.
*
* \caution If the graphic object is NULL an exception is thrown.
*
* \remark When the number of objects included in the quadtree goes
* below an other threshold, the inverse behaviour happens : the
* sub-quadtrees are deleted and the contained objects are taken
* in charge by this quadtree node (and memory is released to
* the system).
*/
// \}
/*! \section secQuadTreeRemark Remark
*
* In principle there is no need to call upon directly those
* insertion and removal functions because graphic objects are
* inserted within the quadtree by the method <b>Materialize</b>
* and removed by the method <b>Unmaterialize</b>.
*
* Nevertheless it is necessary to know them if you need to
* overload one of those methods.
*
* We give as an example the implementation of those methods for
* the components :
\code
void Component::Materialize()
// **************************
{
// we get the cell and the layer of the component
Cell* cell = GetCell();
Layer* layer = GetLayer();
// we get the slice within which the object must be inserted
// (if necessary we create it)
Slice* slice = cellGetSlice(layer);
if (!slice) slice = Slice::_Create(cell, layer);
// we get the quadtree associated to the slice
QuadTree* quadTree = slice_GetQuadTree();
// we insert into the object
quadTreeInsert(this);
// we request to the cell to take into account the new bounding box
// of the quadtree (does nothing if the envelope has not grown).
cell_Fit(quadTreeGetBoundingBox());
}
\endcode
\code
void Component::Unmaterialize()
// ****************************
{
// we get the cell and the layer of the component
Cell* cell = GetCell();
Layer* layer = GetLayer();
// we get the associated slice
Slice* slice = cellGetSlice(layer);
// if the slice doesn't exist : there is nothing to do
if (slice) {
// we inform the cell that an object with a given bounding
// box will be removed (does something only if the bounding
// box is tangent to the cell bounding box)
cell_Unfit(GetBoundingBox());
\endcode
* // we remove the object from its slice
* slice-\>_GetQuadTree()-\>Remove(this);
*
* // if the slice becomes empty, it is destroyed if
* (slice-\>IsEmpty()) slice-\>_Delete(); } }
*/
}

91
hurricane/doc/hurricane/Quark.dox Normal file
View File

@ -0,0 +1,91 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Quark
* \brief Quark description (\b API)
*
* \section secQuarkIntro Introduction
*
* As explained in the Occurence class, occurences are very
* simple objects used to designate any entity of the virtually
* unfolded hierarchy. However, those occurences, which are
* built and deleted very easily, are very volatile objects to
* which we can't, of course, attach properties directly.
*
* But the usefullness of occurences lies in their ability to
* attach them properties.
*
* In order to do that, properties must be stored in a secure
* place, where they can be found when needed. That is the
* purpose of quarks : they are data base objects and then can
* own the properties of the occurences.
*
*
* \section secQuarkImportant Important
*
* A quark designates all occurences refering to the same entity
* of the virtually unfolded hierarchy.
*
* This means that a property put on an occurence can be
* recovered by an other occurence refering the same entity of
* the virtually unfolded hierarchy.
*
*
* \section secQuarkConstructionAndDestruction Construction and destruction
*
* Quarks being completely managed by the system, there is no
* constructor provided.
*
* They are themselves volatile because they need to exist only
* if there is at least a property attached to them (you must
* never store pointers to them !).
*
* An occurence may have, during its life, different quarks
* representing it.
*
* Nevertheless, it is possible to destroy a quark. This one
* will carry away with it the destruction of all its owned
* properties (like any other data base object). This is
* equivalent to destroying the properties associated to the
* occurences whom it is the unique representative.
* Conceptually, it is wiser to use the call :
* <b>occurence.ClearProperties()</b> which does the same.
*
*
* \section secQuarkExample Example
*
* The following sample code shows how to print the set of
* owners of a shared property :
\code
Property* property = ...; // we get a property
if (is_a<SharedPropery*>(property)) {
for_each_dbo(dbo, ((SharedProperty*)property)GetOwners()) {
if (!is_a<Quark*>(dbo))
cerr << dbo << endl;
else
cerr << ((Quark*)dbo)GetOccurence() << endl;
end_for;
}
}
\endcode
*/
/*! \name Accessors
*/
// \{
/*! \function const Occurrence& Quark::GetOccurrence() const;
* \Return an occurence of which this quark is a representative.
*/
// \}
}

98
hurricane/doc/hurricane/RecordHandles.dox Normal file
View File

@ -0,0 +1,98 @@
// -*- C++ -*-
namespace Hurricane {
//! \addtogroup inspectorManagment
//! \{
/*! \class RecordHandles
* \brief Root class of Inspector managable objects (\b internal).
*/
/*! \class StandardHandles
* \brief Provide Inspector support for non-duplicatable (\b internal).
*/
/*! \class PseudoHandles
* \brief Provide Inspector support for volatile objects (\b internal).
*/
/*! \class StringHandles
* \brief Provide minimal support for GetString() (\b internal).
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function string* RecordHandles::_GetString () const;
* \Return a string representing the object name and characteristics
* in a synthetic way. Used, among other things, as title
* for the Inspector Record browser.
*/
/*! \function string RecordHandles::_GetTypeName () const;
* \Return a string representing the object type. May be used by
* RecordHandles::_GetString().
*
* \note Default implementation is supplied, which returns the
* string \c "<RecordHandlesType>"
*/
/*! \function Record* RecordHandles::_GetRecord () const;
* \Return a Record representing the object current state.
*
* \note Default implementation is supplied, which returns \NULL.
*/
/*! \function Slot* RecordHandles::_GetPseudoSlot ( const string& name ) const;
* \param name the name to give to the Slot. Usually the class attribute
* name.
* \return a Slot associated to this object to insert into another Record.
* As the function let you guess, the Slot is a PseudoSlot, which
* implies that the object is duplicated for the Slot.
*
* \note Default implementation is not supplied. You must supply it,
* according to the object behavior.
*/
/*! \function Slot* RecordHandles::_GetStandardSlot ( const string& name ) const;
* \param name the name to give to the Slot. Usually the class attribute
* name.
* \return a Slot associated to this object to insert into another Record.
* The Slot is a StandardSlot, meaning that the data is not duplicated,
* only a pointer is transmitted. The data must remains allocated
* into memory till the deletion of this Slot.
*
* \note Default implementation is supplied. If the object is volatile and
* must not be accessed through pointer (like Occurrence), overload
* this function to invalidate it.
*/
/*! \function Slot* StandardHandles::_GetPseudoSlot ( const string& name ) const;
* \Return always \NULL, and issue a warning if ever be called. This function
* must never be called for this kind of object (non-duplicatable).
*/
/*! \function Slot* PseudoHandles::_GetStandardSlot ( const string& name ) const;
* \Return always \NULL, and issue a warning if ever be called. This function
* must never be called for this kind of object (volatile, no pointer
* avalaible).
*/
/*! \function Slot* StringHandles::_GetPseudoSlot ( const string& name ) const;
* \Return always \NULL, and issue a warning if ever be called. This object
* is not managed by the Inspector.
*/
/*! \function Slot* StringHandles::_GetStandardSlot ( const string& name ) const;
* \Return always \NULL, and issue a warning if ever be called. This object
* is not managed by the Inspector.
*/
}

12
hurricane/doc/hurricane/Relation.dox Normal file
View File

@ -0,0 +1,12 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Relation
* \brief Relation description (\b API)
*
*/
}

88
hurricane/doc/hurricane/Rubber.dox Normal file
View File

@ -0,0 +1,88 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Rubber
* \brief Rubber description (\b API)
*
* \section secRubberIntro Introduction
*
* Ring introduce the concept of virtual connection between
* different master hooks present in the ring. Rubber is just
* introduced to materialize this implicit relation.
*
*
* \section secRubberConstructors Constructors & Destructors
*
* Rubbers are entirely managed by Hurricane. So no constructors
* nor destructor are avalaible.
*/
/*! \typedef Rubber::Inherit
* Useful for calling upon methods of the base class without
* knowing it.
*/
/*! \name Accessors
*/
// \{
/*! \function Net* Rubber::GetNet() const;
* \Return the net owning the rubber.
*/
/*! \function Hook* Rubber::GetHook() const;
* \Return one hook (necessarily a master hook) of the ring which has
* created the rubber.
*/
/*! \function unsigned Rubber::GetCount() const;
* \Return the count associated to the rubber (in fact the number of
* master hooks of the ring).
*
* \remark This count is at least equal to two else the rubber doesn't
* exists (no need).
*/
/*! \function Point Rubber::GetCenter() const;
* \Return the center of the rubber (computed at the fly).
*/
/*! \function Hooks Rubber::GetHooks() const;
* \Return the collection of master hooks that the rubber virtualy
* connect.
*/
// \}
/*! \name Rubber Collection
*/
// \{
/*! \typedef Rubbers
* Generic collection representing a set of rubbers.
*/
/*! \typedef RubberLocator
* Generic locator for traversing a collection of rubbers.
*/
/*! \typedef RubberFilter
* Generic filter allowing to select a subset of rubbers
* matching some criteria.
*/
/*! \def for_each_rubber(rubber, rubbers)
* Macro for visiting all the rubbers of a collection of
* rubbers.
*/
// \}
}

183
hurricane/doc/hurricane/Segment.dox Normal file
View File

@ -0,0 +1,183 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Segment
* \brief Segment description (\b API)
*
* \section secSegmentIntro Introduction
*
* Segments are abstract objects introducing the concept of link
* between two components.
*
* They are implicitely oriented, but that doesn't represent any
* particular signification (for layout objects at least).
*/
/*! \typedef Segment::Inherit
* Useful for calling upon methods of the base class without
* knowing it.
*/
/*! \class Segment::SourceHook
* With segments, a new type of Hook appears : the
* <b>SourceHook</b>, which allows to attach the segment origin
* upon an other component, on which it is said to be
* "anchored". The SourceHook is always a slave hook.
*/
/*! \class Segment::TargetHook
* With segments, a new type of Hook appears : the
* <b>TargetHook</b>, which allows to attach the segment
* extremity upon an other component, on which it is said to be
* "anchored". The TargetHook is always a slave hook.
*/
/*! \name Accessors
*/
// \{
/*! \function Segment::SourceHook* Segment::GetSourceHook();
* \Return the hook through which the segment origin can be anchored on
* a component.
*/
/*! \function Segment::TargetHook* Segment::GetTargetHook();
* \Return the hook through which the segment extremity can be anchored
* on a component.
*/
/*! \function Hook* Segment::GetOppositeHook(const Hook* hook) const;
* \Return the target hook of the segment if \c \<hook\> is the source
* hook of the segment.
*
* \Return the source hook of the segment if \c \<hook\> is the target
* hook of the segment.
*
* \Return NULL otherwise.
*/
/*! \function Component* Segment::GetSource() const;
* The source hook being a slave one, it may have an associated
* master hook representing the body of the component on wich
* the segment origin is anchored.
*
* So, this method returns the component owner of this master
* hook, if any, else a NULL pointer.
*/
/*! \function Component* Segment::GetTarget() const;
* The target hook being a slave one, it may have an associated
* master hook representing the body of the component on wich
* the segment extremity is anchored.
*
* So, this method returns the component owner of this master
* hook, if any, else a NULL pointer.
*/
/*! \function Component* Segment::GetOppositeAnchor(Component* anchor) const;
* \Return the target anchor of the segment if \c \<anchor\> is the
* source anchor of the segment (may be NULL)
*
* \Return the source anchor of the segment if \c \<anchor\> is the
* target anchor of the segment (may be NULL)
*
* \Return NULL otherwise.
*/
/*! \function Components Segment::GetAnchors() const;
* \Return the collection of anchors. This collection is composed by the
* source (if non NULL) and the target (if non NULL) of the
* segment (may be empty if all extremities of the segment
* aren't anchored).
*/
/*! \function const Unit& Segment::GetWidth() const;
* \Return the segment width.
*/
/*! \function Unit Segment::GetHalfWidth() const;
* \Return the segment half width.
*/
/*! \function Unit Segment::GetSourceX() const;
* \Return the abscissa of the segment origin.
*/
/*! \function Unit Segment::GetSourceY() const;
* \Return the ordinate of the segment origin.
*/
/*! \function Point Segment::GetSourcePosition() const;
* \Return the point location of the segment origin.
*/
/*! \function Unit Segment::GetTargetX() const;
* \Return the abscissa of the segment extremity.
*/
/*! \function Unit Segment::GetTargetY() const;
* \Return the ordinate of the segment extremity.
*/
/*! \function Point Segment::GetTargetPosition() const;
* \Return the point location of the segment extremity.
*/
/*! \function Unit Segment::GetLength() const;
* \Return the segment length.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function void Segment::SetLayer(Layer* layer);
* Sets the segment layer.
*/
/*! \function void Segment::SetWidth(const Unit& width);
* Sets the segment width.
*/
/*! \function void Segment::Invert();
* Invert the segment. The source and target of the segment are
* permutted.
*/
// \}
/*! \name Segment Collection
*/
// \{
/*! \typedef Segments
* Generic collection representing a set of segments.
*/
/*! \typedef SegmentLocator
* Generic locator for traversing a collection of segments.
*/
/*! \typedef SegmentFilter
* Generic filter allowing to select a subset of segments
* matching some criteria.
*/
/*! \def for_each_segment(segment, segments)
* Macro for visiting all the segments of a collection of
* segments.
*/
// \}
}

64
hurricane/doc/hurricane/SelectCommand.dox Normal file
View File

@ -0,0 +1,64 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class SelectCommand
* \brief SelectCommand description (\b API)
*
* \section secSelectCommandIntro Introduction
*
* This command allows to change the set of occurences selected
* in a view, by either replacing by, adding to or erasing from
* the current selection the occurences located into a
* rectangular area or below a point. This command uses a rubber
* rectangle to define the selection area. Let us recall that a
* cell may have different selections in different views.
*
* This command has name : <b>"Select"</b> and has to be
* installed on the mouse <b>middle button</b>.
*
*
* \section secSelectCommandPrinciple Principle
*
* After defining a rectangle, the selection proceeds in two
* steps :
*
* <b>Identification of candidate occurences :</b>
*
* If the selection rectangle is a point Then the candidate
* occurences are those located below this point.
*
* Else The candidate occurences are all those located inside
* the rectangle or intersecting the rectangle if the control
* key is hold down.
*
* Only visible occurences are potentially candidates. Only
* occurences of instances refering a terminal cell are
* potential candidates.
*
* <b>Modification of the current selection :</b>
*
* If the shift key is hold down Each occurence is selected
* provided it was not previously selected, and unselected if it
* was previously selected (toggle mode).
*
* Else The new selection of only the candidate occurences
* replaces the old one (replace mode).
*/
/* \name SelectCommand Functions
*/
// \{
/* \function SelectCommand* SelectCommand::GetSelectCommand();
* \Return the selection command.
*/
// \}
}

53
hurricane/doc/hurricane/SelectNetCommand.dox Normal file
View File

@ -0,0 +1,53 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class SelectNetCommand
* \brief SelectNetCommand description (\b API)
*
* \section secSelectNetCommandIntro Introduction
*
* This command allows to select the set of component occurences
* pertaining to one or many net occurences.
*
* This command is named : <b>"Select nets"</b> and bound to the
* mouse <b>right button</b>.
*
*
* \section secSelectNetCommandPrinciple Principle
*
* After having defined a point, the selection proceeds in two
* steps :
*
* <b>Identification of candidate occurences :</b>
*
* Candidate occurences are those located below this point.
*
* Only visible occurences are potentially candidates.
*
* <b>Modification of the current selection :</b>
*
* If the shift key is not hold down the previous selection is
* erased.
*
* Then, for each identified candidate occurence the
* corresponding net occurence is obtained, and the whole set of
* component occurences of this net occurence is selected.
*/
/* \name SelectNetCommand Functions
*/
// \{
/* \function SelectNetCommand* SelectNetCommand::GetSelectNetCommand();
* \Return the select net command object.
*/
// \}
}

42
hurricane/doc/hurricane/Selector.dox Normal file
View File

@ -0,0 +1,42 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Selector
* \brief Selector description (\b API)
*
* \section secSelectorIntro Introduction
*
* Selectors are private properties providing a very secure way
* to manage the different selections attached to the different
* existing views at a given time.
*
* There is no need to known much more about this property
* because it is completely managed by the system. However it is
* very instructive to examine its code to understant how it
* works.
*/
/*! \section secSelectorImportant Important
*
* Thanks to the power of properties, it has been very easy to
* set up a simple mechanism which fully guaranties the
* coherence whathever destruction operations could happen
* either at the graphical views level or at the different
* levels of entities and instances of the data base.
*
* For instance de-selection is automatic whenever an occurence
* becomes non representative, that is when it doesn't represent
* anylonger an entity of the virtually unfolded hierarchy
*
* It will be wise to inspire yourself of this case in order to
* design new ones.
*/
}

79
hurricane/doc/hurricane/SetCollection.dox Normal file
View File

@ -0,0 +1,79 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class SetCollection
* \brief SetCollection description (\b API)
*
* \section secSetCollectionIntro Introduction
*
* This collection allows you to handle a STL set as a
* collection.
*
* In priciple you don't need to handle directly this
* collection, you only need to handle a generic collection
* bound to a <b>SetCollection</b> as created by the generic
* function <b>GetCollection</b>(...) which builds one when its
* argument is a STL set (for that reason we will not describe
* it).
*
*
* \section secSetCollectionOverloadingsOfTheGetcollectionGenericFunction Overloadings of the GetCollection generic function
*
* <b>Hurricane::SetCollection::GetCollection</b>
* <b>Hurricane::SetCollection::GetCollection</b>
*
*
* \section secSetCollectionRemarks Remarks
*
* Like for the other collections, there is no copy of the
* elements included in the set, but instead a link from the
* collection to the set.
*
* Once the collection as been built, you can perfectly modify
* the set; the added or deleted elements will be taken into
* account when visiting the set, as shown in the following
* example :
\code
set<Net*> netSet;
Nets nets = GetCollection(netSet);
// nets is then bound to the set netMap
// and will reflect its content until the end
// so we can :
assert(nets.IsEmpty());
Cell* cell = ... // we get a cell
if (cell) {
Net* net = cellGetNet("vdd");
if (net) {
netSet.insert(net);
// and now
assert(nets.GetSize() == 1);
}
}
\endcode
*/
/* \name Accessors
*/
// \{
/*! \function GenericCollection<Element> SetCollection::GetCollection(const set<Element,Compare>& elementSet);
* See below.
*/
/*! \function GenericCollection<Element> SetCollection::GetCollection(const set<Element,Compare>* elementSet);;
* Those two function return into generic collection bound to a
* <b>SetCollection</b> the content of the STL set given in
* argument.
*/
// \}
}

87
hurricane/doc/hurricane/SharedProperty.dox Normal file
View File

@ -0,0 +1,87 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class SharedProperty
* \brief SharedProperty description (\b API)
*
* \section secSharedPropertyIntro Introduction
*
* Shared properties can be attached to many objects of the data
* base.
*
* When a new property is created, it is not yet assigned to any
* particular object. It becomes effectively the property of an
* object after the call <b>dbo-\>Put(property)</b>. The
* property then receives a message <b>OnCapturedBy</b> whose
* argument is the additional owner. From that time onwards,
* this object becomes partially responsible of the future of
* the property.
*
* <b>What can happen then ?</b>
*
* If the property is destroyed : The property being shared, it
* informs its owners of its deletion. Each of those owners
* detaches it from the list of its properties. If the object is
* a quark and that property is the last one it owns, it
* automatically deletes itself.
*
* If a property of same name already exist : Two properties
* with the same name can't cohabit, the older one is released
* by the object which receives the message <b>OnReleasedBy</b>
* from that old property and proceeds as required according to
* the type of property.
*
* If the property is attached to a new owner : Being shared,
* the property is simply captured by this new owner.
*
* If one of the owners of the property is destroyed : The
* properties captured by this object are then released. The
* future of those properties is here completely managed by the
* different messages <b>OnReleasedBy</b> which are associated
* to them. If the deleted object is the last owner of a shared
* property, this one is automatically deleted.
*/
/*! \typedef typedef SharedProperty::Inherit Property;
* Useful for calling upon methods of the base class without
* knowing it.
*/
/*! \section secSharedPropertyDestruction Destruction
*
* The property has owners, each one is informed of the property
* deletion and detaches it from its property list. If the
* object is a quark and if this was the last property owned it
* automatically deletes itself.
*
* \remark Once the property is attached to an object this one becomes
* party responsible of its automatic destruction.When a new
* owner appears, the other owners delegate to it a part of that
* responsability. On the other hand, a property which has never
* been attached to an owner will never be deleted
* automatically.
*/
/*! \name Accessors
*/
// \{
/*! \function DBos SharedProperty::GetOwners() const;
* \Return the collection of objects owning the property (might be empty
* if the property has never been attached).
*/
// \}
/*! \name Messages
*/
// \{

117
hurricane/doc/hurricane/Slice.dox Normal file
View File

@ -0,0 +1,117 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Slice
* \brief Slice description (\b API)
*
* \section secSliceIntro Introduction
*
* The slices are objects which split the layout description of
* a cell into horizontal slices grouping all objects located on
* a given layer and storing them into a fast geometrical access
* structure implemented by a quadtree.
*
*
* \section secSliceConstructionAndDestruction Construction and destruction
*
* The slices are fully managed by the cells : they are neither
* created nor destroyed by the application programmer.
*
* Components are inserted in a slice (at their creation) and
* removed from their slice (at their deletion).
*
* Empty slices being automatically deleted, you must never
* store pointers to them.
*
*
* \section secSliceExample Example
*
* The following example shows how to visit all cell components
* lying on a given basic layer and whose bounding box
* intersects some rectangular area.
\code
Cell* cell = ...; // we get the cell
BasicLayer* basicLayer = ...; // we get the basic layer
Box area = ...; // we define the rectangular area
for_each_slice(slice, cell->GetSlices()) {
if (slice->GetLayer()->Contains(basicLayer)) {
for_each_componant(component, slice->GetComponentsUnder(area)) {
...
// here we visit all requested components
...
end_for;
}
}
end_for;
}
\endcode
*/
/*! \name Accessors
*/
// \{
/*! \function Cell* Slice::GetCell() const;
* \Return the cell owning the slice.
*/
/*! \function Layer* Slice::GetLayer() const;
* \Return the layer associated to the slice : all components lying in a
* cell are perforce located on that layer.
*/
/*! \function Box Slice::GetBoundingBox() const;
* \Return the bounding box of the slice, that is the smallest enclosing
* rectangle of all its components.
*/
/*! \function const Gos Slice::GetGos() const;
* \Return the collection of graphic objects lying on the slice.
*/
/*! \function const Components Slice::GetComponents() const;
* \Return the collection of components lying on the slice.
*/
/*! \function const Components Slice::GetComponentsUnder(const Box& area) const;
* \Return the collection of components of the slice whose bounding box
* intersects the rectangular region defined by \c \<area\>.
*/
// \}
/*! \name Slice Collection
*/
// \{
/*! \typedef Slices
* Collection representing a set of slices.
*/
/*! \typedef SliceLocator
* Locator for traversing a collection of slices.
*/
/*! \typedef SliceFilter
* Filter for selecting a subset of slices which match a given
* criteria.
*/
/*! \def for_each_slice(slice, slices)
* Macro for visiting the slices of a slice collection.
*/
// \}
}

319
hurricane/doc/hurricane/SlotAdapter.dox Normal file
View File

@ -0,0 +1,319 @@
// -*- C++ -*-
namespace Hurricane {
/*! \defgroup inspectorManagment Inspector : Live Database Explorator (internal)
*
*
* \section sInspectorIntro Introduction
*
* The Hurricane Database provide a generic mechanism to allow
* the inspection of the whole data structure at run-time.
* The associated window/tool is called "The Inspector".
*
* In this section, we will describe how the inspection
* mechanism to new objects.
*
*
* \subsection ssSlotAdapter The SlotAdapter
*
* First, we introduce the SlotAdapter object. Any inspectable
* object has to be associated (see the next section) with a
* SlotAdapter. It's providing the following methods :
\code
class SlotAdapter {
public:
virtual string _GetTypename () const;
virtual string _GetString () const;
virtual Record* _GetRecord () const;
inline virtual Slot* _GetSlot ( const string& name ) const;
};
\endcode
*
*
* Thoses methods correspond to :
* <ul>
* <li>\b _GetTypeName() : the inspected object's type.
* <li>\b _GetString() : a synthetic string description of the
* object's state.
* <li>\b _GetRecord() : the complete description of all object's
* attributes (a list of Slot).
* <li>\b _GetSlot() : a Slot build from this SlotAdapter. As this
* function is supplied by default with the right implementation
* we will not detail it here.
* </ul>
*
*
* \subsection ssObjectTypology Typology of inspectables objects
*
* We distinguish three kind of objects, corresponding to three
* different ways of association to a SlotAdapter.
* <ul>
* <li><b>User defined, with virtual methods</b> : those objects
* must inherit from the NestedSlotAdapter class.
* <li><b>User defined, without virtual methods</b> : thoses
* objects must provides (as ordinary methods)
* \b _GetTypeName() , \b _GetString() , \b _GetRecord() .
* But \b not \b _GetSlot().
* <li><b>External objects</b> : that is, we cannot modify.
* In this case we have to provide a specialised template
* overload for \b ProxyTypeName<>() , \b ProxyString<>() ,
* and \b ProxyRecord<>() (see \ref ssExternalObjects).
* </ul>
*
*
* \subsection ssUserDefinedVirtual User Defined Object with virtual methods
*
* This approach should be preferrred for complex objects
* that are persistents in memory.
*
* Example of implementation :
\code
namespace MyTool {
class MyClass : public NestedSlotAdapter {
protected:
int _value;
public:
int GetValue () const { return _value; }
virtual string _GetTypeName() const { return "MyClass"; };
virtual string _GetString () const { return "<MyClass"+GetString(_value)+">"; };
virtual Record* _GetRecord () const;
};
Record* MyClass::GetRecord () const {
Record* record = new Record(_GetString());
record->Add ( GetSlot("_value",&_value) );
return record;
}
} // End of MyTool namespace.
SetNestedSlotAdapter(MyTool::MyClass)
\endcode
*
* \e MyClass derives from NestedSlotAdapter. Any derived class of
* \e MyClass will inherit of it, so you do not have to (and musn't)
* repeat the inheritance from NestedSlotAdapter.
*
* \e SetNestedSlotAdapter() must be put outside any namespace.
*
* \e SetNestedSlotAdapter() must never be called on objects that do
* not derives from NestedSlotAdapter. There's builtin safety :
* a \c static_cast into NestedSlotAdapter that will make the
* compiler fail.
*
* \e SetNestedSlotAdapter() may be omitted, at the cost of generating
* a intermediary SlotAdapter (that will cost two pointers). Nevertheless
* it will work.
*
*
* \subsection ssUserDefinedWithoutVirtual User Defined Object without virtual methods
*
* This implementation should be preferred for light objects
* that are instanciated in vast amounts (we gain the \e vtable
* pointer over the previous approach).
*
* Example of implementation :
\code
namespace MyTool {
class MyLightClass {
protected:
int _value;
public:
int GetValue () const { return _value; }
string _GetTypeName() const { return "MyLightClass"; };
string _GetString () const { return "<MyLightClass"+GetString(_value)+">"; };
Record* _GetRecord () const;
};
Record* MyLightClass::GetRecord () const {
Record* record = new Record(_GetString());
record->Add ( GetSlot("_value",&_value) );
return record;
}
} // End of MyTool namespace.
\endcode
*
* The methods \b _GetTypeName() , \b _GetString() and \b GetRecord()
* are now non-virtual and there's no call to \b SetNestedSlotAdapter() .
*
*
* \subsection ssExternalObjects External Objects
*
* This is the implementation to uses for managing objects
* from other libraries that we should want to browse in the
* Inspector. In this case we have to provide three overload
* of template functions, as shown below (for boolean type) :
\code
template<>
inline string ProxyTypeName<bool> ( const bool* object ) { return "<PointerSlotAdapter<bool>>"; }
template<>
inline string ProxyString<bool> ( const bool* object ) { return (*object)?"True":"False" ; }
template<>
inline Record* ProxyRecord<bool> ( const bool* object ) { return NULL; }
\endcode
*
*
* \section sGetStringAndGetSlot GetString() and GetSlot() functions
*
* When a class or type is provided with Inspector support,
* you may uses the two generic functions below :
\code
template<typename T> inline string GetString ( T* t );
template<typename T> inline string GetString ( T t );
template<typename T> inline Hurricane::Slot* GetSlot ( const string& name, T* t );
template<typename T> inline Hurricane::Slot* GetSlot ( const string& name, T t );
\endcode
*
* GetString() may be used to print some debugging informations
* on \stdout.
*
* GetSlot() used to built the various entries in a \b _GetRecord()
* method.
*
* <b>Argument type policy</b>
*
* As you noticed there are two overload for each function,
* one with pointer argument, the other with a value argument.
* This is meaningful :
* <ul>
* <li>Passing by pointer means that the data being inspected
* is persistent, and should not be deleted once the
* inspector is closed. This is the case of all DBo
* objects and, for example, Box objects when they are
* attributes of another object.
* <li>Passing by value, means that the data is volatile and
* should be deleted at the inspector closing. As an
* example, the bounding box of an instance which is
* computed on the fly, we must copy the result into
* the SlotAdapter but no longer need it afterwards.
* An important consequence is that thoses objects
* must have a valid copy constructor.
* </ul>
*
* <b>Default type support</b>
*
* Hurricane provide support for the following types :
* <ul>
* <li><b>const char</b>
* <li><b>const char*</b>
* <li><b>const string*</b>
* <li><b>const bool*</b>
* <li><b>const void*</b>
* <li><b>const int*</b>
* <li><b>const long*</b>
* <li><b>const unsigned int*</b>
* <li><b>const unsigned long*</b>
* <li><b>const unsigned long long*</b>
* <li><b>const unsigned short int*</b>
* <li><b>const float*</b>
* <li><b>const double*</b>
* </ul>
* Note that, as long as the pointer type is supported, the value
* is also (except for the \b char type which has a somewhat more
* complex behavior).
*
* It also provide support for the following \STL containers :
* <ul>
* <li><b>const vector<Element>*</b>
* <li><b>const list<Element>*</b>
* <li><b>const map<Key,Element,Compare>*</b>
* <li><b>const set<Element,Compare>*</b>
* <li><b>const multiset<Element,Compare>*</b>
* </ul>
*
*
* \section sIOStreamSupport Support for iostream
*
* If an object (with inspector support) is often printed into
* a stream, you may define an overload of \b operator<<() with
* either the \b PointerIOStreamSupport() or \b ValueIOStreamSupport()
* macros. The macros must in the top-level namespace.
*
*
* \section sLastNote A note for myself
*
* About the deletion mechanism : there are two level of deletion,
* the SlotAdapter deletion and the object deletion.
*
* Object deletion is managed by the SlotAdapter : if the SlotAdapter
* is nested in the object, do not delete, otherwise delete.
*
* SlotAdapter deletion is managed at Slot level : if the object
* is passed by pointer, do not delete the SlotAdapter. if the object
* is passed by value, delete the SlotAdapter.
*/
//! \addtogroup inspectorManagment
//! \{
/*! \class SlotAdapter
* \brief Root class. Provide support for duplicatable objects (\b internal).
*/
/*! \class NestedSlotAdapter
* \brief Provide Inspector support for non-duplicatable (\b internal).
*/
/*! \class PointerSlotAdapter
* \brief Provide Inspector support for external persistant objects (\b internal).
*/
/*! \class ValueSlotAdapter
* \brief Provide Inspector support for external volatile objects (\b internal).
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function string SlotAdapter::_GetTypeName () const;
* \Return a string representing the object type. May be used by
* SlotAdapter::_GetString().
*
* \note No default implementation is supplied.
*/
/*! \function string SlotAdapter::_GetString () const;
* \Return a string representing the object name and characteristics
* in a synthetic way. Used, among other things, as title
* for the Inspector Record browser.
*
* \note Default implementation is supplied, which returns the
* string \c "SlotAdapter::_GetString()" .
*/
/*! \function Record* SlotAdapter::_GetRecord () const;
* \Return a Record representing the object current state.
*
* \note Default implementation is supplied, which returns \NULL.
*/
/*! \function Slot* SlotAdapter::_GetSlot ( const string& name ) const;
* \param name the name to give to the Slot. Usually the class attribute
* name.
* \return a Slot associated to this object to insert into another Record.
* As SlotAdapter is for user-defined objects without virtual
* method the SlotAdapter is created aside to the inspected
* object and must be removed afterwards, so we uses a ValueSlot.
*/
/*! \function Slot* NestedSlotAdapter::_GetSlot ( const string& name ) const;
* \param name the name to give to the Slot. Usually the class attribute
* name.
* \return a Slot associated to this object to insert into another Record.
* NestedSlotAdapter is for user-defined objects with virtual
* method, it must be a base class of the object, and as such
* the object \e is the SlotAdapter. So the removal of the Slot
* must left the SlotAdapter, for this we uses a PointerSlot.
*/
}

21
hurricane/doc/hurricane/StandardPrivateProperty.dox Normal file
View File

@ -0,0 +1,21 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class StandardPrivateProperty
* \brief StandardPrivateProperty description (\b API)
*
* \section secStandardPrivatePropertyIntro Introduction
*
* Those properties allow to assign to an object a relation
* between a name and a value.
*/
/*! \name Constructors
*/
// \{

12
hurricane/doc/hurricane/StandardRelation.dox Normal file
View File

@ -0,0 +1,12 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class StandardRelation
* \brief StandardRelation description (\b API)
*
*/
}

21
hurricane/doc/hurricane/StandardSharedProperty.dox Normal file
View File

@ -0,0 +1,21 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class StandardSharedProperty
* \brief StandardSharedProperty description (\b API)
*
* \section secStandardSharedPropertyIntro Introduction
*
* Those properties allow to assign to a set of objects a
* relation between a name and a value.
*/
/*! \name Constructors
*/
// \{

79
hurricane/doc/hurricane/SubSetCollection.dox Normal file
View File

@ -0,0 +1,79 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class SubSetCollection
* \brief SubSetCollection description (\b API)
*
* \section secSubSetCollectionIntro Introduction
*
* This collection allows you to get the subset of all elements
* which are accepted by a filter (this filter is indeed a
* functional object as illustrated below).
*
* In principle you don't need to use this collection directly,
* but through the call of <b>collection.GetSubSet(filter)</b>
* which builds this subset collection (for that reason we will
* not describe it).
*/
/*! \section secSubSetCollectionExample Example
*
* Definition of the filter which selects external nets of a
* cell :
\code
class IsExternal : public Filter<Net*> {
// ***********************************
public:
IsExternal() {};
IsExternal(const IsExternal& isExternal) {};
IsExternal& operator=(const IsExternal& isExternal) {return *this;};
virtual Filter<Net*>* GetClone() const {return new IsExternal(*this);};
virtual bool Accept(Net* net) const {return netIsExternal();};
};
\endcode
* Implementation of the accessor <b>GetExternalNets</b> for the
* cells :
\code
Nets Cell::GetExternalNet() const
// ******************************
{
return GetNets().GetSubSet(IsExternal());
}
\endcode
*/
/*! \section secSubSetCollectionRemarks Remarks
*
* As we will see, most objects define some handy filters. For
* instance, nets define the filter <b>IsExternalFilter</b>
* which can be obtained by calling the static member function
* <b>Net::GetIsExternalFilter()</b>.
*
* Then, the <b>GetExternalNets</b> accessor for cells is
* written like this :
\code
Nets Cell::GetExternalNets() const
// *******************************
{
return GetNets().GetSubSet(Net::GetIsExternalFilter());
}
\endcode
*/
}

41
hurricane/doc/hurricane/SubTypeCollection.dox Normal file
View File

@ -0,0 +1,41 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class SubTypeCollection
* \brief SubTypeCollection description (\b API)
*
* \section secSubTypeCollectionIntro Introduction
*
* This collection allows you to get the subset of all elements
* of type <b>Type</b> from a collection of elements of type
* <b>SuperType</b>.
*
* In principle you don't need to use this collection directly,
* but through the call of
* <b>collection-\>GetSubSet\c \<Type\></b>() which builds this
* subset collection (for that reason we will not describe it).
*/
/*! \section secSubTypeCollectionExample Example
*
* On the following example we show how to realize the
* <b>GetContacts</b> member function for a net, which returns
* the set of contacts in its layout.
\code
Contacts Net::GetContacts() const
// ******************************
{
return GetComponents()GetSubSet<Contact*>();
}
\endcode
* It's very simple ...
*/
}

119
hurricane/doc/hurricane/Symbol.dox Normal file
View File

@ -0,0 +1,119 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Symbol
* \brief Symbol description (\b API)
*
*/
/*! \typedef Symbol::Inherit
* Useful for calling upon methods of the base class without
* knowing it.
*/
/*! \name Constructors
*/
// \{
/*! \function Symbol* Symbol::Create(Library* library, const Name& name);
* Creates and returns a new symbol named \c \<name\> for the
* library \c \<library\>.
*
* \caution Throws an exception if the library is null, if the name is
* empty or if a symbol with same name already exists in the
* library.
*/
/*! \function Symbol* Symbol::CreateFor(Cell* cell);
* Creates and returns an adapted symbol for the cell
* \c \<cell\>.
*
* \remark This symbol is owned by the library owning the cell and it's
* name is generated on the fly.
*
* The primitives which define the look of the symbol are
* generated with a default strategy.
*
* The positions and names of symbol pins depend respectively of
* the directions and names of the external nets of the cell.
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function Library* Symbol::GetLibrary() const;
* \Return the library owning the symbol.
*/
/*! \function const Name& Symbol::GetName() const;
* \Return the name of the symbol.
*/
/*! \function Cells Symbol::GetCells() const;
* \Return the collection of all cells associated to this symbol.
*/
/*! \function Primitives Symbol::GetPrimitives() const;
* \Return the collection of primitives constituing the symbol.
*/
/*! \function Box Symbol::GetBoundingBox() const;
* \Return the bounding box of the symbol. It is defined as the smallest
* box enclosing the primitives constituing the symbol.
*/
/* \function Pin* Symbol::GetPin(const Name& name) const;
* \Return the pin of name \c \<name\> if it exists, else NULL.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function void Symbol::SetName(const Name& name);;
* Allows to change the symbol name.
*
* \remark Throws an exception if the new name is empty or if the
* library owning the symbol has already a symbol with the same
* name.
*/
// \}
/*! \name Symbol Collection
*/
// \{
/*! \typedef Symbols
* Generic collection representing a set of symbols.
*/
/*! \typedef SymbolLocator
* Generic locator for visiting a collection of symbols.
*/
/*! \typedef SymbolFilter
* Filter to selecting a subset of symbols matching some
* criteria.
*/
/*! \def for_each_symbol(symbol, symbols)
* Macro for visiting all symbols of a symbols collection.
*/
// \}
}

167
hurricane/doc/hurricane/Tabulation.dox Normal file
View File

@ -0,0 +1,167 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Tabulation
* \brief Tabulation description (\b API)
*
* \section secTabulationIntro Introduction
*
* This object provides an indentation capability for printing
* readable texts.
*
*
* \section secTabulationNewGlobalVariable New global variable
*
\code
Tabulation tab(" ");
\endcode
* Represents the
* global tabulation variable usable by all application
* programmers. The elementary tabulation being fixed to 3 space
* characters.
*
*
* \section secTabulationUsage Usage
*
* Let us write a sample code of printing a succinct cell
* description :
\code
void Describe(Cell* cell)
// **********************
{
cout << tab++ << "cell : " << cellGetName() << endl;
if (!cellGetInstances().IsEmpty()) {
cout << tab++ << "instances : {" << endl;
for_each_instance(instance, cellGetInstances()) {
cout << tab << "instance : " << instanceGetName() << endl;
end_for;
}
cout << --tab << "}";
}
if (!cellGetNets().IsEmpty()) {
cout << tab++ << "nets : {" << endl;
for_each_net(net, cellGetNets()) {
cout << tab++ << "net : " << netGetName() << endl;
if (!netGetPlugs().IsEmpty()) {
cout << tab++ << "plugs : {" << endl;
for_each_plug(plug, netGetPlugs()) {
cout << tab << "master_net : "
<< plugGetMasterNet()GetName() << endl;
end_for;
}
cout << --tab << "}";
}
end_for;
}
cout << --tab << "}";
}
--tab;
}
\endcode
* The call :
\code
Describe(cell);
\endcode
* Will print the result in the following form :
\code
cell : ...
instances : {
instance : ...
instance : ...
...
}
nets : {
net : ...
plugs : {
master_net : ...
master_net : ...
...
}
net : ...
plugs : {
master_net : ...
master_net : ...
...
}
...
}
\endcode
*
*
* \section secTabulationRemark Remark
*
* Of course this automatic indentation works also in recursive
* mode. Its main interest is for that purpose because you don't
* need to transfer through recursive function calls an
* additional argument for controling the indentation when
* formating print-outs.
*/
/*! \name Constructors
*/
// \{
/*! \function Tabulation::Tabulation(const string& s = "&nbsp;&nbsp;&nbsp;");
* Default constructor : The string \c \<s\> represents the
* elementary tabulation (fixed by default to 3 space
* characters)
*/
/*! \function Tabulation::Tabulation(const Tabulation& tabulation);
* Copy constructor.
*/
// \}
/*! \name Destructors
*/
// \{
/*! \function Tabulation::~Tabulation();
* No description.
*/
// \}
/*! \name Operators
*/
// \{
/*! \function Tabulation& Tabulation::operator=(const Tabulation& tabulation);
* Assignment operator.
*/
/*! \function Tabulation& Tabulation::operator++();
* Incrementation operator : returns the tabulation augmented of
* an elementary tabulation.
*/
/*! \function Tabulation Tabulation::operator++(int);
* Postfixed version of the incrementation operator : the
* tabulation is augmented of an elementary tabulation, but
* returns the previous tabulation.
*/
/*! \function Tabulation& Tabulation::operator--();
* Decrementation operator : returns the tabulation reduced of
* an elementary tabulation.
*/
/*! \function Tabulation Tabulation::operator--(int);
* Postfixed version of the decrementation operator : the
* tabulation is reduced of an elementary tabulation, but
* returns the previous tabulation.
*/
// \}
}

100
hurricane/doc/hurricane/Technology.dox Normal file
View File

@ -0,0 +1,100 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Technology
* \brief Technological rules description (\b API).
*
* \section sTechnologyIntro Introduction
*
* The Technology object provides the description of all the technology
* rules needed by the tools, currently it is limited to the description
* of all layers available. This object must be created once within the
* DataBase, and, in principle never destroyed (this would destroy layers
* and all objects laying on them ...).
*
* \remark There is only one technology for the current DataBase, and only one
* Database object, so only one technology defined.
*/
/*! \name Constructors
*/
// \{
/*! \function Technology* Technology::Create ( DataBase* dataBase, const Name& name );
* \Return a newly created technology named \c \<name\> for the data base \c \<dataBase\>.
*
* \caution Throws an exception if the \c dataBase is \NULL, if the name is empty or if
* the \c dataBase has already a technology.
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function DataBase* Technology::GetDataBase () const;
* \Return the DataBase owning the technology.
*/
/*! \function const Name& Technology::GetName () const;
* \Return the technology name.
*/
/*! \function Layer* Technology::GetLayer ( const Name& name ) const;
* \Return the Layer named \c \<name\> if it exists, else \NULL.
*/
/*! \function BasicLayer* Technology::GetBasicLayer ( const Name& name ) const;
* \Return the Layer named \c \<name\> if it exists and is a BasicLayer, else \NULL.
*/
/*! \function CompositeLayer* Technology::GetCompositeLayer ( const Name& name ) const;
* \Return the Layer named \c \<name\> if it exists and is a CompositeLayer, else \NULL.
*/
/*! \function Layers Technology::GetLayers () const;
* \Return Returns the collection of layers of the technology.
*
* \remark The layers are traversed according to their
* creation order. This order is very important,
* notably for the graphical display. Therefore deeper
* basic layers must be created first and upper layers
* later (the order of composite layers has no
* importance).
*/
/*! \function BasicLayers Technology::GetBasicLayers () const;
* \Return Returns the collection of basic layers of the technology
* (uses the same order).
*/
/*! \function BasicLayers Technology::GetBasicLayers ( const Layer::Mask& mask ) const;
* \Return Returns the collection of basic layers of the technology
* which matches the Layer mask \c \<mask\> (uses the same order).
*/
/*! \function CompositeLayers Technology::GetCompositeLayers () const;
* \Return Returns the collection of composite layers of the technology
* (uses the same order).
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function void Technology::SetName ( const Name& name );
* Allows to change the technology name (if empty name, throws an exception).
*/
// \}
}

264
hurricane/doc/hurricane/Transformation.dox Normal file
View File

@ -0,0 +1,264 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Transformation
* \brief Transformation description (\b API)
*
* \section secTransformationIntro Introduction
*
* Transformation objects are a combination of a
* <b>translation</b> and an <b>orientation</b> defined by the
* new enumeration <b>Transformation::Orientation</b> whose
* different values are described in table below.
*
*
* \remark <b>Rotations are done counter clock wise</b> :
*/
/*! \class Transformation::Orientation
* This enumeration defines the orientation associated to a
* transformation object. table: Orientation codes and
* associated transfornation matrix headers: Name Aspect Code
* Signification a b c d slots: ID <img src='./gif/id.gif'> 0
* Identity 1 0 0 1 slots: R1 <img src='./gif/r1.gif'> 1 Simple
* rotation (90°) 0 &nbsp;&nbsp;-1&nbsp;&nbsp 1 0 slots: R2 <img
* src='./gif/r2.gif'> 2 Double rotation (180°)
* &nbsp;&nbsp;-1&nbsp;&nbsp 0 0 &nbsp;&nbsp;-1&nbsp;&nbsp
* slots: R3 <img src='./gif/r3.gif'> 3 Triple rotation (270°) 0
* 1 &nbsp;&nbsp;-1&nbsp;&nbsp 0 slots: MX <img
* src='./gif/mx.gif'> 4 Horizontal symetry (Miror X)
* &nbsp;&nbsp;-1&nbsp;&nbsp 0 0 1 slots: XR <img
* src='./gif/xr.gif'> 5 Horizontal symetry followed by a 90°
* rotation 0 &nbsp;&nbsp;-1&nbsp;&nbsp
* &nbsp;&nbsp;-1&nbsp;&nbsp 0 slots: MY <img
* src='./gif/my.gif'> 6 Vertical symetry (Miror Y) 1 0 0
* &nbsp;&nbsp;-1&nbsp;&nbsp slots: YR <img src='./gif/yr.gif'>
* 7 Vertical symetry followed by a 90° rotation 0 1 1 0 To each
* orientation corresponds a 2x2 matrix whose coefficients are
* named a and b for the first line and c and d for the second
* one.
*
* The transformation formula is given by : x' = (a * x) + (b *
* y) + tx y' = (c * x) + (d * y) + ty Where x and y are the
* coordinates of any point, x' and y' the coordinates of the
* trasformed point, tx and ty the horizontal and vertical
* components of the translation and where a, b, c and d are the
* coefficients of the matrix associated to the orientation.
*
* \remark The exact name of the orientation is, i.e. for <b>R1</b> :
* <b>Transformation::Orientation::R1</b>. It's a little verbose
* but you use seldom those codes. If nevertheless you make
* intensive use of them you can locally write :
\code
#define Transformation::Orientation TO
\endcode
* and then use the expression :
\code
TO::R1
\endcode
*/
/*! \name Constructors
*/
// \{
/*! \function Transformation::Transformation();
* Default constructor : The translation is null and the
* orientation is equal to <b>ID</b>.
*/
/*! \function Transformation::Transformation(const Point& translation, const Transformation::Orientation& orientation=Orientation::ID);
* Builds a transformation whose translation part is defined by
* the argument \c \<translation\> and whose default orientation is
* <b>ID</b>.
*/
/*! \function Transformation::Transformation(const Unit& tx, const Unit& ty, const Transformation::Orientation& orientation=Orientation::ID);
* Builds a transformation whose translation part is defined by
* the arguments \c \<xt\> and \c \<ty\> and whose orientation
* is defined by \c \<orientation\> (\c \<ID\> by default).
*/
/*! \function Transformation::Transformation(const Point& translation, const Transformation::Orientation& orientation);
* Builds a transformation whose translation part is defined by
* the argument \c \<translation\> and whose orientation is
* defined by \c \<orientation\>.
*/
/*! \function Transformation::Transformation(const Transformation& transformation);
* Copy constructor.
*/
// \}
/*! \name Operators
*/
// \{
/*! \function Transformation& Transformation::operator=(const Transformation& transformation);
* Assignment operator.
*/
/*! \function bool Transformation::operator==(const Transformation& transformation) const;
* Two transformations are identical if their translations and
* orientation are identical.
*/
/*! \function bool Transformation::operator!=(const Transformation& transformation) const;
* Two transformations are different if eitheir their
* translations or orientation differ.
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function const Unit& Transformation::GetTx() const;
* \Return the horizontal component of the translation.
*/
/*! \function const Unit& Transformation::GetTy() const;
* \Return the vertical component of the translation.
*/
/*! \function Point Transformation::GetTranslation() const;
* \Return the translation component of the transformation.
*/
/*! \function const Translation::Orientation& Transformation::GetOrientation() const;
* \Return the orientation of the transformation (may be used in a
* switch).
*/
/*! \function Unit Transformation::GetX(const Unit& x, const Unit& y) const;
* \Return the point abscissa resulting of the transformation
* application on the point defined by \c \<x\> et \c \<y\>.
*/
/*! \function Unit Transformation::GetY(const Unit& x, const Unit& y) const;
* \Return the point ordinate resulting of the transformation
* application on the point defined by \c \<x\> et \c \<y\>.
*/
/*! \function Unit Transformation::GetX(const Point& point) const;
* \Return the point abscissa resulting of the transformation
* application on \c \<point\>.
*/
/*! \function Unit Transformation::GetY(const Point& point) const;
* \Return the point ordinate resulting of the transformation
* application on \c \<point\>.
*/
/*! \function Unit Transformation::GetDx(const Unit& dx, const Unit& dy) const;
* \Return the horizontal component of the vector resulting from the
* application of the transformation on the vector defined by
* \c \<dx\> et \c \<dy\>.
*/
/*! \function Unit Transformation::GetDy(const Unit& dx, const Unit& dy) const;
* \Return the vertical component of the vector resulting from the
* application of the transformation on the vector defined by
* \c \<dx\> et \c \<dy\>.
*/
/*! \function Point Transformation::GetPoint(const Unit& x, const Unit& y) const;
* \Return the point resulting from the application of the
* transformation on the point defined by \c \<dx\> et
* \c \<dy\>.
*/
/*! \function Point Transformation::GetPoint(const Point& point) const;
* \Return the point resulting from the application of the
* transformation on \c \<point\>.
*/
/*! \function Box Transformation::GetBox(const Unit& x1, const Unit& y1, const Unit& x2, const Unit& y2) const;
* \Return the box resulting from the application of the transformation
* on the box defined by \c \<x1\>, \c \<y1\>, \c \<x2\> et
* \c \<y2\>.
*/
/*! \function Box Transformation::GetBox(const Point& point1, const Point& point2) const;
* \Return the box resulting from the application of the transformation
* on the box defined by \c \<point1\> et \c \<point2\>.
*/
/*! \function Box Transformation::GetBox(const Box& box) const;
* \Return the box resulting from the application of the transformation
* on the box \c \<box\>.
*/
/*! \function Transformation Transformation::GetTransformation(const Transformation& transformation) const;
* \Return the transformation resulting from the application of the
* transformation on the transformation \c \<transformation\>.
*/
/*! \function Transformation Transformation::GetInvert() const;
* \Return the inverse transformation.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function Transformation& Transformation::Invert();
* Inverts the transformation \c \<this\> and returns a
* reference to it in order to apply in sequence a new function.
*/
// \}
/*! \section secTransformationTransformers Transformers
*
*
* <b>Transformation::ApplyOn</b>
*
* <b>Transformation::ApplyOn</b>
*
* <b>Transformation::ApplyOn</b>
*
* <b>Transformation::ApplyOn</b>
*/
/* \name Others
*/
// \{
/*! \function void Transformation::ApplyOn(Unit& x, Unit& y) const;
* Applies the transformation on the coordinates given in
* arguments.
*/
/*! \function void Transformation::ApplyOn(Point& point) const;
* Applies the transformation on the point given in argument.
*/
/*! \function void Transformation::ApplyOn(Box& box) const;
* Applies the transformation on the box given in argument.
*/
/*! \function void Transformation::ApplyOn(Transformation& transformation) const;
* Applies the transformation on the transformation given in
* argument. This last one becomes then the transformation
* resulting of the product of those two.
*/
// \}
}

141
hurricane/doc/hurricane/Unit.dox Normal file
View File

@ -0,0 +1,141 @@
// -*- C++ -*-
namespace Hurricane {
/*! \defgroup Unit Unit description
*
* \section secUnitIntro Introduction
*
* Those objects are used to model a geometric lengths, that is
* abscissas, ordinates, widths, offsets ...
*
* They are represented internally by a <b>long integer</b>
* asociated with a <b>precision</b> and not by a double in
* order to avoid floating point round errors.
*
*
* \section secUnitPrecision Precision
*
* It is possible to choose (once for all) the precision with
* which unit values are stored.
*
* This precision represents the maximal number of decimal
* digits allowed (it applies globally to all units). Therefore
* for a precision of 3, the unit will represent a value of
* 0.001 and the effective value 23.54 will be represented by a
* unit equal to 23540.
*
* <ul>
* <li><b>Unit::GetPrecision</b>
* <li><b>Unit::GetMaximalPrecisionAllowed</b>
* <li><b>Unit::SetPrecision</b>
* </ul>
*
*
* \section secUnitResolution Resolution
*
* The resolution is associated to the precision. Indeed it
* represents the external value associated to the smallest
* unit, that is the value returned by GetValue(GetUnit(1)).
*
* <b>Unit::GetResolution</b>
*
*
* \section secUnitGrid Grid
*
* <ul>
* <li><b>Unit::GetGridStep</b>
* <li><b>Unit::SetGridStep</b>
* <li><b>Unit::IsOnGrid</b>
* <li><b>Unit::GetOnGridUnit</b>
* </ul>
*
*
* \section secUnitTranslators Translators
*
* <ul>
* <li><b>Unit::GetUnit</b>
* <li><b>Unit::GetValue</b>
* <li><b>Unit::GetValueString</b>
* </ul>
*/
/*! \ingroup Unit
*/
// \{
/*! \function bool Unit::IsOnGrid(const Unit& unit, int n = 1);
* \Return \true if the unit is on grid, else \false. The argument
* \c \<n\> allows to consider on grid only multiples of
* \c \<n\> grid steps. So if n=1 all grid steps are considered,
* but if n=2 only even grid steps are considered.
*/
/*! \function unsigned Unit::GetPrecision();
* \Return the current precision (whose default is fixed to 0).
*/
/*! \function unsigned Unit::GetMaximalPrecisionAllowed();
* \Return the maximal precision allowed (currently fixed to 3).
*/
/*! \function double Unit::GetResolution();
* \Return the current resolution.
*/
/*! \function const Unit& Unit::GetGridStep();
* \Return the grid step.
*/
/*! \function Unit Unit::GetOnGridUnit(const Unit& unit, int s = 0);
* \Return the closest location on grid if the argument \c \<s\> equals
* 0, the closest inferior location on grid if the argument
* \c \<s\> equals -1 and the closest superior location on grid
* if the argument \c \<s\> equals +1.
*
* \remark Throw an exception for any other \c \<s\> argument value.
*/
/*! \function Unit GetUnit(double value);
* \Return the unit corresponding to the value \c \<value\> according to
* the current precision.
*/
/*! \function double GetValue(const Unit& unit);
* \Return the external value associated to the unit \c \<unit\>
* according to the current precision.
*/
/*! \function string GetValueString(const Unit& unit);
* \Return a character string representing the external value of
* \c \<unit\>.
*
* \remark This string is shorter than the one we could print from the
* external value because non needed decimals are not drawn (nor
* the point if value is integer).
*/
/*! \function void SetPrecision(unsigned precision);
* Allows to set the precision at a requested value. This must
* be done at the begining of the program (before the creation
* of the first unit) and not changed for the following (unless
* mandatory and for a temporary period because all existing
* units would be misinterpreted).
*
* \remark This function throws an exception if the requested precision
* is greater than the maximal one.
*/
/*! \function void SetGridStep(const Unit& gridStep);
* Allows to change the grid step.
*/
// \}
}

12
hurricane/doc/hurricane/UpdateSession.dox Normal file
View File

@ -0,0 +1,12 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class UpdateSession
* \brief UpdateSession description (\b API)
*
*/
}

94
hurricane/doc/hurricane/VectorCollection.dox Normal file
View File

@ -0,0 +1,94 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class VectorCollection
* \brief VectorCollection description (\b API)
*
* \section secVectorCollectionIntro Introduction
*
* This collection allows you to handle a STL vector as a
* collection.
*
* In priciple you don't need to handle directly this
* collection, you only need to handle a generic collection
* bound to a <b>VectorCollection</b> as created by the generic
* function <b>GetCollection</b>(...) which builds one when its
* argument is a STL vector (for that reason we will not
* describe it).
*
*
* \section secVectorCollectionOverloadingsOfTheGetcollectionGenericFunction Overloadings of the GetCollection generic function
*
* <ul>
* <li><b>Hurricane::VectorCollection::GetCollection</b>
* <li><b>Hurricane::VectorCollection::GetCollection</b>
* </ul>
*
*
* \section secVectorCollectionRemarks Remarks
*
* Comme pour toutes les collections, il n'y a pas de copie des
* éléments contenus dans le vecteur mais plutot une mise en
* correspondance du vecteur avec la collection.
*
* Une fois la collection créée il est tout à fait possible de
* modifier le vecteur ; les éléments ajoutés ou supprimés
* seront alors pris en compte ou pas lors du parcours de la
* collection comme le montre l'exemple suivant :
*
* Like for the other collections, there is no copy of the
* elements included in the vector, but instead a link from the
* collection to the vector.
*
* Once the collection as been built, you can perfectly modify
* the vector; the added or deleted elements will be taken into
* account when visiting the vector, as shown in the following
* example :
\code
vector<Net*> netVector;
Nets nets = GetCollection(netVector);
// nets is then bound to the vector netVector
// and will reflect its content until the end
// so we can :
assert(nets.IsEmpty());
Cell* cell = ... // we get a cell
if (cell) {
Net* net = cellGetNet("vdd");
if (net) {
netVector.push_back(net);
// and now :
assert(nets.GetSize() == 1);
}
}
\endcode
*/
/* \name Accessors
*/
// \{
/*! \function GenericCollection<Element> VectorCollection::GetCollection(const vector<Element>& elementVector);
* See below.
*/
/*! \function GenericCollection<Element> VectorCollection::GetCollection(const vector<Element>* elementVector);;
* Ces deux fonctions récupèrent sous forme de collection
* générique liée à un <b>VectorCollection</b> le contenu d'un
* vecteur passée en argument.
*
* Those two function return into generic collection bound to a
* <b>VectorCollection</b> the content of the STL vector given
* in argument.
*/
// \}
}

133
hurricane/doc/hurricane/Vertical.dox Normal file
View File

@ -0,0 +1,133 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Vertical
* \brief Vertical description (\b API)
*
* \section secVerticalIntro Introduction
*
* A vertical has, in addition to inherited attributes, a
* specific one : its abscissa. The vertical extend of the
* segment is defined by the "source" and "target" components on
* which it is anchored.
*
* This abscissa allows, among other things, to anchor a
* vertical segment extremity on a component (i.e. a contact)
* with a small horizontal offset without the need to
* materialize it, because it is implicitely equal to the
* difference between the vertical abscissa and the component
* abscissa. It allows also, and it not the least interesting
* feature, to anchor an extremity of a vertical directly on a
* horizontal segment (and conversely) without the need to
* create an intermediate contact (unless they are on different
* layers!). The abscissa of the implicit contact point is the
* one of the vertical and the ordinate the one of the
* horizontal).
*/
/*! \typedef Vertical::Inherit
* Useful for calling upon methods of the base class without
* knowing it.
*/
/*! \name Constructors
*/
// \{
/*! \function Vertical* Vertical::Create(Component* source, Component* target, Layer* layer,const Unit& x,const Unit& width = 0,const Unit& dySource = 0, const Unit& dyTarget = 0);
* Creates and returns a vertical segment whose origin lies
* (through an offset equal to \c \<dySource\>) on
* \c \<source\>, whose extremity lies (through an offset equal
* to \c \<dyTarget\>) on \c \<target\>, with layer
* \c \<layer\>, located at abscissa \c \<x\> and of width
* \c \<width\>.
*
* \caution Throws an exception if any of the source, target or layer
* pointers is null or if the two component don't belong to the
* same net.
*/
/*! \function Vertical* Vertical::Create(Net* net, Layer* layer, const Unit& x, const Unit& width = 0,const Unit& dySource = 0, const Unit& dyTarget = 0);
* Creates and returns an absolute vertical segment with layer
* \c \<layer\>, located at abscissa \c \<x\> and of width
* \c \<width\>. The differents extremities ordinates are given
* by \c \<dySource\> and \c \<dyTarget\>.
*
* \caution Throws an exception if any of the net or layer pointers is
* null.
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function const Unit& Vertical::GetDySource() const;
* \Return the relative source ordinate of the segment (may be absolute
* if the source extremity isn't anchored).
*
* \remark If you want to get the absolute one use the member function
* GetSourceX() defined at the Segment level.
*/
/*! \function const Unit& Vertical::GetDyTarget() const;
* \Return the relative target ordinate of the segment (may be absolute
* if the target extremity isn't anchored).
*
* \remark If you want to get the absolute one use the member function
* GetTargetX() defined at the Segment level.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function void Vertical::SetX(const Unit& x);
* Sets the abscissa of the segment.
*/
/*! \function void Vertical::Translate(const Unit& dx);
* Translate horizontaly the vertical segment of the quantity
* \c \<dx\>.
*/
// \}
/*! \name Vertical Collection
*/
// \{
/*! \typedef Verticals
* Generic collection representing a set of vertical segments.
*/
/*! \typedef VerticalLocator
* Generic locator for traversing a collection of vertical
* segments.
*/
/*! \typedef VerticalFilter
* Generic filter allowing to select a subset of verticals
* matching some criteria.
*/
/*! \def for_each_vertical(vertical, verticals)
* Macro for visiting all the verticals of a collection of
* vertical segments.
*/
// \}
}

699
hurricane/doc/hurricane/View.dox Normal file
View File

@ -0,0 +1,699 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class View
* \brief View description (\b API)
*
* \section secViewIntro Introduction
*
* A view is an object managing the graphic display behaviour of
* a cell. A view is neither a window nor a widget (in their
* strict meaning) but indeed an object which establish a
* relationship between the cell and a DrawingArea widget (the
* display window).
*
* Its purpose is to display the associated cell within this
* drawing area according to characteristics which are only
* driven by this view object (zoom factor, grid display,
* visible layers, selected objects, ...).
*
* Furthermore the view manages the events recieved from the
* drawing area and notifies them to the attached cell in its
* reference coordinates.
*
* A view can display one and only one cell, but a cell can be
* displayed in multiple views. The fact that each view has its
* own characteristics (zoom factor, visible layers, display
* style and depth, ...) provides the capability to show
* different aspects of the same cell within separated windows.
*
* A view being a data base object, you can attach properties to
* it.
*
*
* \section secViewCoordinateSystems Coordinate systems
*
* There are three coordinates systems to be considered : the
* <b>screen coordinate system</b> which references screen pixel
* locations, the <b>cell coordinate system</b> and the
* <b>client coordinate system</b>. Those two last coordinate
* systems are almost always identical, unless when the cell
* display is mapped through a transformation (translation,
* rotation and/or symetry) in order to represent it, for
* instance, in the context of some of its instanciations.
*/
/*! \typedef View::Inherit
* Useful for calling upon methods of the base class without
* knowing it.
*/
/*! \typedef ScreenUnit
* Data type used to represent screen units (pixels). It is
* typed as a form of Unit where the precision is ignored. The
* reason why this type is choosen instead of an integer is that
* we want to use Point and Box (indeed ScreenPoint and
* ScreenBox) which are very handy as we will see later.
*/
/*! \typedef ScreenPoint
* Type used to represent screen pixel position (precision is
* ignored).
*/
/*! \typedef ScreenBox
* Type used to represent a rectangular area expressed in screen
* pixel positions (precision is ignored).
*/
/*! \name Accessors
*/
// \{
/*! \function GtkWidget* View::GetFrame() const;
* \Return the widget containing the drawing area associated to the
* view.
*
* This is the widget which must be inserted into an other
* window of the graphic interface in order to activate the
* display.
*/
/*! \function GtkWidget* View::GetDrawingArea() const;
* \Return the drawing area associated to the view.
*/
/*! \function Cell* View::GetCell() const;
* \Return the cell associated to the view (possibly null).
*
* \remark Views have no attribute refering directly the attached cell.
* Therefore this virtual method must be overloaded for each new
* view sub-type (for the MapView, for instance, the returned
* cell is the one attached to the MainView of which MapView
* represents a location map).
*/
/*! \function Transformation View::GetTransformation() const;
* Views allow to display a cell either within the coordinate
* reference of the cell or with some transformation (useful to
* display an instanciated cell in the context of a given
* occurrence). So this function returns the currently applied
* transformation.
*
* \remark Like the previous function, this virtual method must be
* overloaded.
*/
/*! \function const Point& View::GetCenter() const;
* \Return the point, in client coordinates, located at the center of
* the view.
*/
/*! \function double View::GetScale() const;
* \Return the zoom factor with which the cell is drawn.
*/
/*! \function const ScreenUnit& View::GetScreenWidth() const;
* \Return the screen width of the view (that is the pixel width of the
* drawing area).
*/
/*! \function const ScreenUnit& View::GetScreenHeight() const;
* \Return the screen height of the view (that is the pixel height of
* the drawing area).
*/
/*! \function ScreenUnit View::GetHalfScreenWidth() const;
* \Return the half width of the view.
*/
/*! \function ScreenUnit View::GetHalfScreenHeight() const;
* \Return the half height of the view.
*/
/*! \function Unit View::GetX(const ScreenUnit& screenX) const;
* \Return the client abscissa associated to a pixel abscissa.
*
* \remark The upper left point of the drawing area has always null
* abscissa and ordinate (in pixels), while the center of the
* view has client coordinates returned by <b>GetCenter()</b>.
*
* \remark Within the drawing area, ordinates are increasing from the
* top to bottom, while client ordinates are increasing from the
* bottom to top.
*/
/*! \function Unit View::GetY(const ScreenUnit& screenY) const;
* \Return the client ordinate corresponding to a pixel ordinate.
*/
/*! \function Unit View::GetSize(const ScreenUnit& screenSize) const;
* \Return the client dimension associated to a screen dimension.
\code
int screenAperture = 2; // 2 pixels
Unit clientAperture = view->GetSize(screenAperture);
\endcode
*
*
*/
/*! \function Point View::GetPoint(const ScreenPoint& screenPoint) const;
* \Return the point in client coordinates associated to a point in
* pixel coordinates.
*/
/*! \function Box View::GetBox(const ScreenBox& screenBox) const;
* \Return the box in client coordinates associated to a box in pixel
* coordinates.
*/
/*! \function ScreenUnit View::GetScreenX(const Unit& x) const;
* \Return the pixel abscissa corresponding to a client abscissa.
*/
/*! \function ScreenUnit View::GetScreenY(const Unit& y) const;
* \Return the pixel ordinate corresponding to a client ordinate.
*/
/*! \function ScreenUnit View::GetScreenSize(const Unit& size) const;
* \Return the pixel dimension of a client dimension.
*/
/*! \function ScreenPoint View::GetScreenPoint(const Point& point) const;
* \Return the point in pixel coordinates associated to a point in
* client coordinates.
*/
/*! \function ScreenBox View::GetScreenBox(const Box& box) const;
* \Return the box in pixel coordinates associated to a box in client
* coordinates.
*/
/*! \function Box View::GetClientArea() const;
* \Return the box in client coordinates enclosing the total displayable
* (or displayed) space. This is the bounding box of the cell to
* which has been applied the transformation attached to the
* view, but increased in order to include the points outside
* the cell which are currently visible on the screen. This
* function (with a strange definition) is mainly used to manage
* the X and Y scroll bars.
*/
/*! \function Box View::GetVisibleArea() const;
* \Return the box in client coordinates of the previous defined space
* which is currently visible in the view.
*/
/*! \function Command* View::GetCommand(unsigned button) const;
* \Return the command currently associated to the button, else NULL.
*/
/*! \function View::Commands View::GetCommands() const;
* \Return the collection of commands currently installed on the view.
*/
/*! \function const ScreenUnit& View::GetGridDisplayThreshold() const;
* \Return the display threshold of the grid.
*
* \remark In order to effectively see the grid, the grid must be set
* visible and the zoom factor must allow to distinguish two
* adjacent grid points, that is spaced on the screen by some
* pixel distance. This distance is the grid threshold (whose
* minimal allowed value is 3 pixels and default value fixed to
* 6 pixels).
*/
/*! \function const LayerMask& View::GetVisibleBasicLayersMask() const;
* \Return the bit mask representing the set of basic layers currently
* visible within the view.
*/
/*! \function BasicLayers View::GetVisibleBasicLayers() const;
* \Return the collection of basic layers currently visible within the
* view.
*/
/*! \function Selectors View::GetSelectors() const;
* \Return the collection of selectors associated to the view.
*/
// \}
/*! \name Predicates
*/
// \{
/*! \function bool View::GridIsVisible() const;
* \Return \true if the grid is visible else \false.
*
* \caution The grid may, as explained above, be visible and not
* drawable.
*/
/*! \function bool View::GridIsDrawable() const;
* \Return \true when the grid is drawable, that is when the scale
* factor and the display threshold are such that the grid can
* be visible, else \false.
*
* \caution The grid may be drawable but not set visible.
*/
/*! \function bool View::AutoScrollIsEnabled() const;
* \Return \true when the auto scroll mode is allowed, else \false.
*/
/*! \function bool View::DoubleBufferingIsEnabled() const;
* \Return \true when the delayed display mode (through a double buffer)
* is allowed, else \false.
*/
/*! \function bool View::PhantomsAreVisible() const;
* \Return \true when the phantoms (usually of cell instances) are
* visible, else \false.
*/
/*! \function bool View::BoundariesAreVisible() const;
* \Return \true when the boundaries (usually of cell instances) are
* visible, else \false.
*/
/*! \function bool View::SelectionIsVisible() const;
* \Return \true when the selected objects are set visible, else \false.
*/
/*! \function bool View::IsVisible(BasicLayer* basicLayer) const;
* \Return \true when the basic layer is visible, else \false.
*
* \caution Throws an exception if the basiclayer is null.
*/
/*! \function bool View::IsSelected(const Occurrence& occurrence) const;
* \Return \true if the occurrence is selected in this view, else \false.
*/
/*! \function bool View::HasSomethingSelected() const;
* \Return \false if the selection is empty, else \true.
*/
// \}
/*! \name Modifiers
*/
// \{
/*! \function void View::SetCell(Cell* cell);
* Allows to change the cell displayed within the view.
*
* \remark The view is re-initialized, that is all previous installed
* commands are first unbound, the choosen transform displays
* the new cell in its own reference coordinates, the scale
* factor and the view center area computed in order to make the
* whole cell visible. Then an overall update area event is
* posted.
*/
/*! \function void View::SetTransformation(const Transformation& transformation);
* Changes the transformation associated to the view. The scale
* factor and the view center area computed in order to make the
* whole cell visible. Then an overall update area event is
* posted.
*/
/*! \function void View::ShowGrid();
* Sets visible the grid (which however will be drawn only if
* the zoom factor and the grid display threshold allows it).
*
* The following piece of code shows how display the grid while
* executing a refresh only when neded.
\code
View* view = ...; // we get a view
if (!viewGridIsVisible()) {
viewShowGrid();
if (viewGridIsDrawable()) {
viewRefresh();
}
}
\endcode
*
*
*
* or still simpler :
\code
View* view = ...; // on récupère une vue
viewShowGrid();
viewUpdate();
\endcode
*
*
*
* The second version uses the fact that the function
* <b>ShowGrid</b> posts an overall update area only if the
* display has to be redrawn and the function <b>Update()</b>
* does nothing if no update area has been posted.
*
* \remark If the refresh doesn't occur because the grid is not
* drawable, this one will appear when the zoom factor will
* allows it.
*/
/*! \function void View::HideGrid();
* Makes the grid invisible (an overall update area is posted if
* necessary).
*/
/*! \function void View::SetGridDisplayThreshold(const ScreenUnit& threshold);
* Sets the display threshold of the grid (an overall update
* area is posted if necessary).
*
* \caution An exception is thrown if the threshold is below the minimal
* allowed value.
*/
/*! \function void View::EnableAutoScroll();
* Enables the automatic scroll mode.
*/
/*! \function void View::DisableAutoScroll();
* Disables the automatic scroll mode.
*/
/*! \function void View::EnableDoubleBuffering();
* Enables the delayed double buffering display mode.
*/
/*! \function void View::DisableDoubleBuffering();
* Disables the delayed double buffering display mode.
*/
/*! \function void View::SetVisibleBasicLayersMask(const Layer::Mask& visibleBasicLayersMask);
* Sets the layer mask of visible basic layers.
*/
/*! \function void View::ShowPhantoms();
* Sets visible the phantom layer.
*/
/*! \function void View::HidePhantoms();
* Sets invisible the phantom layer.
*/
/*! \function void View::ShowBoundaries();
* Sets visible the boundary layer.
*/
/*! \function void View::HideBoundaries();
* Sets invisible the boundary layer.
*/
/*! \function void View::ShowSelection();
* Sets visible the selection.
*/
/*! \function void View::HideSelection();
* Sets invisible the selection.
*/
/*! \function void View::Show(BasicLayer* basicLayer);
* Sets visible the basic layer.
*
* \caution An exception is thrown if the basicLayer is null.
*/
/*! \function void View::Hide(BasicLayer* basicLayer);
* Sets invisible the basic layer.
*
* \caution An exception is thrown if the basicLayer is null.
*/
/*! \function void View::ShowAllLayers();
* Sets visible all the basic layers.
*/
/*! \function void View::HideAllLayers();
* Sets invisible all the basic layers.
*/
/*! \function void View::Select(Occurrence& occurrence);
* Selects the occurrence if it was not already selected.
*
* \caution An excetion is thrown if the occurrence is not valid or if it
* doesn't pertain to the cell associated to the view.
*/
/*! \function void View::Unselect(Occurrence& occurrence);
* Unselects the occurrence if it was already selected.
*
* \caution An excetion is thrown if the occurrence is not valid or if it
* doesn't pertain to the cell associated to the view.
*/
/*! \function void View::UnselectAll();
* Unselects all the selected occurrences.
*/
// \}
/*! \name Managers
*/
// \{
/*! \function void View::Invalidate();
* Invalidates the whole view, therefore at the next call upon
* <b>Update()</b> all the view will be redrawn.
*/
/*! \function void View::Invalidate(const Box& area);
* Invalidates the client area defined by \c \<area\>, therefore
* at the next call upon <b>Update()</b> all this area will be
* redrawn.
*/
/*! \function bool View::Update(bool useDoubleBuffering=false);
* Updates the view by redrawing the rectangular area resulting
* of the union of invalidated areas.
*
* \remark Its advantage is to do nothing if no area has been
* invalidated.
*/
/*! \function bool View::Refresh(bool useDoubleBuffering=false);
* Refreshes globally the view.
*
* The following piece of code shows its implementation.
\code
void View::Refresh()
// *****************
{
Invalidate();
Update();
}
\endcode
* Use preferably the function <b>Update()</b> which doesn't
* execute useless refreshes and which updates only the drawing
* of invalidated areas, but sometimes a <b>Refresh()</b> is
* worthwhile to eliminate possible graphic scoria.
*/
/*! \function void View::VerticalScroll(const Unit& dy);
* No description.
*/
/*! \function void View::HorizontalScroll(const Unit& dx);
* No description.
*/
/*! \function void View::Scroll(const Unit& dx, const Unit& dy);
* Those functions scroll the view of \c \<dx\> and \c \<dy\>.
* Those values are defined in client coordinates (and not in
* pixel) and may be negative. The uncovered areas are
* automatically updated.
*/
/*! \function void View::Reframe(const Point& center);
* This function moves the visible area to a new area centered
* in \c \<center\> without changing the scale factor (an
* overall update area is posted if necessary).
*
* In order to center the view on a given point just do :
\code
Point newCenter = ...; // define the new center
viewReframe(newCenter);
viewUpdate(); // to get an immediate effect
\endcode
*
*
*
* And to apply a "pan right" just do :
\code
Point newCenter =
Point(viewGetX(viewGetScreenWidth()), viewGetCenter().GetY());
viewReframe(newCenter);
viewUpdate(); // to get an immediate effect
\endcode
*
*
*
* or else :
\code
Point newCenter = viewGetCenter();
newCenter.Translate(viewGetSize(viewGetHalfScreenWidth()), 0);
viewReframe(newCenter);
viewUpdate(); // to get an immediate effect
\endcode
*
*
*/
/*! \function void View::Reframe(const Point& center, double scale);
* This function has the same behaviour but allows also to
* change the scale factor (an overall update area is posted if
* necessary).
*
* To apply a "zoom in" while maintaining the same center just
* do :
\code
viewReframe(viewGetCenter(), viewGetScale() * 2);
viewUpdate(); // to get an immediate effect
\endcode
*
*
*
* To apply a "zoom out" while maintaining the same center just
* do :
\code
viewReframe(viewGetCenter(), viewGetScale() * 0.5);
viewUpdate(); // to get an immediate effect
\endcode
*
*
*/
/*! \function void View::Reframe(const Box& area);
* Changes the view point in order to let the area be visible
* and centered (a global update area is posted if needed). If
* the area is empty or if one of its dimensions is null, the
* function does nothing.
*
* \remark The ratio width/height of the view may be different than the
* ratio width/height of the area, this last may not fully
* occupy all the view space but will be anyway fully visible.
*
* If we want to reframe the view on a given instance, just do :
\code
Instance* instance = ...; // let's get the instance
Box area = instance->GetAbutmentBox();
viewReframe(view->GetTransformation().GetBox(area));
// we apply to area the view transformation with which the cell is displayed
viewUpdate(); // to get an immediate effect
\endcode
*/
/*! \function void View::ReframeBack();
* \Return to the previous point.
*/
/*! \function void View::FitToContent();
* Changes both the view center and zoom factor in order to make
* an overview of the cell (an overall update area is posted if
* necessary).
*/
/*! \function void View::DrawGhost(Command* command);
* Some commands have a method <b>_OnDrawGhost()</b> which
* allows to draw the ghost associated to the command. This
* message is indeed called upon automatically by the system
* when neded, but sometimes it is necessary to trigger
* explicitelly the ghost drawing. This must not be done by
* calling directly the object's method, but by calling upon
* this which does the same but after setting up the graphic
* context.
*/
// \}
/*! \name Drawing Primitives
*/
// \{
/*! \function void View::DrawLine(const Unit& xo, const Unit& yo, const Unit& xe, const Unit& ye);
* No description.
*/
/*! \function void View::DrawLine(const Point& origin, const Point& extremity);
* Those primitives allow to draw a line.
*/
/*! \function void View::DrawRectangle(const Unit& xo, const Unit& yo, const Unit& xe, const Unit& ye);
* No description.
*/
/*! \function void View::DrawRectangle(const Point& origin, const Point& extremity);
* No description.
*/
/*! \function void View::DrawRectangle(const Box& box);
* Those primitives allow to draw an hollowed rectangle.
*/
/*! \function void View::FillRectangle(const Unit& xo, const Unit& yo, const Unit& xe, const Unit& ye, bool solid = false);
* No description.
*/
/*! \function void View::FillRectangle(const Point& origin, const Point& extremity, bool solid = false);
* No description.
*/
/*! \function void View::FillRectangle(const Box& box, bool solid = false);
* Those primitives allow to fill a rectangle, either with a
* uniform color if the flag \c \<solid\> is set or with a
* stipple when this flag is off (default behaviour).
*/
// \}
/*! \name View Collection
*/
// \{
/*! \typedef Views
* Generic collection representing a set of views.
*/
/*! \typedef ViewLocator
* Generic locator for traversing a collection of views.
*/
/*! \typedef ViewFilter
* Generic filter for selecting a subset of views matching some
* criteria.
*/
/*! \def for_each_view(view, views)
* Macro for visiting all views of a collection of views.
*/
// \}
}

83
hurricane/doc/hurricane/Warning.dox Normal file
View File

@ -0,0 +1,83 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class Warning
* \brief Warning description (\b API)
*
* \section secWarningIntro Introduction
*
* There is no difference with the Error type but the printed
* message is prefixed by <b>WARNING</b> instead of
* <b>ERROR</b>.
*
* \section secWarningNouveauxTypes Nouveaux types
*
* type: <b>Warning::Inherit</b> -\> Exception Useful for
* calling the base class methods without knowing this class.
*
*
* \section secWarningRemark Remark
*
* You can also use this object to print messages without
* throwing an exception as shown below :
\code
Cell* cell = libraryGetCell("adder"); // we get the cell
if (!cell)
cerr << Warning("Unknown cell adder") << endl;
else {
// we know what to do here
}
\endcode
* The same remark applies to all exception types.
*/
/*! \name Constructors
*/
// \{
/*! \function Warning::Warning(const string& reason, int code = 0);
* Builds a warning characterized by a reason and a code useful
* within a switch.
*/
/*! \function Warning::Warning(const Warning& warning);
* Copy constructor.
*/
// \}
/*! \name Operators
*/
// \{
/*! \function Warning& Warning::operator=(const Warning& warning);
* Assignment operator.
*/
// \}
/*! \name Accessors
*/
// \{
/*! \function const string& Warning::GetReason() const;
* \Return the reason for which the warning was thrown.
*/
/*! \function int Warning::GetCode() const;
* \Return the warning code number.
*/
// \}
}

72
hurricane/doc/hurricane/ZoomCommand.dox Normal file
View File

@ -0,0 +1,72 @@
// -*- C++ -*-
namespace Hurricane {
/*! \class ZoomCommand
* \brief ZoomCommand description (\b API)
*
* \section secZoomCommandIntro Introduction
*
* This command allows to reframe the main view over the cell
* portion enclosed into a rectangle defined either in the main
* view or in the associated map view.
*
* This command is named <b>"Zoom"</b> and is bound to the mouse
* <b>left button</b>.
*
* In order to let this command be available at any time, it is
* advisable to have this only command bound to the left button.
* As far as the rigth button is reserved (in principle) to a
* contextual pop-menu, the other commands should be bound to
* the middle button (like the selection command).
*
*
* \section secZoomCommandRemark Remark
*
* We have detailed, when explaining the Command class, a way to
* implement this command.
*
* However things are in fact slightly different for the
* implementation of the message _OnButtonRelease which must
* take into account that the rubber rectangle may be defined
* either in the main view or in the associated map view.
*
* The implementation of this message is not really more complex
* :
\code
void ZoomCommand::_OnButtonRelease(View* view, const Point& position)
// ******************************************************************
{
viewDrawGhost(this);
_started = false;
if (_extremity != _origin) {
if (is_a<MapView*>(view)) {
// when the view is the reframe map, the zoom must be
// applied on the associated main view
view = ((MapView*)view)GetMainView();
}
viewReframe(Box(_origin, _extremity));
viewRefresh();
}
}
\endcode
*/
/* \name ZoomCommand Functions
*/
// \{
/* \function ZoomCommand* ZoomCommand::GetZoomCommand();
* \Return the zoom command.
*/
// \}
}

798
hurricane/doc/hurricane/asimbook.cls Normal file
View File

@ -0,0 +1,798 @@
%%
%% This is file `book.cls',
%% generated with the docstrip utility.
%%
%% The original source files were:
%%
%% classes.dtx (with options: `book')
%%
%% This is a generated file.
%%
%% Copyright 1993 1994 1995 1996 1997 1998 1999 2000 2001
%% The LaTeX3 Project and any individual authors listed elsewhere
%% in this file.
%%
%% This file was generated from file(s) of the LaTeX base system.
%% --------------------------------------------------------------
%%
%% It may be distributed and/or modified under the
%% conditions of the LaTeX Project Public License, either version 1.2
%% of this license or (at your option) any later version.
%% The latest version of this license is in
%% http://www.latex-project.org/lppl.txt
%% and version 1.2 or later is part of all distributions of LaTeX
%% version 1999/12/01 or later.
%%
%% This file may only be distributed together with a copy of the LaTeX
%% base system. You may however distribute the LaTeX base system without
%% such generated files.
%%
%% The list of all files belonging to the LaTeX base distribution is
%% given in the file `manifest.txt'. See also `legal.txt' for additional
%% information.
%%
%% \CharacterTable
%% {Upper-case \A\B\C\D\E\F\G\H\I\J\K\L\M\N\O\P\Q\R\S\T\U\V\W\X\Y\Z
%% Lower-case \a\b\c\d\e\f\g\h\i\j\k\l\m\n\o\p\q\r\s\t\u\v\w\x\y\z
%% Digits \0\1\2\3\4\5\6\7\8\9
%% Exclamation \! Double quote \" Hash (number) \#
%% Dollar \$ Percent \% Ampersand \&
%% Acute accent \' Left paren \( Right paren \)
%% Asterisk \* Plus \+ Comma \,
%% Minus \- Point \. Solidus \/
%% Colon \: Semicolon \; Less than \<
%% Equals \= Greater than \> Question mark \?
%% Commercial at \@ Left bracket \[ Backslash \\
%% Right bracket \] Circumflex \^ Underscore \_
%% Grave accent \` Left brace \{ Vertical bar \|
%% Right brace \} Tilde \~}
\NeedsTeXFormat{LaTeX2e}[1995/12/01]
\ProvidesClass{asimbook}
[2005/11/21 v1.0
ASIM LaTeX document class]
\newcommand\@ptsize{}
\newif\if@restonecol
\newif\if@titlepage
\@titlepagetrue
\newif\if@openright
\newif\if@mainmatter \@mainmattertrue
\if@compatibility\else
\DeclareOption{a4paper}
{\setlength\paperheight {297mm}%
\setlength\paperwidth {210mm}}
\DeclareOption{a5paper}
{\setlength\paperheight {210mm}%
\setlength\paperwidth {148mm}}
\DeclareOption{b5paper}
{\setlength\paperheight {250mm}%
\setlength\paperwidth {176mm}}
\DeclareOption{letterpaper}
{\setlength\paperheight {11in}%
\setlength\paperwidth {8.5in}}
\DeclareOption{legalpaper}
{\setlength\paperheight {14in}%
\setlength\paperwidth {8.5in}}
\DeclareOption{executivepaper}
{\setlength\paperheight {10.5in}%
\setlength\paperwidth {7.25in}}
\DeclareOption{landscape}
{\setlength\@tempdima {\paperheight}%
\setlength\paperheight {\paperwidth}%
\setlength\paperwidth {\@tempdima}}
\fi
\if@compatibility
\renewcommand\@ptsize{0}
\else
\DeclareOption{10pt}{\renewcommand\@ptsize{0}}
\fi
\DeclareOption{11pt}{\renewcommand\@ptsize{1}}
\DeclareOption{12pt}{\renewcommand\@ptsize{2}}
\if@compatibility\else
\DeclareOption{oneside}{\@twosidefalse \@mparswitchfalse}
\fi
\DeclareOption{twoside}{\@twosidetrue \@mparswitchtrue}
\DeclareOption{draft}{\setlength\overfullrule{5pt}}
\if@compatibility\else
\DeclareOption{final}{\setlength\overfullrule{0pt}}
\fi
\DeclareOption{titlepage}{\@titlepagetrue}
\if@compatibility\else
\DeclareOption{notitlepage}{\@titlepagefalse}
\fi
\if@compatibility
\@openrighttrue
\else
\DeclareOption{openright}{\@openrighttrue}
\DeclareOption{openany}{\@openrightfalse}
\fi
\if@compatibility\else
\DeclareOption{onecolumn}{\@twocolumnfalse}
\fi
\DeclareOption{twocolumn}{\@twocolumntrue}
\DeclareOption{leqno}{\input{leqno.clo}}
\DeclareOption{fleqn}{\input{fleqn.clo}}
\DeclareOption{openbib}{%
\AtEndOfPackage{%
\renewcommand\@openbib@code{%
\advance\leftmargin\bibindent
\itemindent -\bibindent
\listparindent \itemindent
\parsep \z@
}%
\renewcommand\newblock{\par}}%
}
\ExecuteOptions{letterpaper,10pt,twoside,onecolumn,final,openright}
\ProcessOptions
\input{bk1\@ptsize.clo}
\setlength\lineskip{1\p@}
\setlength\normallineskip{1\p@}
\renewcommand\baselinestretch{}
\setlength\parskip{0\p@ \@plus \p@}
\@lowpenalty 51
\@medpenalty 151
\@highpenalty 301
\setcounter{topnumber}{2}
\renewcommand\topfraction{.7}
\setcounter{bottomnumber}{1}
\renewcommand\bottomfraction{.3}
\setcounter{totalnumber}{3}
\renewcommand\textfraction{.2}
\renewcommand\floatpagefraction{.5}
\setcounter{dbltopnumber}{2}
\renewcommand\dbltopfraction{.7}
\renewcommand\dblfloatpagefraction{.5}
%%%% Select Chapter font.
\newcommand \textchapter [1] {\textsf{\textbf{#1}}}
\newcommand \fontchapter {\sffamily \bfseries}
\if@twoside
\def\ps@headings{%
\let\@oddfoot\@empty\let\@evenfoot\@empty
\def\@evenhead{\thepage\hfil\slshape\leftmark}%
\def\@oddhead{{\slshape\rightmark}\hfil\thepage}%
\let\@mkboth\markboth
\def\chaptermark##1{%
\markboth {\MakeUppercase{%
\ifnum \c@secnumdepth >\m@ne
\if@mainmatter
\@chapapp\ \thechapter. \ %
\fi
\fi
##1}}{}}%
\def\sectionmark##1{%
\markright {\MakeUppercase{%
\ifnum \c@secnumdepth >\z@
\thesection. \ %
\fi
##1}}}}
\else
\def\ps@headings{%
\let\@oddfoot\@empty
\def\@oddhead{{\slshape\rightmark}\hfil\thepage}%
\let\@mkboth\markboth
\def\chaptermark##1{%
\markright {\MakeUppercase{%
\ifnum \c@secnumdepth >\m@ne
\if@mainmatter
\@chapapp\ \thechapter. \ %
\fi
\fi
##1}}}}
\fi
\def\ps@myheadings{%
\let\@oddfoot\@empty\let\@evenfoot\@empty
\def\@evenhead{\thepage\hfil\slshape\leftmark}%
\def\@oddhead{{\slshape\rightmark}\hfil\thepage}%
\let\@mkboth\@gobbletwo
\let\chaptermark\@gobble
\let\sectionmark\@gobble
}
\if@titlepage
\newcommand\maketitle{\begin{titlepage}%
\let\footnotesize\small
\let\footnoterule\relax
\let \footnote \thanks
\null\vfil
\vskip 60\p@
\begin{center}%
{\LARGE \@title \par}%
\vskip 3em%
{\large
\lineskip .75em%
\begin{tabular}[t]{c}%
\@author
\end{tabular}\par}%
\vskip 1.5em%
{\large \@date \par}% % Set date in \large size.
\end{center}\par
\@thanks
\vfil\null
\end{titlepage}%
\setcounter{footnote}{0}%
\global\let\thanks\relax
\global\let\maketitle\relax
\global\let\@thanks\@empty
\global\let\@author\@empty
\global\let\@date\@empty
\global\let\@title\@empty
\global\let\title\relax
\global\let\author\relax
\global\let\date\relax
\global\let\and\relax
}
\else
\newcommand\maketitle{\par
\begingroup
\renewcommand\thefootnote{\@fnsymbol\c@footnote}%
\def\@makefnmark{\rlap{\@textsuperscript{\normalfont\@thefnmark}}}%
\long\def\@makefntext##1{\parindent 1em\noindent
\hb@xt@1.8em{%
\hss\@textsuperscript{\normalfont\@thefnmark}}##1}%
\if@twocolumn
\ifnum \col@number=\@ne
\@maketitle
\else
\twocolumn[\@maketitle]%
\fi
\else
\newpage
\global\@topnum\z@ % Prevents figures from going at top of page.
\@maketitle
\fi
\thispagestyle{plain}\@thanks
\endgroup
\setcounter{footnote}{0}%
\global\let\thanks\relax
\global\let\maketitle\relax
\global\let\@maketitle\relax
\global\let\@thanks\@empty
\global\let\@author\@empty
\global\let\@date\@empty
\global\let\@title\@empty
\global\let\title\relax
\global\let\author\relax
\global\let\date\relax
\global\let\and\relax
}
\def\@maketitle{%
\newpage
\null
\vskip 2em%
\begin{center}%
\let \footnote \thanks
{\LARGE \@title \par}%
\vskip 1.5em%
{\large
\lineskip .5em%
\begin{tabular}[t]{c}%
\@author
\end{tabular}\par}%
\vskip 1em%
{\large \@date}%
\end{center}%
\par
\vskip 1.5em}
\fi
\newcommand*\chaptermark[1]{}
\setcounter{secnumdepth}{2}
\newcounter {part}
\newcounter {chapter}
\newcounter {section}[chapter]
\newcounter {subsection}[section]
\newcounter {subsubsection}[subsection]
\newcounter {paragraph}[subsubsection]
\newcounter {subparagraph}[paragraph]
\renewcommand \thepart {\@Roman\c@part}
\renewcommand \thechapter {\@arabic\c@chapter}
\renewcommand \thesection {\thechapter.\@arabic\c@section}
\renewcommand\thesubsection {\thesection.\@arabic\c@subsection}
\renewcommand\thesubsubsection{\thesubsection .\@arabic\c@subsubsection}
\renewcommand\theparagraph {\thesubsubsection.\@arabic\c@paragraph}
\renewcommand\thesubparagraph {\theparagraph.\@arabic\c@subparagraph}
\newcommand\@chapapp{\chaptername}
\newcommand\frontmatter{%
\cleardoublepage
\@mainmatterfalse
\pagenumbering{roman}}
\newcommand\mainmatter{%
\cleardoublepage
\@mainmattertrue
\pagenumbering{arabic}}
\newcommand\backmatter{%
\if@openright
\cleardoublepage
\else
\clearpage
\fi
\@mainmatterfalse}
\newcommand\part{%
\if@openright
\cleardoublepage
\else
\clearpage
\fi
\thispagestyle{plain}%
\if@twocolumn
\onecolumn
\@tempswatrue
\else
\@tempswafalse
\fi
\null\vfil
\secdef\@part\@spart}
\def\@part[#1]#2{%
\ifnum \c@secnumdepth >-2\relax
\refstepcounter{part}%
\addcontentsline{toc}{part}{\thepart\hspace{1em}#1}%
\else
\addcontentsline{toc}{part}{#1}%
\fi
\markboth{}{}%
{\centering
\interlinepenalty \@M
\normalfont
\ifnum \c@secnumdepth >-2\relax
\huge\bfseries \partname\nobreakspace\thepart
\par
\vskip 20\p@
\fi
\Huge \bfseries #2\par}%
\@endpart}
\def\@spart#1{%
{\centering
\interlinepenalty \@M
\normalfont
\Huge \bfseries #1\par}%
\@endpart}
\def\@endpart{\vfil\newpage
\if@twoside
\if@openright
\null
\thispagestyle{empty}%
\newpage
\fi
\fi
\if@tempswa
\twocolumn
\fi}
\newcommand\chapter{\if@openright\cleardoublepage\else\clearpage\fi
\thispagestyle{plain}%
\global\@topnum\z@
\@afterindentfalse
\secdef\@chapter\@schapter}
\def\@chapter[#1]#2{\ifnum \c@secnumdepth >\m@ne
\if@mainmatter
\refstepcounter{chapter}%
\typeout{\@chapapp\space\thechapter.}%
\addcontentsline{toc}{chapter}%
{\protect\numberline{\thechapter}#1}%
\else
\addcontentsline{toc}{chapter}{#1}%
\fi
\else
\addcontentsline{toc}{chapter}{#1}%
\fi
\chaptermark{#1}%
\addtocontents{lof}{\protect\addvspace{10\p@}}%
\addtocontents{lot}{\protect\addvspace{10\p@}}%
\if@twocolumn
\@topnewpage[\@makechapterhead{#2}]%
\else
\@makechapterhead{#2}%
\@afterheading
\fi}
%%%%\def\@makechapterhead#1{%
%%%% \vspace*{50\p@}%
%%%% {\parindent \z@ \raggedright \normalfont
%%%% \ifnum \c@secnumdepth >\m@ne
%%%% \if@mainmatter
%%%% \huge\bfseries \@chapapp\space \thechapter
%%%% \par\nobreak
%%%% \vskip 20\p@
%%%% \fi
%%%% \fi
%%%% \interlinepenalty\@M
%%%% \Huge \bfseries #1\par\nobreak
%%%% \vskip 40\p@
%%%% }}
\newlength \titlewidth
\setlength \titlewidth {\textwidth}
\addtolength \titlewidth {\marginparwidth}
\addtolength \titlewidth {\marginparsep}
\def\@makechapterhead#1{%
\vspace*{50\p@}%
{\parindent \z@ \raggedleft \fontchapter
\ifnum \c@secnumdepth >\m@ne
\if@mainmatter
\huge \@chapapp\space \thechapter
\par\nobreak
\vskip 20\p@
\fi
\fi
\interlinepenalty\@M
\hsize=\titlewidth
\Huge #1 \par\nobreak
\hsize=\textwidth
\vskip 40\p@
}}
\def\@schapter#1{\if@twocolumn
\@topnewpage[\@makeschapterhead{#1}]%
\else
\@makeschapterhead{#1}%
\@afterheading
\fi}
%%%%\def\@makeschapterhead#1{%
%%%% \vspace*{50\p@}%
%%%% {\parindent \z@ \raggedright
%%%% \normalfont
%%%% \interlinepenalty\@M
%%%% \Huge \bfseries #1\par\nobreak
%%%% \vskip 40\p@
%%%% }}
\def\@makeschapterhead#1{%
\vspace*{50\p@}%
{\parindent \z@ \raggedright
\normalfont
\interlinepenalty\@M
\hsize=\titlewidth
\flushright
\Huge \bfseries #1\par\nobreak
\hsize=\textwidth
\vskip 40\p@
}}
\newcommand\section{\@startsection {section}{1}{\z@}%
{-3.5ex \@plus -1ex \@minus -.2ex}%
{2.3ex \@plus.2ex}%
{\normalfont\Large\bfseries}}
\newcommand\subsection{\@startsection{subsection}{2}{\z@}%
{-3.25ex\@plus -1ex \@minus -.2ex}%
{1.5ex \@plus .2ex}%
{\normalfont\large\bfseries}}
\newcommand\subsubsection{\@startsection{subsubsection}{3}{\z@}%
{-3.25ex\@plus -1ex \@minus -.2ex}%
{1.5ex \@plus .2ex}%
{\normalfont\normalsize\bfseries}}
\newcommand\paragraph{\@startsection{paragraph}{4}{\z@}%
{3.25ex \@plus1ex \@minus.2ex}%
{-1em}%
{\normalfont\normalsize\bfseries}}
\newcommand\subparagraph{\@startsection{subparagraph}{5}{\parindent}%
{3.25ex \@plus1ex \@minus .2ex}%
{-1em}%
{\normalfont\normalsize\bfseries}}
\if@twocolumn
\setlength\leftmargini {2em}
\else
\setlength\leftmargini {2.5em}
\fi
\leftmargin \leftmargini
\setlength\leftmarginii {2.2em}
\setlength\leftmarginiii {1.87em}
\setlength\leftmarginiv {1.7em}
\if@twocolumn
\setlength\leftmarginv {.5em}
\setlength\leftmarginvi {.5em}
\else
\setlength\leftmarginv {1em}
\setlength\leftmarginvi {1em}
\fi
\setlength \labelsep {.5em}
\setlength \labelwidth{\leftmargini}
\addtolength\labelwidth{-\labelsep}
\@beginparpenalty -\@lowpenalty
\@endparpenalty -\@lowpenalty
\@itempenalty -\@lowpenalty
\renewcommand\theenumi{\@arabic\c@enumi}
\renewcommand\theenumii{\@alph\c@enumii}
\renewcommand\theenumiii{\@roman\c@enumiii}
\renewcommand\theenumiv{\@Alph\c@enumiv}
\newcommand\labelenumi{\theenumi.}
\newcommand\labelenumii{(\theenumii)}
\newcommand\labelenumiii{\theenumiii.}
\newcommand\labelenumiv{\theenumiv.}
\renewcommand\p@enumii{\theenumi}
\renewcommand\p@enumiii{\theenumi(\theenumii)}
\renewcommand\p@enumiv{\p@enumiii\theenumiii}
\newcommand\labelitemi{\textbullet}
\newcommand\labelitemii{\normalfont\bfseries \textendash}
\newcommand\labelitemiii{\textasteriskcentered}
\newcommand\labelitemiv{\textperiodcentered}
\newenvironment{description}
{\list{}{\labelwidth\z@ \itemindent-\leftmargin
\let\makelabel\descriptionlabel}}
{\endlist}
\newcommand*\descriptionlabel[1]{\hspace\labelsep
\normalfont\bfseries #1}
\newenvironment{verse}
{\let\\\@centercr
\list{}{\itemsep \z@
\itemindent -1.5em%
\listparindent\itemindent
\rightmargin \leftmargin
\advance\leftmargin 1.5em}%
\item\relax}
{\endlist}
\newenvironment{quotation}
{\list{}{\listparindent 1.5em%
\itemindent \listparindent
\rightmargin \leftmargin
\parsep \z@ \@plus\p@}%
\item\relax}
{\endlist}
\newenvironment{quote}
{\list{}{\rightmargin\leftmargin}%
\item\relax}
{\endlist}
\if@compatibility
\newenvironment{titlepage}
{%
\cleardoublepage
\if@twocolumn
\@restonecoltrue\onecolumn
\else
\@restonecolfalse\newpage
\fi
\thispagestyle{empty}%
\setcounter{page}\z@
}%
{\if@restonecol\twocolumn \else \newpage \fi
}
\else
\newenvironment{titlepage}
{%
\cleardoublepage
\if@twocolumn
\@restonecoltrue\onecolumn
\else
\@restonecolfalse\newpage
\fi
\thispagestyle{empty}%
\setcounter{page}\@ne
}%
{\if@restonecol\twocolumn \else \newpage \fi
\if@twoside\else
\setcounter{page}\@ne
\fi
}
\fi
\newcommand\appendix{\par
\setcounter{chapter}{0}%
\setcounter{section}{0}%
\gdef\@chapapp{\appendixname}%
\gdef\thechapter{\@Alph\c@chapter}}
\setlength\arraycolsep{5\p@}
\setlength\tabcolsep{6\p@}
\setlength\arrayrulewidth{.4\p@}
\setlength\doublerulesep{2\p@}
\setlength\tabbingsep{\labelsep}
\skip\@mpfootins = \skip\footins
\setlength\fboxsep{3\p@}
\setlength\fboxrule{.4\p@}
\@addtoreset {equation}{chapter}
\renewcommand\theequation
{\ifnum \c@chapter>\z@ \thechapter.\fi \@arabic\c@equation}
\newcounter{figure}[chapter]
\renewcommand \thefigure
{\ifnum \c@chapter>\z@ \thechapter.\fi \@arabic\c@figure}
\def\fps@figure{tbp}
\def\ftype@figure{1}
\def\ext@figure{lof}
\def\fnum@figure{\figurename\nobreakspace\thefigure}
\newenvironment{figure}
{\@float{figure}}
{\end@float}
\newenvironment{figure*}
{\@dblfloat{figure}}
{\end@dblfloat}
\newcounter{table}[chapter]
\renewcommand \thetable
{\ifnum \c@chapter>\z@ \thechapter.\fi \@arabic\c@table}
\def\fps@table{tbp}
\def\ftype@table{2}
\def\ext@table{lot}
\def\fnum@table{\tablename\nobreakspace\thetable}
\newenvironment{table}
{\@float{table}}
{\end@float}
\newenvironment{table*}
{\@dblfloat{table}}
{\end@dblfloat}
\newlength\abovecaptionskip
\newlength\belowcaptionskip
\setlength\abovecaptionskip{10\p@}
\setlength\belowcaptionskip{0\p@}
\long\def\@makecaption#1#2{%
\vskip\abovecaptionskip
\sbox\@tempboxa{#1: #2}%
\ifdim \wd\@tempboxa >\hsize
#1: #2\par
\else
\global \@minipagefalse
\hb@xt@\hsize{\hfil\box\@tempboxa\hfil}%
\fi
\vskip\belowcaptionskip}
\DeclareOldFontCommand{\rm}{\normalfont\rmfamily}{\mathrm}
\DeclareOldFontCommand{\sf}{\normalfont\sffamily}{\mathsf}
\DeclareOldFontCommand{\tt}{\normalfont\ttfamily}{\mathtt}
\DeclareOldFontCommand{\bf}{\normalfont\bfseries}{\mathbf}
\DeclareOldFontCommand{\it}{\normalfont\itshape}{\mathit}
\DeclareOldFontCommand{\sl}{\normalfont\slshape}{\@nomath\sl}
\DeclareOldFontCommand{\sc}{\normalfont\scshape}{\@nomath\sc}
\DeclareRobustCommand*\cal{\@fontswitch\relax\mathcal}
\DeclareRobustCommand*\mit{\@fontswitch\relax\mathnormal}
\newcommand\@pnumwidth{1.55em}
\newcommand\@tocrmarg{2.55em}
\newcommand\@dotsep{4.5}
\setcounter{tocdepth}{2}
\newcommand\tableofcontents{%
\if@twocolumn
\@restonecoltrue\onecolumn
\else
\@restonecolfalse
\fi
\chapter*{\contentsname
\@mkboth{%
\MakeUppercase\contentsname}{\MakeUppercase\contentsname}}%
\@starttoc{toc}%
\if@restonecol\twocolumn\fi
}
\newcommand*\l@part[2]{%
\ifnum \c@tocdepth >-2\relax
\addpenalty{-\@highpenalty}%
\addvspace{2.25em \@plus\p@}%
\setlength\@tempdima{3em}%
\begingroup
\parindent \z@ \rightskip \@pnumwidth
\parfillskip -\@pnumwidth
{\leavevmode
\large \bfseries #1\hfil \hb@xt@\@pnumwidth{\hss #2}}\par
\nobreak
\global\@nobreaktrue
\everypar{\global\@nobreakfalse\everypar{}}%
\endgroup
\fi}
%%%%\newcommand*\l@chapter[2]{%
%%%% \ifnum \c@tocdepth >\m@ne
%%%% \addpenalty{-\@highpenalty}%
%%%% \vskip 1.0em \@plus\p@
%%%% \setlength\@tempdima{1.5em}%
%%%% \begingroup
%%%% \parindent \z@ \rightskip \@pnumwidth
%%%% \parfillskip -\@pnumwidth
%%%% \leavevmode \bfseries
%%%% \advance\leftskip\@tempdima
%%%% \hskip -\leftskip
%%%% #1\nobreak\hfil \nobreak\hb@xt@\@pnumwidth{\hss #2}\par
%%%% \penalty\@highpenalty
%%%% \endgroup
%%%% \fi}
\newcommand\l@chapter[2]{%
\ifnum \c@tocdepth >\m@ne
\addpenalty{-\@highpenalty}%
\vskip 1.0em \@plus\p@
\setlength\@tempdima{1.5em}%
\begingroup
\parindent \z@ \rightskip \@pnumwidth
\parfillskip -\@pnumwidth
\leavevmode \fontchapter
\advance\leftskip\@tempdima
\hskip -\leftskip
#1\nobreak\hfil \nobreak\hb@xt@\@pnumwidth{\hss #2}\par
\penalty\@highpenalty
\endgroup
\fi}
\newcommand*\l@section{\@dottedtocline{1}{1.5em}{2.3em}}
\newcommand*\l@subsection{\@dottedtocline{2}{3.8em}{3.2em}}
\newcommand*\l@subsubsection{\@dottedtocline{3}{7.0em}{4.1em}}
\newcommand*\l@paragraph{\@dottedtocline{4}{10em}{5em}}
\newcommand*\l@subparagraph{\@dottedtocline{5}{12em}{6em}}
\newcommand\listoffigures{%
\if@twocolumn
\@restonecoltrue\onecolumn
\else
\@restonecolfalse
\fi
\chapter*{\listfigurename}%
\@mkboth{\MakeUppercase\listfigurename}%
{\MakeUppercase\listfigurename}%
\@starttoc{lof}%
\if@restonecol\twocolumn\fi
}
\newcommand*\l@figure{\@dottedtocline{1}{1.5em}{2.3em}}
\newcommand\listoftables{%
\if@twocolumn
\@restonecoltrue\onecolumn
\else
\@restonecolfalse
\fi
\chapter*{\listtablename}%
\@mkboth{%
\MakeUppercase\listtablename}%
{\MakeUppercase\listtablename}%
\@starttoc{lot}%
\if@restonecol\twocolumn\fi
}
\let\l@table\l@figure
\newdimen\bibindent
\setlength\bibindent{1.5em}
\newenvironment{thebibliography}[1]
{\chapter*{\bibname}%
\@mkboth{\MakeUppercase\bibname}{\MakeUppercase\bibname}%
\list{\@biblabel{\@arabic\c@enumiv}}%
{\settowidth\labelwidth{\@biblabel{#1}}%
\leftmargin\labelwidth
\advance\leftmargin\labelsep
\@openbib@code
\usecounter{enumiv}%
\let\p@enumiv\@empty
\renewcommand\theenumiv{\@arabic\c@enumiv}}%
\sloppy
\clubpenalty4000
\@clubpenalty \clubpenalty
\widowpenalty4000%
\sfcode`\.\@m}
{\def\@noitemerr
{\@latex@warning{Empty `thebibliography' environment}}%
\endlist}
\newcommand\newblock{\hskip .11em\@plus.33em\@minus.07em}
\let\@openbib@code\@empty
\newenvironment{theindex}
{\if@twocolumn
\@restonecolfalse
\else
\@restonecoltrue
\fi
\columnseprule \z@
\columnsep 35\p@
\twocolumn[\@makeschapterhead{\indexname}]%
\@mkboth{\MakeUppercase\indexname}%
{\MakeUppercase\indexname}%
\thispagestyle{plain}\parindent\z@
\parskip\z@ \@plus .3\p@\relax
\let\item\@idxitem}
{\if@restonecol\onecolumn\else\clearpage\fi}
\newcommand\@idxitem{\par\hangindent 40\p@}
\newcommand\subitem{\@idxitem \hspace*{20\p@}}
\newcommand\subsubitem{\@idxitem \hspace*{30\p@}}
\newcommand\indexspace{\par \vskip 10\p@ \@plus5\p@ \@minus3\p@\relax}
\renewcommand\footnoterule{%
\kern-3\p@
\hrule\@width.4\columnwidth
\kern2.6\p@}
\@addtoreset{footnote}{chapter}
\newcommand\@makefntext[1]{%
\parindent 1em%
\noindent
\hb@xt@1.8em{\hss\@makefnmark}#1}
\newcommand\contentsname{Contents}
\newcommand\listfigurename{List of Figures}
\newcommand\listtablename{List of Tables}
\newcommand\bibname{Bibliography}
\newcommand\indexname{Index}
\newcommand\figurename{Figure}
\newcommand\tablename{Table}
\newcommand\partname{Part}
\newcommand\chaptername{Chapter}
\newcommand\appendixname{Appendix}
\def\today{\ifcase\month\or
January\or February\or March\or April\or May\or June\or
July\or August\or September\or October\or November\or December\fi
\space\number\day, \number\year}
\setlength\columnsep{10\p@}
\setlength\columnseprule{0\p@}
\pagestyle{headings}
\pagenumbering{arabic}
\if@twoside
\else
\raggedbottom
\fi
\if@twocolumn
\twocolumn
\sloppy
\flushbottom
\else
\onecolumn
\fi
\endinput
%%
%% End of file `book.cls'.

219
hurricane/doc/hurricane/customHierarchy.html Normal file
View File

@ -0,0 +1,219 @@
<!DOCTYPE HTML PUBLIC '-//W3C//DTD HTML 4.0//EN'>
<!-- $Id: customHierarchy.html,v 1.1 2007/08/22 16:35:53 jpc Exp $ -->
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1">
<title>Hurricane Documentation</title>
<link href="ASIM.css" rel="stylesheet" type="text/css">
</head>
<h1 id="pagetop" class="header">Hurricane Documentation</h1>
<center class="header">
<table class="header">
<tr>
<td><a href="customSummary.html">Summary</a></td>
<td><a href="namespaces.html">Namespaces</a></td>
<td><a href="customHierarchy.html">Class Hierarchy</a></td>
<td><a href="annotated.html">Classes</a></td>
<td><a href="functions.html">Member Index</a></td>
<!-- <td><a href="classes.html">Index2</a></td> -->
</tr>
</table>
</center>
<br>
<hr>
<body>
<h1>Hurricane Synthetic Class Hierarchy</h1>
<br>
<p><b>The complete class hierarchy could be accessed <a href="hierarchy.html">here</a>.</b></p>
<p>All the classes below are in the <a href="namespaceHurricane.html">Hurricane</a> namespace.</p>
<p>The inheritance tree has been splitted/simplificated.</p>
<b>Legend :</b><br>
<pre class="fragment">
<table class="classHierarchy">
<tr><td width="70"></td><td class="virtual"><a href="#pagetop">ClassA</a></td><td><b>&nbsp;&nbsp;<tt>ClassA</tt> is abstract</b></td></tr>
<tr><td width="70"></td><td class="normal"><a href="#pagetop">ClassB</a></td><td><b>&nbsp;&nbsp;<tt>ClassB</tt> is instanciable</b></td></tr>
</table>
</pre>
<br>
<h2 class="classHierarchy">Exceptions</h2>
<table class="classHierarchy">
<tr><td width="70"></td><td class="virtual"><a href="classHurricane_1_1Exception.html">Exception</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="140"></td><td class="normal"><a href="classHurricane_1_1Error.html">Error</a></td></tr>
<tr><td width="140"></td><td class="normal"><a href="classHurricane_1_1Warning.html">Warning</a></td></tr>
<tr><td width="140"></td><td class="normal"><a href="classHurricane_1_1Interruption.html">Interruption</a></td></tr>
</table>
<h2 class="classHierarchy">Collections</h2>
<table class="classHierarchy">
<tr><td width="70"></td><td class="wvirtual"><a href="classHurricane_1_1Collection.html">Collection&lt;&nbsp;Type&nbsp;&gt;</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="140"></td><td class="wnormal"><a href="classHurricane_1_1GenericCollection.html">GenericCollection&lt;&nbsp;Type&nbsp;&gt;</a></td></tr>
<tr><td width="140"></td><td class="wnormal"><a href="classHurricane_1_1SubSetCollection.html">SubSetCollection&lt;&nbsp;Type&nbsp;&gt;</a></td></tr>
<tr><td width="140"></td><td class="wnormal"><a href="classHurricane_1_1SubTypeCollection.html">SubTypeCollection&lt;&nbsp;SuperType, Type&nbsp;&gt;</a></td></tr>
<tr><td width="140"></td><td class="wnormal"><a href="classHurricane_1_1ListCollection.html">ListCollection&lt;&nbsp;Type&nbsp;&gt;</a></td></tr>
<tr><td width="140"></td><td class="wnormal"><a href="classHurricane_1_1VectorCollection.html">VectorCollection&lt;&nbsp;Type&nbsp;&gt;</a></td></tr>
<tr><td width="140"></td><td class="wnormal"><a href="classHurricane_1_1MapCollection.html">MapCollection&lt;&nbsp;Type&nbsp;&gt;</a></td></tr>
<tr><td width="140"></td><td class="wnormal"><a href="classHurricane_1_1SetCollection.html">SetCollection&lt;&nbsp;Type&nbsp;&gt;</a></td></tr>
</table>
<h2 class="classHierarchy">Locators</h2>
<table class="classHierarchy">
<tr><td width="70"></td><td class="virtual"><a href="classHurricane_1_1Locator.html">Locator&lt;&nbsp;Type&nbsp;&gt;</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="140"></td><td class="normal"><a href="classHurricane_1_1GenericLocator.html">GenericLocator&lt;&nbsp;Type&nbsp;&gt;</a></td></tr>
</table>
<h2 class="classHierarchy">Filters</h2>
<table class="classHierarchy">
<tr><td width="70"></td><td class="virtual"><a href="classHurricane_1_1Filter.html">Filter&lt;&nbsp;Type&nbsp;&gt;</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="140"></td><td class="normal"><a href="classHurricane_1_1GenericFilter.html">GenericFilter&lt;&nbsp;Type&nbsp;&gt;</a></td></tr>
<tr><td width="140"></td><td class="normal"><a href="classHurricane_1_1NotFilter.html">NotFilter&lt;&nbsp;Type&nbsp;&gt;</a></td></tr>
</table>
<h2 class="classHierarchy">Common Objects</h2>
<table class="classHierarchy">
<tr><td width="70"></td><td class="normal"><a href="classHurricane_1_1Tabulation.html">Tabulation</a></td></tr>
<tr><td width="70"></td><td class="normal"><a href="group__Unit.html">Unit</a></td></tr>
<tr><td width="70"></td><td class="normal"><a href="classHurricane_1_1Point.html">Point</a></td></tr>
<tr><td width="70"></td><td class="normal"><a href="classHurricane_1_1Box.html">Box</a></td></tr>
<tr><td width="70"></td><td class="normal"><a href="classHurricane_1_1Interval.html">Interval</a></td></tr>
<tr><td width="70"></td><td class="normal"><a href="classHurricane_1_1Transformation.html">Transformation</a></td></tr>
<tr><td width="70"></td><td class="normal"><a href="classHurricane_1_1Name.html">Name</a></td></tr>
</table>
<h2 class="classHierarchy">Data Base Objects</h2>
<table class="classHierarchy">
<tr><td width="70"></td><td class="virtual"><a href="classHurricane_1_1DBo.html">DBo</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="140"></td><td class="normal"><a href="classHurricane_1_1DataBase.html">DataBase</a></td></tr>
<tr><td width="140"></td><td class="normal"><a href="classHurricane_1_1Technology.html">Technology</a></td></tr>
<tr><td width="140"></td><td class="virtual"><a href="classHurricane_1_1Layer.html">Layer</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="210"></td><td class="normal"><a href="classHurricane_1_1BasicLayer.html">BasicLayer</a></td></tr>
<tr><td width="210"></td><td class="normal"><a href="classHurricane_1_1CompositeLayer.html">CompositeLayer</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="140"></td><td class="normal"><a href="classHurricane_1_1Library.html">Library</a></td></tr>
<tr><td width="140"></td><td class="normal"><a href="classHurricane_1_1Symbol.html">Symbol</a></td></tr>
<tr><td width="140"></td><td class="virtual"><a href="classHurricane_1_1Entity.html">Entity</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="210"></td><td class="normal"><a href="classHurricane_1_1Cell.html">Cell</a></td></tr>
<tr><td width="210"></td><td class="normal"><a href="classHurricane_1_1Net.html">Net</a></td></tr>
<tr><td width="210"></td><td class="virtual"><a href="classHurricane_1_1Go.html">Go</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="280"></td><td class="normal"><a href="classHurricane_1_1Instance.html">Instance</a></td></tr>
<tr><td width="280"></td><td class="virtual"><a href="classHurricane_1_1Component.html">Component</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="350"></td><td class="normal"><a href="classHurricane_1_1Plug.html">Plug</a></td></tr>
<tr><td width="350"></td><td class="normal"><a href="classHurricane_1_1Contact.html">Contact</a></td></tr>
<tr><td width="350"></td><td class="virtual"><a href="classHurricane_1_1Segment.html">Segment</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="420"></td><td class="normal"><a href="classHurricane_1_1Vertical.html">Vertical</a></td></tr>
<tr><td width="420"></td><td class="normal"><a href="classHurricane_1_1Horizontal.html">Horizontal</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="350"></td><td class="normal"><a href="classHurricane_1_1Pad.html">Pad</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="280"></td><td class="normal"><a href="classHurricane_1_1Rubber.html">Rubber</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="140"></td><td class="normal"><a href="classHurricane_1_1Quark.html">Quark</a></td></tr>
<tr><td width="140"></td><td class="virtual"><a href="classHurricane_1_1View.html">View</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="210"></td><td class="virtual"><a href="classHurricane_1_1MainView.html">MainView</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="280"></td><td class="normal"><a href="classHurricane_1_1Editor.html">Editor</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="210"></td><td class="normal"><a href="classHurricane_1_1MapView.html">MapView</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="140"></td><td class="virtual"><a href="classHurricane_1_1Command.html">Command</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="210"></td><td class="normal"><a href="classHurricane_1_1ZoomCommand.html">ZoomCommand</a></td></tr>
<tr><td width="210"></td><td class="normal"><a href="classHurricane_1_1SelectCommand.html">SelectCommand</a></td></tr>
<tr><td width="210"></td><td class="normal"><a href="classHurricane_1_1SelectNetCommand.html">SelectNetCommand</a></td></tr>
</table>
<h2 class="classHierarchy">Properties</h2>
<table class="classHierarchy">
<tr><td width="70"></td><td class="wvirtual"><a href="classHurricane_1_1Property.html">Property</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="140"></td><td class="wvirtual"><a href="classHurricane_1_1PrivateProperty.html">PrivateProperty</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="210"></td><td class="wnormal"><a href="classHurricane_1_1StandardPrivateProperty.html">StandardPrivateProperty&lt;&nbsp;Value&nbsp;&gt;</a></td></tr>
<tr><td width="210"></td><td class="wnormal"><a href="classHurricane_1_1Selector.html">Selector</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="140"></td><td class="wvirtual"><a href="classHurricane_1_1SharedProperty.html">SharedProperty</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="210"></td><td class="wnormal"><a href="classHurricane_1_1StandardSharedProperty.html">StandardSharedProperty&lt;&nbsp;Value&nbsp;&gt;</a></td></tr>
<tr><td width="210"></td><td class="wvirtual"><a href="classHurricane_1_1Relation.html">Relation</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="280"></td><td class="wnormal"><a href="classHurricane_1_1StandardRelation.html">StandardRelation</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="210"></td><td class="wnormal"><a href="classHurricane_1_1UpdateSession.html">UpdateSession</a></td></tr>
</table>
<h2 class="classHierarchy">Hooks</h2>
<table class="classHierarchy">
<tr><td width="70"></td><td class="virtual"><a href="classHurricane_1_1Hook.html">Hook</a></td></tr>
</table>
<table class="classHierarchy">
<tr><td width="140"></td><td class="normal"><a href="classHurricane_1_1Component_1_1BodyHook.html">Component::BodyHook</a></td></tr>
<tr><td width="140"></td><td class="normal"><a href="classHurricane_1_1Contact_1_1AnchorHook.html">Component::AnchorHook</a></td></tr>
<tr><td width="140"></td><td class="normal"><a href="classHurricane_1_1Segment_1_1SourceHook.html">Component::SourceHook</a></td></tr>
<tr><td width="140"></td><td class="normal"><a href="classHurricane_1_1Segment_1_1TargetHook.html">Component::TargetHook</a></td></tr>
</table>
<h2 class="classHierarchy">Pathes and Occurrences</h2>
<table class="classHierarchy">
<tr><td width="70"></td><td class="normal"><a href="classHurricane_1_1Path.html">Path</a></td></tr>
<tr><td width="70"></td><td class="normal"><a href="classHurricane_1_1Occurrence.html">Occurrence</a></td></tr>
</table>
<h2 class="classHierarchy">Fast Access Structures</h2>
<table class="classHierarchy">
<tr><td width="70"></td><td class="normal"><a href="classHurricane_1_1QuadTree.html">Component::QuadTree</a></td></tr>
<tr><td width="70"></td><td class="normal"><a href="classHurricane_1_1Slice.html">Component::Slice</a></td></tr>
</table>
<hr>
<table class="footer1">
<tr>
<td class="LFooter"><small>Customized Class Hierarchy</small></td>
<td class="RFooter"><a href='#pagetop'><small>Return to top of page</small></a></td>
</tr>
</table>
<table class="footer2">
<tr>
<td class="LFooter">Hurricane Documentation</td>
<td class="RFooter"><small>Copyright &#169; 2000-2007 Bull S.A. All rights reserved</small></td>
</tr>
</table>
</body>
</html>

65
hurricane/doc/hurricane/customSummary.html Normal file
View File

@ -0,0 +1,65 @@
<!DOCTYPE HTML PUBLIC '-//W3C//DTD HTML 4.0//EN'>
<!-- $Id: customSummary.html,v 1.1 2007/08/22 16:35:53 jpc Exp $ -->
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1">
<title>Hurricane Documentation</title>
<link href="ASIM.css" rel="stylesheet" type="text/css">
</head>
<h1 class="header">Hurricane Documentation</h1>
<center class="header">
<table class="header">
<tr>
<td><a href="customSummary.html">Summary</a></td>
<td><a href="namespaces.html">Namespaces</a></td>
<td><a href="customHierarchy.html">Class Hierarchy</a></td>
<td><a href="annotated.html">Classes</a></td>
<td><a href="functions.html">Member Index</a></td>
<!-- <td><a href="classes.html">Index2</a></td> -->
</tr>
</table>
</center>
<br>
<hr>
<body>
<h1>Hurricane Concepts</h1>
<br>
<p><b>The classical Doxygen class hierarchy could be accessed <a href="modules.html">here</a>.</b></p>
<h2>API documentations</h2>
<ul>
<li><b><a href="group__Generalities.html">Generalities</a></b><br>
Naming conventions, Utilitarians, Generic Functions.
<li><b><a href="group__Unit.html">Unit</a></b><br>
Object/Type used to model all coordinates in <a href="namespaceHurricane.html">Hurricane</a>.
<li><b><a href="customHierarchy.html">Synthetic Class Hierarchy.</a></b>
<li><b><a href="hierarchy.html">Complete Class Hierarchy (doxygen).</a></b>
<li><b><a href="annotated.html">Class List (doxygen).</a></b>
<li><b><a href="classes.html">Class Index (doxygen).</a></b>
<li><b><a href="modules.html">Modules (raw concepts).</a></b>
<li><b><a href="functions.html">Member Functions Index (doxygen).</a></b>
<li><b><a href="namespaces.html">Namespaces (doxygen).</a></b>
</ul>
<h2>Extending Hurricane (internal)</h2>
<ul>
<li><b><a href="group__inspectorManagment.html">Inspector Managment</a></b><br>
How to extend the run-time database inspector.
</ul>
<hr>
<table class="footer1">
<tr>
<td class="LFooter"><small>Customized Concepts (a.k.a. modules)</small></td>
<td class="RFooter"><a href='#pagetop'><small>Return to top of page</small></a></td>
</tr>
</table>
<table class="footer2">
<tr>
<td class="LFooter">Hurricane Documentation</td>
<td class="RFooter"><small>Copyright &#169; 2000-2007 Bull S.A. All rights reserved</small></td>
</tr>
</table>
</body>
</html>

331
hurricane/doc/hurricane/doxyfile Normal file
View File

@ -0,0 +1,331 @@
# Doxyfile 1.3.4
# --------------------------------------------------------------------
# Project related configuration options
PROJECT_NAME = "Hurricane"
PROJECT_NUMBER = 2.3
OUTPUT_DIRECTORY = en/hurricane
OUTPUT_LANGUAGE = English
USE_WINDOWS_ENCODING = NO
BRIEF_MEMBER_DESC = YES
REPEAT_BRIEF = YES
ALWAYS_DETAILED_SEC = NO
INLINE_INHERITED_MEMB = NO
FULL_PATH_NAMES = NO
STRIP_FROM_PATH =
SHORT_NAMES = NO
JAVADOC_AUTOBRIEF = NO
MULTILINE_CPP_IS_BRIEF = NO
DETAILS_AT_TOP = YES
INHERIT_DOCS = NO
DISTRIBUTE_GROUP_DOC = NO
TAB_SIZE = 2
ALIASES = "function=\fn"\
"important=\par Important:\n"\
"caution=\par Caution:\n"\
"remark=\par Remark:\n"\
"sample=\par Sample:\n"\
"Return=<b>Returns:</b>"\
"unsigned=\c unsigned"\
"POD=\c POD"\
"True=\b True"\
"true=\b true"\
"False=\b False"\
"false=\b false"\
"public=\c public"\
"protected=\c protected"\
"private=\c private"\
"static=\c static"\
"virtual=\c virtual"\
"this=\c this"\
"VERTICAL=\b VERTICAL"\
"HORIZONTAL=\b HORIZONTAL"\
"NULL=\c NULL"\
"stream=\c stream"\
"iostream=\c iostream"\
"stdin=\c stdin"\
"stdout=\c stdout"\
"stderr=\c stderr"\
"string=\c string"\
"vector=\c vector"\
"list=\c list"\
"map=\c map"\
"set=\c set"\
"STL=<a href='http://www.sgi.com/tech/stl/'>STL</a>"
OPTIMIZE_OUTPUT_FOR_C = NO
OPTIMIZE_OUTPUT_JAVA = NO
SUBGROUPING = YES
# --------------------------------------------------------------------
# Build related configuration options
EXTRACT_ALL = NO
EXTRACT_PRIVATE = YES
EXTRACT_STATIC = YES
EXTRACT_LOCAL_CLASSES = YES
HIDE_UNDOC_MEMBERS = YES
HIDE_UNDOC_CLASSES = YES
HIDE_FRIEND_COMPOUNDS = NO
HIDE_IN_BODY_DOCS = NO
INTERNAL_DOCS = NO
CASE_SENSE_NAMES = YES
HIDE_SCOPE_NAMES = NO
SHOW_INCLUDE_FILES = YES
INLINE_INFO = YES
SORT_MEMBER_DOCS = NO
GENERATE_TODOLIST = YES
GENERATE_TESTLIST = YES
GENERATE_BUGLIST = YES
GENERATE_DEPRECATEDLIST= YES
ENABLED_SECTIONS =
MAX_INITIALIZER_LINES = 1
SHOW_USED_FILES = YES
# --------------------------------------------------------------------
# Configuration options related to warning and progress messages
QUIET = YES
WARNINGS = YES
WARN_IF_UNDOCUMENTED = NO
WARN_IF_DOC_ERROR = YES
WARN_FORMAT = "$file:$line: $text"
WARN_LOGFILE =
# --------------------------------------------------------------------
# Configuration options related to the input files
# ../../src/hurricane/Commands.h ../../src/hurricane/Command.h Command.dox \
# ../../src/hurricane/MainViews.h ../../src/hurricane/MainView.h MainView.dox \
# ../../src/hurricane/MapView.h MapView.dox \
# ../../src/hurricane/Primitives.h ../../src/hurricane/Primitive.h Primitive.dox \
INPUT = \
../../src/hurricane/Hurricane.h Hurricane.dox \
../../src/hurricane/SlotAdapter.h SlotAdapter.dox \
../../src/hurricane/Commons.h Commons.dox \
../../src/hurricane/DataBase.h DataBase.dox \
../../src/hurricane/Technology.h Technology.dox \
../../src/hurricane/DBos.h ../../src/hurricane/DBo.h DBo.dox \
../../src/hurricane/Entities.h ../../src/hurricane/Entity.h Entity.dox \
../../src/hurricane/Cells.h ../../src/hurricane/Cell.h Cell.dox \
../../src/hurricane/BasicLayers.h ../../src/hurricane/BasicLayer.h BasicLayer.dox \
../../src/hurricane/Boxes.h ../../src/hurricane/Box.h Box.dox \
../../src/hurricane/Collection.h Collection.dox \
SelectCommand.dox \
SelectNetCommand.dox \
ZoomCommand.dox \
../../src/hurricane/Components.h ../../src/hurricane/Component.h Component.dox \
../../src/hurricane/CompositeLayers.h ../../src/hurricane/CompositeLayer.h CompositeLayer.dox \
../../src/hurricane/Contacts.h ../../src/hurricane/Contact.h Contact.dox \
../../src/hurricane/Error.h Error.dox \
../../src/hurricane/Exception.h Exception.dox \
../../src/hurricane/Filter.h Filter.dox \
NotFilter.dox \
Generalities.dox \
../../src/hurricane/Collection.h GenericCollection.dox \
../../src/hurricane/Filter.h GenericFilter.dox \
../../src/hurricane/Locator.h GenericLocator.dox \
../../src/hurricane/Gos.h ../../src/hurricane/Go.h Go.dox \
../../src/hurricane/Hooks.h ../../src/hurricane/Hook.h Hook.dox \
../../src/hurricane/Horizontals.h ../../src/hurricane/Horizontal.h Horizontal.dox \
../../src/hurricane/Instances.h ../../src/hurricane/Instance.h Instance.dox \
../../src/hurricane/Interruption.h Interruption.dox \
../../src/hurricane/Intervals.h ../../src/hurricane/Interval.h Interval.dox \
../../src/hurricane/Layers.h ../../src/hurricane/Layer.h Layer.dox \
../../src/hurricane/Libraries.h ../../src/hurricane/Library.h Library.dox \
../../src/hurricane/ListCollection.h ListCollection.dox \
../../src/hurricane/Locator.h Locator.dox \
../../src/hurricane/MapCollection.h MapCollection.dox \
../../src/hurricane/Names.h ../../src/hurricane/Name.h Name.dox \
../../src/hurricane/Nets.h ../../src/hurricane/Net.h Net.dox \
../../src/hurricane/Occurrences.h ../../src/hurricane/Occurrence.h Occurrence.dox \
../../src/hurricane/Pads.h ../../src/hurricane/Pad.h Pad.dox \
../../src/hurricane/Pathes.h ../../src/hurricane/Path.h Path.dox \
../../src/hurricane/Pins.h ../../src/hurricane/Pin.h Pin.dox \
../../src/hurricane/Plugs.h ../../src/hurricane/Plug.h Plug.dox \
../../src/hurricane/Points.h ../../src/hurricane/Point.h Point.dox \
../../src/hurricane/Properties.h ../../src/hurricane/Property.h Property.dox \
PrivateProperty.dox \
SharedProperty.dox \
StandardPrivateProperty.dox \
StandardSharedProperty.dox \
../../src/hurricane/QuadTree.h QuadTree.dox \
../../src/hurricane/Quarks.h ../../src/hurricane/Quark.h Quark.dox \
../../src/hurricane/Relation.h Relation.dox \
StandardRelation.dox \
../../src/hurricane/Rubbers.h ../../src/hurricane/Rubber.h Rubber.dox \
../../src/hurricane/Segments.h ../../src/hurricane/Segment.h Segment.dox \
../../src/hurricane/Selectors.h ../../src/hurricane/Selector.h Selector.dox \
../../src/hurricane/SetCollection.h SetCollection.dox \
SubSetCollection.dox \
SubTypeCollection.dox \
../../src/hurricane/Slices.h ../../src/hurricane/Slice.h Slice.dox \
../../src/hurricane/Symbols.h ../../src/hurricane/Symbol.h Symbol.dox \
../../src/hurricane/Tabulation.h Tabulation.dox \
../../src/hurricane/Transformation.h Transformation.dox \
../../src/hurricane/Unit.h Unit.dox \
../../src/hurricane/UpdateSession.h UpdateSession.dox \
../../src/hurricane/VectorCollection.h VectorCollection.dox \
../../src/hurricane/Verticals.h ../../src/hurricane/Vertical.h Vertical.dox \
../../src/hurricane/Views.h ../../src/hurricane/View.h View.dox \
../../src/hurricane/Warning.h Warning.dox
FILE_PATTERNS = *.h \
*.cpp \
*.dox
RECURSIVE = YES
EXCLUDE =
EXCLUDE_SYMLINKS = NO
EXCLUDE_PATTERNS =
EXAMPLE_PATH =
EXAMPLE_PATTERNS =
EXAMPLE_RECURSIVE = NO
IMAGE_PATH = images
INPUT_FILTER =
FILTER_SOURCE_FILES = YES
# --------------------------------------------------------------------
# Configuration options related to source browsing
SOURCE_BROWSER = NO
INLINE_SOURCES = NO
STRIP_CODE_COMMENTS = YES
REFERENCED_BY_RELATION = YES
REFERENCES_RELATION = YES
VERBATIM_HEADERS = YES
# --------------------------------------------------------------------
# Configuration options related to the alphabetical class index
ALPHABETICAL_INDEX = YES
COLS_IN_ALPHA_INDEX = 2
IGNORE_PREFIX =
# --------------------------------------------------------------------
# Configuration options related to the HTML output
GENERATE_HTML = YES
HTML_OUTPUT = html
HTML_FILE_EXTENSION = .html
HTML_HEADER = header.html
HTML_FOOTER = footer.html
HTML_STYLESHEET = ASIM.css
HTML_ALIGN_MEMBERS = YES
GENERATE_HTMLHELP = NO
CHM_FILE =
HHC_LOCATION =
GENERATE_CHI = NO
BINARY_TOC = NO
TOC_EXPAND = NO
DISABLE_INDEX = YES
ENUM_VALUES_PER_LINE = 1
GENERATE_TREEVIEW = NO
TREEVIEW_WIDTH = 250
# --------------------------------------------------------------------
# Configuration options related to the LaTeX output
GENERATE_LATEX = YES
LATEX_OUTPUT = latex
LATEX_CMD_NAME = latex
MAKEINDEX_CMD_NAME = makeindex
COMPACT_LATEX = NO
PAPER_TYPE = a4wide
EXTRA_PACKAGES =
LATEX_HEADER = header.tex
PDF_HYPERLINKS = YES
USE_PDFLATEX = YES
LATEX_BATCHMODE = NO
LATEX_HIDE_INDICES = NO
# --------------------------------------------------------------------
# Configuration options related to the RTF output
GENERATE_RTF = NO
RTF_OUTPUT = rtf
COMPACT_RTF = NO
RTF_HYPERLINKS = NO
RTF_STYLESHEET_FILE =
RTF_EXTENSIONS_FILE =
# --------------------------------------------------------------------
# Configuration options related to the man page output
GENERATE_MAN = YES
MAN_OUTPUT = man
MAN_EXTENSION = .3
MAN_LINKS = NO
# --------------------------------------------------------------------
# Configuration options related to the XML output
GENERATE_XML = NO
XML_OUTPUT = xml
XML_SCHEMA =
XML_DTD =
# --------------------------------------------------------------------
# Configuration options for the AutoGen Definitions output
GENERATE_AUTOGEN_DEF = NO
# --------------------------------------------------------------------
# Configuration options related to the Perl module output
GENERATE_PERLMOD = NO
PERLMOD_LATEX = NO
PERLMOD_PRETTY = YES
PERLMOD_MAKEVAR_PREFIX =
# --------------------------------------------------------------------
# Configuration options related to the preprocessor
ENABLE_PREPROCESSING = YES
MACRO_EXPANSION = NO
EXPAND_ONLY_PREDEF = NO
SEARCH_INCLUDES = YES
INCLUDE_PATH =
INCLUDE_FILE_PATTERNS =
PREDEFINED = __DOXYGEN_PROCESSOR__
EXPAND_AS_DEFINED =
SKIP_FUNCTION_MACROS = YES
# --------------------------------------------------------------------
# Configuration::addtions related to external references
TAGFILES =
GENERATE_TAGFILE = en/hurricane/html/hurricane.tag
ALLEXTERNALS = NO
EXTERNAL_GROUPS = YES
PERL_PATH = /usr/bin/perl
# --------------------------------------------------------------------
# Configuration options related to the dot tool
CLASS_DIAGRAMS = NO
HIDE_UNDOC_RELATIONS = YES
HAVE_DOT = YES
CLASS_GRAPH = YES
COLLABORATION_GRAPH = NO
UML_LOOK = NO
TEMPLATE_RELATIONS = NO
INCLUDE_GRAPH = YES
INCLUDED_BY_GRAPH = YES
CALL_GRAPH = NO
GRAPHICAL_HIERARCHY = NO
DOT_IMAGE_FORMAT = png
DOT_PATH =
DOTFILE_DIRS =
MAX_DOT_GRAPH_WIDTH = 512
MAX_DOT_GRAPH_HEIGHT = 1024
MAX_DOT_GRAPH_DEPTH = 0
GENERATE_LEGEND = YES
DOT_CLEANUP = YES
# --------------------------------------------------------------------
# Configuration::addtions related to the search engine
SEARCHENGINE = NO

16
hurricane/doc/hurricane/footer.html Normal file
View File

@ -0,0 +1,16 @@
<br>
<hr>
<table class="footer1">
<tr>
<td class="LFooter"><small>Generated by doxygen $doxygenversion on $date</small></td>
<td class="RFooter"><a href='#pagetop'><small>Return to top of page</small></a></td>
</tr>
</table>
<table class="footer2">
<tr>
<td class="LFooter">Hurricane Documentation</td>
<td class="RFooter"><small>Copyright &#169; 2000-2007 Bull S.A. All rights reserved</small></td>
</tr>
</table>
</body>
</html>

23
hurricane/doc/hurricane/header.html Normal file
View File

@ -0,0 +1,23 @@
<!DOCTYPE HTML PUBLIC '-//W3C//DTD HTML 4.0//EN'>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html;charset=iso-8859-1">
<title>Hurricane Documentation</title>
<link href="ASIM.css" rel="stylesheet" type="text/css">
</head>
<h1 id="pagetop" class="header">Hurricane Documentation</h1>
<center class="header">
<table class="header">
<tr>
<td><a href="customSummary.html">Summary</a></td>
<td><a href="namespaces.html">Namespaces</a></td>
<td><a href="customHierarchy.html">Class Hierarchy</a></td>
<td><a href="annotated.html">Classes</a></td>
<td><a href="functions.html">Member Index</a></td>
<!-- <td><a href="classes.html">Index2</a></td> -->
</tr>
</table>
</center>
<br>
<hr>
<body>

47
hurricane/doc/hurricane/header.tex Normal file
View File

@ -0,0 +1,47 @@
\documentclass[a4paper]{asimbook}
\usepackage{a4wide}
\usepackage{makeidx}
\usepackage{fancyhdr}
\usepackage{graphicx}
\usepackage{multicol}
\usepackage{float}
\usepackage{textcomp}
\usepackage{alltt}
\usepackage{times}
\ifx\pdfoutput\undefined
\usepackage[ps2pdf,pagebackref=true,colorlinks=true,linkcolor=blue]{hyperref}
\usepackage{pspicture}
\else
\usepackage[pdftex,pagebackref=true,colorlinks=true,linkcolor=blue]{hyperref}
\fi
\usepackage{doxygen}
\makeindex
\setcounter{tocdepth}{1}
\renewcommand{\footrulewidth}{0.4pt}
\raggedbottom
\begin{document}
\begin{titlepage}
\vspace*{7cm}
\begin{center}
{\Large $projectname Reference Manual\\[1ex]\large $projectnumber }\\
\vspace*{1cm}
{\large Generated by Doxygen $doxygenversion}\\
\vspace*{0.5cm}
{\small $datetime}\\
\end{center}
\end{titlepage}
\clearemptydoublepage
\pagenumbering{roman}
\tableofcontents
\clearemptydoublepage
\pagenumbering{arabic}

1
hurricane/doc/hurricane/html.entry Normal file
View File

@ -0,0 +1 @@
<li><a class="entry" href="hurricane.new/index.html">Hurricane</a><br>Fundamental C++ Database<br><br>

146
hurricane/doc/hurricane/images/DummyFig-1.fig Normal file
View File

@ -0,0 +1,146 @@
#FIG 3.2
Landscape
Center
Metric
Letter
100.00
Single
-2
1200 2
2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2
5625 3645 5625 4050
2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2
6750 2565 6750 4050
2 2 0 1 0 7 30 -1 -1 0.000 0 0 -1 0 0 5
1125 0 8325 0 8325 8550 1125 8550 1125 0
2 1 0 2 -1 7 40 -1 -1 0.000 0 0 -1 0 0 2
1350 6300 1935 6300
2 2 3 1 0 7 30 -1 -1 8.000 0 0 -1 0 0 5
1575 4950 4275 4950 4275 7650 1575 7650 1575 4950
2 2 3 1 0 7 30 -1 -1 8.000 0 0 -1 0 0 5
5175 4950 7875 4950 7875 7650 5175 7650 5175 4950
2 2 0 2 -1 7 50 -1 45 0.000 0 0 -1 0 0 5
4950 6255 7425 6255 7425 6345 4950 6345 4950 6255
2 2 0 2 18 7 40 -1 -1 0.000 0 0 -1 0 0 5
5535 6210 5715 6210 5715 6390 5535 6390 5535 6210
2 2 0 2 18 7 40 -1 -1 0.000 0 0 -1 0 0 5
7335 6210 7515 6210 7515 6390 7335 6390 7335 6210
2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2
3 1 1.00 60.00 120.00
2925 4005 5625 4005
2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2
3 1 1.00 60.00 120.00
2925 4320 5625 4320
2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2
3 1 1.00 60.00 120.00
6975 4005 6750 4005
2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2
3 1 1.00 60.00 120.00
6975 4320 6750 4320
2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2
5625 4005 6750 4005
2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2
5580 4320 6750 4320
2 2 3 1 0 7 30 -1 -1 8.000 0 0 -1 0 0 5
1575 675 4275 675 4275 3375 1575 3375 1575 675
2 2 3 1 0 7 30 -1 -1 8.000 0 0 -1 0 0 5
5175 675 7875 675 7875 3375 5175 3375 5175 675
2 1 0 2 -1 7 40 -1 -1 0.000 0 0 -1 0 0 2
1350 2025 1935 2025
2 2 0 2 -1 7 50 -1 45 0.000 0 0 -1 0 0 5
4950 1980 7425 1980 7425 2070 4950 2070 4950 1980
2 2 0 2 18 7 40 -1 -1 0.000 0 0 -1 0 0 5
5535 1935 5715 1935 5715 2115 5535 2115 5535 1935
2 2 0 2 18 7 40 -1 -1 0.000 0 0 -1 0 0 5
7335 1935 7515 1935 7515 2115 7335 2115 7335 1935
2 1 0 2 -1 7 40 -1 -1 0.000 0 0 -1 0 0 2
2025 3015 2025 3600
2 1 0 2 -1 7 40 -1 -1 0.000 0 0 -1 0 0 2
2115 2475 2700 2475
2 2 0 2 0 7 40 -1 45 0.000 0 0 -1 0 0 5
2700 2430 3150 2430 3150 2520 2700 2520 2700 2430
2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2
3 0 1.00 60.00 120.00
2925 2385 2925 1620
2 1 0 2 -1 7 40 -1 -1 0.000 0 0 -1 0 0 2
2025 7290 2025 7875
2 2 0 2 0 7 40 -1 45 0.000 0 0 -1 0 0 5
2700 5805 3150 5805 3150 5895 2700 5895 2700 5805
2 1 0 2 -1 7 40 -1 -1 0.000 0 0 -1 0 0 2
3825 4725 3825 6255
2 1 0 2 -1 7 40 -1 -1 0.000 0 0 -1 0 0 2
3825 450 3825 1935
2 2 0 2 0 7 50 -1 45 0.000 0 0 -1 0 0 5
5580 2025 5670 2025 5670 3600 5580 3600 5580 2025
2 2 0 2 0 7 50 -1 45 0.000 0 0 -1 0 0 5
5625 2430 6750 2430 6750 2520 5625 2520 5625 2430
2 2 0 2 18 7 40 -1 -1 0.000 0 0 -1 0 0 5
5535 2385 5715 2385 5715 2565 5535 2565 5535 2385
2 2 0 2 0 7 50 -1 45 0.000 0 0 -1 0 0 5
7470 2025 7380 2025 7380 450 7470 450 7470 2025
2 2 0 2 0 7 50 -1 45 0.000 0 0 -1 0 0 5
7470 6300 7380 6300 7380 4725 7470 4725 7470 6300
2 4 0 2 18 7 50 -1 -1 0.000 0 0 7 0 0 5
2115 3015 2115 1935 1935 1935 1935 3015 2115 3015
2 4 0 2 18 7 50 -1 -1 0.000 0 0 7 0 0 5
3915 2115 3915 1935 3735 1935 3735 2115 3915 2115
2 1 0 2 -1 7 40 -1 -1 0.000 0 0 -1 0 0 2
2115 2025 3735 2025
2 1 0 1 18 7 50 -1 -1 0.000 0 0 -1 1 0 2
3 0 1.00 60.00 120.00
5085 2475 5535 2115
2 1 0 1 18 7 50 -1 -1 0.000 0 0 -1 1 0 2
3 0 1.00 60.00 120.00
5085 2475 5535 2475
2 4 0 2 18 7 50 -1 -1 0.000 0 0 7 0 0 5
2115 7290 2115 5760 1935 5760 1935 7290 2115 7290
2 1 0 2 -1 7 40 -1 -1 0.000 0 0 -1 0 0 2
2115 5850 2700 5850
2 4 0 2 18 7 50 -1 -1 0.000 0 0 7 0 0 5
3915 6390 3915 6210 3735 6210 3735 6390 3915 6390
2 1 0 2 -1 7 40 -1 -1 0.000 0 0 -1 0 0 2
2115 6300 3735 6300
2 2 0 2 0 7 50 -1 45 0.000 0 0 -1 0 0 5
5625 5805 6750 5805 6750 5895 5625 5895 5625 5805
2 2 0 2 18 7 40 -1 -1 0.000 0 0 -1 0 0 5
5535 5760 5715 5760 5715 5940 5535 5940 5535 5760
2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2
5625 5760 5625 4275
2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 0 0 2
6750 5760 6750 4275
2 1 0 1 18 7 50 -1 -1 0.000 0 0 -1 1 0 2
3 0 1.00 60.00 120.00
5130 5850 5535 5850
2 1 0 1 18 7 50 -1 -1 0.000 0 0 -1 1 0 2
3 0 1.00 60.00 120.00
5130 5850 5535 6210
2 2 0 2 0 7 50 -1 45 0.000 0 0 -1 0 0 5
5580 5850 5670 5850 5670 7875 5580 7875 5580 5850
4 1 0 30 -1 14 12 0.0000 4 120 2205 2790 270 AutoContact Structure\001
4 1 0 30 -1 14 12 0.0000 4 180 1680 6390 225 Physical Mapping\001
4 1 0 40 -1 18 12 0.0000 4 135 255 1440 6255 G2\001
4 1 0 40 -1 18 12 0.0000 4 135 255 5040 6210 G2\001
4 0 0 50 -1 19 12 0.0000 4 180 2055 3105 3960 L1 before displacement\001
4 0 0 50 -1 19 12 0.0000 4 180 1905 3105 4500 L1 after displacement\001
4 1 0 40 -1 18 12 0.0000 4 135 255 1440 1980 G2\001
4 1 0 40 -1 18 12 0.0000 4 135 255 5040 1935 G2\001
4 1 -1 40 -1 18 12 0.0000 4 135 255 2205 3600 G1\001
4 1 -1 40 -1 18 12 0.0000 4 135 210 2925 2700 L1\001
4 1 -1 40 -1 18 12 0.0000 4 135 255 2205 7875 G1\001
4 1 -1 40 -1 18 12 0.0000 4 135 210 2925 5760 L1\001
4 1 -1 40 -1 18 12 0.0000 4 135 255 4005 4860 G3\001
4 1 -1 40 -1 18 12 0.0000 4 135 255 4005 585 G3\001
4 1 -1 40 -1 18 12 0.0000 4 135 255 5850 3600 G1\001
4 1 -1 40 -1 18 12 0.0000 4 135 210 6525 2385 L1\001
4 1 -1 40 -1 18 12 0.0000 4 135 255 7650 585 G3\001
4 1 -1 40 -1 18 12 0.0000 4 135 255 5850 7875 G1\001
4 1 -1 40 -1 18 12 0.0000 4 135 255 7650 4860 G3\001
4 1 -1 40 -1 18 12 0.0000 4 135 210 6570 5760 L1\001
4 1 18 40 -1 18 12 0.0000 4 135 600 2025 1845 AC-SW\001
4 1 18 40 -1 18 12 0.0000 4 135 570 3825 2295 AC-NE\001
4 1 18 40 -1 18 12 0.0000 4 135 570 7425 2340 AC-NE\001
4 1 18 40 -1 18 12 0.0000 4 135 570 7425 6615 AC-NE\001
4 2 18 40 -1 18 12 0.0000 4 135 600 5040 2565 AC-SW\001
4 2 18 40 -1 18 12 0.0000 4 135 600 5085 5895 AC-SW\001
4 1 18 40 -1 18 12 0.0000 4 135 600 2025 5670 AC-SW\001
4 1 18 40 -1 18 12 0.0000 4 135 570 3825 6570 AC-NE\001

BIN
hurricane/doc/hurricane/images/DummyFig-1.pdf Normal file
View File

Binary file not shown.

BIN
hurricane/doc/hurricane/images/DummyFig-1.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 7.6 KiB

151
hurricane/doc/hurricane/images/DummyFig-2.fig Normal file
View File

@ -0,0 +1,151 @@
#FIG 3.2
Landscape
Center
Metric
Letter
100.00
Single
-2
1200 2
6 1260 405 8145 3645
2 1 0 1 0 7 50 -1 -1 0.000 0 0 -1 1 0 2
3 0 1.00 60.00 120.00
2520 900 3780 900
2 2 3 1 0 7 30 -1 -1 8.000 0 0 -1 0 0 5
5175 675 7875 675 7875 3375 5175 3375 5175 675
2 1 0 2 -1 7 40 -1 -1 0.000 0 0 -1 0 0 2
1350 1125 1935 1125
2 1 0 2 -1 7 40 -1 -1 0.000 0 0 -1 0 0 2
2565 2025 4500 2025
2 1 0 2 -1 7 40 -1 -1 0.000 0 0 -1 0 0 2
2025 2115 2025 3600
2 1 0 2 -1 7 40 -1 -1 0.000 0 0 -1 0 0 2
2475 450 2475 1035
2 2 0 2 18 7 40 -1 -1 0.000 0 0 -1 0 0 5
5535 1035 5715 1035 5715 1215 5535 1215 5535 1035
2 2 0 2 0 7 50 -1 45 0.000 0 0 -1 0 0 5
5580 1125 5670 1125 5670 3600 5580 3600 5580 1125
2 4 0 2 18 7 50 -1 -1 0.000 0 0 7 0 0 5
2115 2115 2115 1035 1935 1035 1935 2115 2115 2115
2 4 0 2 18 7 50 -1 -1 0.000 0 0 7 0 0 5
2565 2115 2565 1035 2385 1035 2385 2115 2565 2115
2 1 0 2 -1 7 40 -1 -1 0.000 0 0 -1 0 0 2
2115 1575 2385 1575
2 2 0 2 -1 7 50 -1 45 0.000 0 0 -1 0 0 5
4950 1080 5625 1080 5625 1170 4950 1170 4950 1080
2 2 0 2 18 7 40 -1 -1 0.000 0 0 -1 0 0 5
5535 1485 5715 1485 5715 1665 5535 1665 5535 1485
2 2 0 2 0 7 50 -1 45 0.000 0 0 -1 0 0 5
6165 2025 6075 2025 6075 450 6165 450 6165 2025
2 2 0 2 18 7 40 -1 -1 0.000 0 0 -1 0 0 5
6030 1485 6210 1485 6210 1665 6030 1665 6030 1485
2 2 0 2 18 7 40 -1 -1 0.000 0 0 -1 0 0 5
6030 1935 6210 1935 6210 2115 6030 2115 6030 1935
2 2 0 2 -1 7 50 -1 45 0.000 0 0 -1 0 0 5
5625 1530 6120 1530 6120 1620 5625 1620 5625 1530
2 2 0 2 0 7 50 -1 45 0.000 0 0 -1 0 0 5
6120 1980 8100 1980 8100 2070 6120 2070 6120 1980
2 1 0 1 18 7 50 -1 -1 0.000 0 0 -1 1 0 2
3 0 1.00 60.00 120.00
5085 1575 5535 1575
2 1 0 1 18 7 50 -1 -1 0.000 0 0 -1 1 0 2
3 0 1.00 60.00 120.00
5085 1575 5535 1215
2 2 3 1 0 7 30 -1 -1 8.000 0 0 -1 0 0 5
1575 675 4275 675 4275 3375 1575 3375 1575 675
2 1 0 1 18 7 50 -1 -1 0.000 0 0 -1 1 0 2
3 0 1.00 60.00 120.00
6750 1575 6210 1575
2 1 0 1 18 7 50 -1 -1 0.000 0 0 -1 1 0 2
3 0 1.00 60.00 120.00
6750 1575 6210 1935
4 1 -1 40 -1 18 12 0.0000 4 135 255 5850 3600 G1\001
4 1 0 40 -1 18 12 0.0000 4 135 255 1395 1080 G2\001
4 1 -1 40 -1 18 12 0.0000 4 135 255 4410 2205 G4\001
4 1 -1 40 -1 18 12 0.0000 4 135 255 2205 3600 G1\001
4 1 -1 40 -1 18 12 0.0000 4 135 255 2655 585 G3\001
4 1 0 40 -1 18 12 0.0000 4 135 255 5040 1035 G2\001
4 1 -1 40 -1 18 12 0.0000 4 135 210 2250 1755 L1\001
4 1 -1 40 -1 18 12 0.0000 4 135 255 8010 2250 G4\001
4 1 -1 40 -1 18 12 0.0000 4 135 255 6345 585 G3\001
4 0 18 40 -1 18 12 0.0000 4 135 570 2655 1665 AC-NE\001
4 2 18 40 -1 18 12 0.0000 4 135 600 5040 1620 AC-SW\001
4 0 18 40 -1 18 12 0.0000 4 135 570 6795 1620 AC-NE\001
-6
2 2 0 1 0 7 30 -1 -1 0.000 0 0 -1 0 0 5
1125 0 8325 0 8325 7875 1125 7875 1125 0
2 2 3 1 0 7 30 -1 -1 8.000 0 0 -1 0 0 5
5175 4500 7875 4500 7875 7200 5175 7200 5175 4500
2 1 0 2 -1 7 40 -1 -1 0.000 0 0 -1 0 0 2
1350 4950 1935 4950
2 1 0 2 -1 7 40 -1 -1 0.000 0 0 -1 0 0 2
3915 5850 4500 5850
2 1 0 2 -1 7 40 -1 -1 0.000 0 0 -1 0 0 2
2025 5940 2025 7425
2 2 0 2 18 7 40 -1 -1 0.000 0 0 -1 0 0 5
5535 4860 5715 4860 5715 5040 5535 5040 5535 4860
2 2 0 2 0 7 50 -1 45 0.000 0 0 -1 0 0 5
5580 4950 5670 4950 5670 7425 5580 7425 5580 4950
2 4 0 2 18 7 50 -1 -1 0.000 0 0 7 0 0 5
2115 5940 2115 4860 1935 4860 1935 5940 2115 5940
2 1 0 2 -1 7 40 -1 -1 0.000 0 0 -1 0 0 2
2115 5400 3735 5400
2 2 0 2 -1 7 50 -1 45 0.000 0 0 -1 0 0 5
4950 4905 5625 4905 5625 4995 4950 4995 4950 4905
2 2 0 2 18 7 40 -1 -1 0.000 0 0 -1 0 0 5
5535 5310 5715 5310 5715 5490 5535 5490 5535 5310
2 1 0 1 18 7 50 -1 -1 0.000 0 0 -1 1 0 2
3 0 1.00 60.00 120.00
5085 5400 5535 5400
2 1 0 1 18 7 50 -1 -1 0.000 0 0 -1 1 0 2
3 0 1.00 60.00 120.00
5085 5400 5535 5040
2 2 3 1 0 7 30 -1 -1 8.000 0 0 -1 0 0 5
1575 4500 4275 4500 4275 7200 1575 7200 1575 4500
2 1 0 2 -1 7 40 -1 -1 0.000 0 0 -1 0 0 2
3825 4275 3825 4860
2 4 0 2 18 7 50 -1 -1 0.000 0 0 7 0 0 5
3915 5940 3915 4860 3735 4860 3735 5940 3915 5940
2 2 0 2 0 7 50 -1 45 0.000 0 0 -1 0 0 5
7425 5850 7335 5850 7335 4275 7425 4275 7425 5850
2 2 0 2 18 7 40 -1 -1 0.000 0 0 -1 0 0 5
7290 5310 7470 5310 7470 5490 7290 5490 7290 5310
2 2 0 2 18 7 40 -1 -1 0.000 0 0 -1 0 0 5
7290 5760 7470 5760 7470 5940 7290 5940 7290 5760
2 2 0 2 0 7 50 -1 45 0.000 0 0 -1 0 0 5
7380 5805 8100 5805 8100 5895 7380 5895 7380 5805
2 2 0 2 -1 7 50 -1 45 0.000 0 0 -1 0 0 5
5625 5355 7380 5355 7380 5445 5625 5445 5625 5355
2 1 0 1 18 7 50 -1 -1 0.000 0 0 -1 1 0 2
3 0 1.00 60.00 120.00
6975 6255 7290 5490
2 1 0 1 18 7 50 -1 -1 0.000 0 0 -1 1 0 2
3 0 1.00 60.00 120.00
6975 6255 7290 5940
2 1 0 1 18 7 50 -1 -1 0.000 0 0 -1 1 0 2
3 0 1.00 60.00 120.00
6075 5175 7290 5175
2 1 0 1 18 7 50 -1 -1 0.000 0 0 -1 1 0 2
3 0 1.00 60.00 120.00
6075 5850 7290 5850
2 1 0 4 18 7 50 -1 -1 0.000 0 0 -1 0 0 2
6075 5805 6075 5895
2 1 0 4 18 7 50 -1 -1 0.000 0 0 -1 0 0 2
6075 5130 6075 5220
4 1 0 30 -1 14 12 0.0000 4 120 2205 2790 270 AutoContact Structure\001
4 1 0 30 -1 14 12 0.0000 4 180 1680 6390 270 Physical Mapping\001
4 2 18 40 -1 18 12 0.0000 4 135 600 1845 1665 AC-SW\001
4 1 -1 40 -1 18 12 0.0000 4 135 255 5850 7425 G1\001
4 1 0 40 -1 18 12 0.0000 4 135 255 1395 4905 G2\001
4 1 -1 40 -1 18 12 0.0000 4 135 255 4410 6030 G4\001
4 1 -1 40 -1 18 12 0.0000 4 135 255 2205 7425 G1\001
4 1 0 40 -1 18 12 0.0000 4 135 255 5040 4860 G2\001
4 1 -1 40 -1 18 12 0.0000 4 135 255 8010 6075 G4\001
4 2 18 40 -1 18 12 0.0000 4 135 600 5040 5445 AC-SW\001
4 1 -1 40 -1 18 12 0.0000 4 135 255 4005 4410 G3\001
4 2 18 40 -1 18 12 0.0000 4 135 570 3645 5850 AC-NE\001
4 2 18 40 -1 18 12 0.0000 4 135 600 1845 5490 AC-SW\001
4 1 -1 40 -1 18 12 0.0000 4 135 255 7605 4410 G3\001
4 2 18 40 -1 18 12 0.0000 4 135 570 6930 6345 AC-NE\001
4 1 -1 40 -1 18 12 0.0000 4 135 210 2925 5580 L1\001
4 1 -1 40 -1 18 12 0.0000 4 135 210 6525 5625 L1\001

BIN
hurricane/doc/hurricane/images/DummyFig-2.pdf Normal file
View File

Binary file not shown.

BIN
hurricane/doc/hurricane/images/DummyFig-2.png Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 9.9 KiB

4
hurricane/doc/hurricane/images/Makefile.am Normal file
View File

@ -0,0 +1,4 @@
EXTRA_DIST = DummyFig-1.fig \
DummyFig-2.fig

Some files were not shown because too many files have changed in this diff Show More