diff --git a/hurricane/CMakeLists.txt b/hurricane/CMakeLists.txt index 4b85ff62..305c2737 100644 --- a/hurricane/CMakeLists.txt +++ b/hurricane/CMakeLists.txt @@ -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) diff --git a/hurricane/doc/CMakeLists.txt b/hurricane/doc/CMakeLists.txt new file mode 100644 index 00000000..06f2eea8 --- /dev/null +++ b/hurricane/doc/CMakeLists.txt @@ -0,0 +1 @@ +add_subdirectory(hurricane) diff --git a/hurricane/doc/hurricane/ASIM-bigfonts.css b/hurricane/doc/hurricane/ASIM-bigfonts.css new file mode 100644 index 00000000..f8ec6823 --- /dev/null +++ b/hurricane/doc/hurricane/ASIM-bigfonts.css @@ -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; + } + diff --git a/hurricane/doc/hurricane/ASIM.css b/hurricane/doc/hurricane/ASIM.css new file mode 100644 index 00000000..6d92a0c5 --- /dev/null +++ b/hurricane/doc/hurricane/ASIM.css @@ -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; + } + diff --git a/hurricane/doc/hurricane/BasicLayer.dox b/hurricane/doc/hurricane/BasicLayer.dox new file mode 100644 index 00000000..080973d7 --- /dev/null +++ b/hurricane/doc/hurricane/BasicLayer.dox @@ -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 \, of + * type \c \ 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. + * + * Color : + * + * A color is defined by its three RGB components (whose values + * lies in the 0, 255). + * + * Pattern : + * + * 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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/Box.dox b/hurricane/doc/hurricane/Box.dox new file mode 100644 index 00000000..f5c65961 --- /dev/null +++ b/hurricane/doc/hurricane/Box.dox @@ -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 XMin, YMin, XMax and + * YMax 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 \ and \c \. + */ + + /*! \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 \, \c \ and \c \, + * \c \. + */ + + /*! \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 \ + * and \c \. 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\, \c \ else \false. + */ + + /*! \function bool Box::Contains(const Point& point) const; + * \Return \true if the box is non empty and contains the point + * \c \, else \false. + */ + + /*! \function bool Box::Contains(const Box& box) const; + * \Return \true if the two boxes are non empty and if the box + * \c \ contains the box \c \, 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 \ + * contains the box \c \ 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 \. 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 \ and vertically of the quatity + * \c \. 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 \, on the bottom of the quantity + * \c \, on the right of the quantity \c \ and + * on the top of the quantity \c \. 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 \ and \c \. 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 \. 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 \, \c \ and \c \, \c \. + */ + + /*! \function Box& Box::Merge(const Box& box); + * Expands the box in order that it encloses, if not empty, the + * box \c \. If the box \c \ 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 \ + * and \c \. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/CMakeLists.txt b/hurricane/doc/hurricane/CMakeLists.txt new file mode 100644 index 00000000..c1be0312 --- /dev/null +++ b/hurricane/doc/hurricane/CMakeLists.txt @@ -0,0 +1 @@ +EXEC_PROGRAM(${DOXYGEN_EXECUTABLE}) diff --git a/hurricane/doc/hurricane/Cell.dox b/hurricane/doc/hurricane/Cell.dox new file mode 100644 index 00000000..4bb7d69f --- /dev/null +++ b/hurricane/doc/hurricane/Cell.dox @@ -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 Cells; + * Generic collection representing a set of cell objects. + */ + + /*! \typedef typedef GenericLocator CellLocator; + * Generic locator for visiting a cell objects Collection. + */ + + /*! \typedef typedef GenericFilter 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. + */ + + // \} + + } diff --git a/hurricane/doc/hurricane/Collection.dox b/hurricane/doc/hurricane/Collection.dox new file mode 100644 index 00000000..0f060a32 --- /dev/null +++ b/hurricane/doc/hurricane/Collection.dox @@ -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\ 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 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 GetInstances(...) +// ******************************************* +{ + set 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(); + * Destroys the collection but doesn't acts on elements refered + * by this collection. + */ + + // \} + + + /*! \name Accessors + */ + // \{ + + /*! \function Collection* 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* 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 for_each 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 Collection::GetSubSet() const; + * \Return the collection corresponding to the subset of elements of + * type \c \. + * + * \remark The returned collection is a collection of objects of type + * SubType and not of type Type. + * +\code +Contacts Net::GetContacts() const +// ****************************** +{ + return GetComponents().GetSubSet(); +} +\endcode + */ + + /*! \function GenericCollection Collection::GetSubSet(const Filter& 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 Collection::GetSubSet(const Filter& filter) const; + * \Return the collection representing the subset of elements of type + * \c \ accepted by the filter. + * + * \remark The returned collection is a collection of elements of type + * SubType and not of type Type and the filter + * must be a filter of elements of type SubType. + * + * \sample Filter Hurricane::Segment according to their Layer. +\code +class IsOnLayer : public Filter { +// ************************************** + + 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* 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(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 + * + * + * Collection::Fill + * Collection::Fill + * Collection::Fill + * \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 \ defines the type of elements that will be visited + * and the third argument \c \ is the traced + * collection. The code body located between macros + * for_each and end_for (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 break). 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 cell-\>GetExternalNets() + * 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& list) const; + * No description. + */ + + /* \function void Collection::Fill(vector& vector) const; + * No description. + */ + + /* \function void Collection::Fill(set>& set) const; + * Those three functions allow to fill a STL container with the + * identified elements of a collection. + */ + + // \} + + } diff --git a/hurricane/doc/hurricane/Command.dox b/hurricane/doc/hurricane/Command.dox new file mode 100644 index 00000000..2780a5b6 --- /dev/null +++ b/hurricane/doc/hurricane/Command.dox @@ -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 : + *
    + *
  • Command::InstallOn + *
  • Command::UninstallFrom + *
+ * + * + * \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 + * _OnInstalledOn() 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 + * _OnUnInstalledFrom() is issued by the view. + */ + + // \} + + } diff --git a/hurricane/doc/hurricane/Commons.dox b/hurricane/doc/hurricane/Commons.dox new file mode 100644 index 00000000..1813946b --- /dev/null +++ b/hurricane/doc/hurricane/Commons.dox @@ -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. + */ + + // \} + + } diff --git a/hurricane/doc/hurricane/Component.dox b/hurricane/doc/hurricane/Component.dox new file mode 100644 index 00000000..252e82d7 --- /dev/null +++ b/hurricane/doc/hurricane/Component.dox @@ -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 GetX() and GetY() 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 + * + * Component::GetIsUnderFilter + */ + + + + /*! \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 + * BodyHook, which represents the body of the component + * inside which it is nested (it is always a "master" + * 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 + * anchor 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 \, 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 \ + * (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 \ (which includes at least this one). + * + * \remark A componnent is said connex 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 \. + */ + + // \} + + + + /*! \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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/CompositeLayer.dox b/hurricane/doc/hurricane/CompositeLayer.dox new file mode 100644 index 00000000..0cecb9e7 --- /dev/null +++ b/hurricane/doc/hurricane/CompositeLayer.dox @@ -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 \, + * of type \c \ 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 \ (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 \ (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 \ (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 \ + * (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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/Contact.dox b/hurricane/doc/hurricane/Contact.dox new file mode 100644 index 00000000..6e7d6c2e --- /dev/null +++ b/hurricane/doc/hurricane/Contact.dox @@ -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 + * AnchorHook, 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 \ and \c \ 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 \, on the layer \c \, of size \c \ + * and \c \ and located at the absolute coordinates + * \c \ and \c \. + * + * \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 \, + * of size \c \ and \c \ attached upon the + * component \c \ through an offset defined by + * \c \ et \c \. + * + * \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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/DBo.dox b/hurricane/doc/hurricane/DBo.dox new file mode 100644 index 00000000..8bb8904f --- /dev/null +++ b/hurricane/doc/hurricane/DBo.dox @@ -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. Those objects must + * therefore be built by special functions which take care of + * that obscure work. + * + * Indeed, let us imagine a Go type representing the + * category of graphic objects and two sub-classes + * Rectangle and Line having specific geometric + * attributes. For eficiency reasons those Go are stored + * in a fast access geometric data structure like a + * QuadTree. It would be ideal that the insertion of the + * Go within its QuadTree be automatic. This could + * be done in the Go 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 + * Go 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 + * Line is created, the insertion being already done in + * the Line constructor, it must not be re-done for the + * derived class. Conversely if a new type of Go 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 Go, + * 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 _PostCreate 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 Create + * 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& 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 _PostCreate is + * called upon the net. This one realizes the additional + * operations that the constructor couldn't realize and then + * calls the functions _PostCreate 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 Line : the different called constructors + * will fully characterize the line, then the _PostCreate + * method on a line will do nothing else than call upon the + * _PostCreate method of the go which will insert + * the line within the QuadTree (this is now feasible, + * the line geometry being fully characterized). + * + * \section sDBoDelete Deletion process + * + * The Delete() member function : + * + * 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 _PreDelete must be called upon + * before the effective object destruction. As a matter of fact, + * if we take again the case of the Line for example, the + * line must be removed from the QuadTree 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& name); + + public: static MyCell* Create(Library* library, const Name& 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& name) + // *********************************************** + : Inherit(library, name) + { + } + + MyCell* MyCell::Create(Library* library, const Name& 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 + * _PreDelete. + * In the implementation of the class MyCell we have only + * used the type Inherit (and never Cell). 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 DBos; + * Generic collection representing a set of data base objects. + */ + + /*! \typedef typedef GenericLocator DBoLocator; + * Generic locator for visiting a data base objects Collection. + */ + + /*! \typedef typedef GenericFilter 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. + */ + + // \} diff --git a/hurricane/doc/hurricane/DataBase.dox b/hurricane/doc/hurricane/DataBase.dox new file mode 100644 index 00000000..82405d57 --- /dev/null +++ b/hurricane/doc/hurricane/DataBase.dox @@ -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. + */ + + // \} + + } diff --git a/hurricane/doc/hurricane/Editor.dox b/hurricane/doc/hurricane/Editor.dox new file mode 100644 index 00000000..9367d3f9 --- /dev/null +++ b/hurricane/doc/hurricane/Editor.dox @@ -0,0 +1,10 @@ + + // -*- C++ -*- + + + namespace Hurricane { + + /*! \class Editor + * \brief Editor description (\b API) + * + } diff --git a/hurricane/doc/hurricane/Entity.dox b/hurricane/doc/hurricane/Entity.dox new file mode 100644 index 00000000..377a7cb4 --- /dev/null +++ b/hurricane/doc/hurricane/Entity.dox @@ -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 Entities; + * Generic collection representing a set of data base objects. + */ + + /*! \typedef typedef GenericLocator EntityLocator; + * Generic locator for visiting a data base objects Collection. + */ + + /*! \typedef typedef GenericFilter 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. + */ + + // \} + + } diff --git a/hurricane/doc/hurricane/Error.dox b/hurricane/doc/hurricane/Error.dox new file mode 100644 index 00000000..680a6deb --- /dev/null +++ b/hurricane/doc/hurricane/Error.dox @@ -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. + */ + + // \} + + + + } diff --git a/hurricane/doc/hurricane/Exception.dox b/hurricane/doc/hurricane/Exception.dox new file mode 100644 index 00000000..8d3c9f7e --- /dev/null +++ b/hurricane/doc/hurricane/Exception.dox @@ -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 + */ + + + + } diff --git a/hurricane/doc/hurricane/ExpandRules.dox b/hurricane/doc/hurricane/ExpandRules.dox new file mode 100644 index 00000000..1c9fc1e1 --- /dev/null +++ b/hurricane/doc/hurricane/ExpandRules.dox @@ -0,0 +1,10 @@ + + // -*- C++ -*- + + + namespace Hurricane { + + /*! \class ExpandRules + * \brief ExpandRules description (\b API) + * + } diff --git a/hurricane/doc/hurricane/Filter.dox b/hurricane/doc/hurricane/Filter.dox new file mode 100644 index 00000000..24e4b27f --- /dev/null +++ b/hurricane/doc/hurricane/Filter.dox @@ -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* 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 Filter::operator ! () const; + * \Return the inverse filter of the filter \c \ (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 { +// *********************************** + + public: + + IsExternal() {}; + + IsExternal(const IsExternal& isExternal) {}; + + IsExternal& operator=(const IsExternal& isExternal) {return *this;}; + + virtual Filter* GetClone() const {return new IsExternal(*this);}; + + virtual bool Accept(Net* net) const {return netIsExternal();}; + +}; +\endcode + * Implementation of the accessor GetExternalNets for the + * cells : +\code +Nets Cell::GetExternalNet() const +// ****************************** +{ + return GetNets().GetSubSet(IsExternal()); +} +\endcode + * Similarly, the accessor GetInternalNets can be + * implemented using the ! 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 Accept 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 { +// ********************************* + + 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* 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& filter) const +// ******************************************************** +{ + return GetNets().GetSubSet(filter); +} +\endcode + * As far as the type NetFilter is defined as being a + * GenericFilter\ the previous function can be + * written like this : +\code +Nets Cell::GetNets(const NetFilter& filter) const +// ********************************************** +{ + return GetNets().GetSubSet(filter); +} +\endcode + */ + + + + } diff --git a/hurricane/doc/hurricane/Generalities.dox b/hurricane/doc/hurricane/Generalities.dox new file mode 100644 index 00000000..96c2a605 --- /dev/null +++ b/hurricane/doc/hurricane/Generalities.dox @@ -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 : is_a, for_each_cell + * or end_for) while the name of generic functions and + * member functions never use the underscore and always start + * with an Upper case letter (examples : GetUnit, + * GetMasterCell, IsCalledBy). + * + * \remark When examining \c .h include files for more detailed information + * you will find member functions which start with an + * underscore. While being "public" those functions must + * never be called upon. 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(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 \ 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)) { + // will inevitably go through here +} + +if (is_a(cell)) { + // will go through here also because Cell derives from Entity +} + +if (is_a(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 Inherit which represents this base class. + * This one is unique because Hurricane doesn't use multiple + * inheritance. 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: + * + *
    + *
  • Hurricane::in_trace + *
  • Hurricane::trace_on + *
  • Hurricane::trace_off + *
  • Hurricane::trace_in + *
  • Hurricane::trace_out + *
  • Hurricane::trace + *
+ * + * +\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: Hurricane::GetUnit will be + * introduced with the Unit class and Hurricane::GetCollection 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 cerr or + * a cout but the trace printing will be effective and + * indented only when the trace is active. + */ + + // \} + + } diff --git a/hurricane/doc/hurricane/GenericCollection.dox b/hurricane/doc/hurricane/GenericCollection.dox new file mode 100644 index 00000000..48a22781 --- /dev/null +++ b/hurricane/doc/hurricane/GenericCollection.dox @@ -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 \ a subset collection whose descriptor, + * of course, has additional attributes. For instance, the + * following sequence is rejected by the compiler +\code +Collection 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* nets = cellGetExternalNets().GetClone(); +... +// use +... +delete nets; // we delete the collection, not the nets +\endcode + * Fortunately, the GenericCollection\c \ 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 \ any collection of type Type (as + * well as an other generic collection). +\code +GenericCollection nets = cellGetExternalNets(); +... +// use it +... +\endcode + * The variable \c \ 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\), 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* 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 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::GenericCollection(); + * Default constructor : The generic collection is unbound and + * therefore empty. + */ + + /*! \function GenericCollection::GenericCollection(const Collection& collection); + * Standard constructor: the generic collection is initialized + * with a clone of \c \ (which may be empty). + */ + + /*! \function GenericCollection::GenericCollection(Collection* 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::GenericCollection(const GenericCollection& genericCollection); + * Copy constructor: the generic collection is here initialized + * with a clone of genericCollection (which, here also, may be + * empty). + */ + + // \} + + + + /*! \name Operators + */ + // \{ + + /*! \function GenericCollection& GenericCollection::operator=(const Collection& collection); + * Assignment operator : if the generic collection was bound to + * a clone, this one is first deleted and then a new clone of + * \c \ is allocated (which will be deleted when + * time comes either by a new assignment or by the generic + * collection deletion). + */ + + /*! \function GenericCollection& GenericCollection::operator=(Collection* collection); + * Assignment operator : The behaviour is identical to the + * standard assignment, but it's the \c \ + * collection itself which is bound to the generic collection + * and not a clone. + * + * \important This \* locator = cellGetNets().GetLocator(); +... +// use +... +delete locator; +\endcode + * Fortunately, the type GenericLocator\c \ 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 locator = cellGetNets().GetLocator(); +... +// use +... +\endcode + * \remark It's possible to bring within a GenericLocator\c \ + * 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 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 locator1 = CellGetNets().GetLocator(); + while (locator1.IsValid()) { + Net* net1 = locator1.GetElement(); + GenericLocator locator2 = locator1; + // or GenericLocator 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. + * + * Macro for_each implementation +\code +#define for_each(Type, variable, collection)\ +/*******************************************/\ +{\ + GenericLocator _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. + * + * Macro end_for implementation This macro is mandatory + * in order to close the lexical blocks opened by the for_each + * macro. +\code +#define end_for\ +/**************/\ + }\ +} +\endcode + * Important observation 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 + */ + + + + } diff --git a/hurricane/doc/hurricane/Go.dox b/hurricane/doc/hurricane/Go.dox new file mode 100644 index 00000000..97bd5849 --- /dev/null +++ b/hurricane/doc/hurricane/Go.dox @@ -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 Plugs are never materialized. + * + * + * \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 OpenUpdateSession() + * 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 + * CloseUpdateSession() 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 Invalidate + * 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 \ 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 \ and + * \c \. + * + * 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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/Hook.dox b/hurricane/doc/hurricane/Hook.dox new file mode 100644 index 00000000..c1d6d7e6 --- /dev/null +++ b/hurricane/doc/hurricane/Hook.dox @@ -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 part 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 + * BodyHook representing the body of the component (which + * can be assimilated to the component itself). + * + * + * \section secHookRings Rings + * + * Hooks are assembled into a ring (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 masters and the + * slaves. + * + * 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 \ and returns this masterHook. + * + * \caution Might throw an exception if the hook already has a master or + * if \c \ 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 \ 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 \ 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 \. + * + * \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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/Horizontal.dox b/hurricane/doc/hurricane/Horizontal.dox new file mode 100644 index 00000000..9b287a65 --- /dev/null +++ b/hurricane/doc/hurricane/Horizontal.dox @@ -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 \, located at ordinate \c \ and of width + * \c \. The differents extremities abscissas are given + * by \c \ and \c \. + * + * \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 \. + */ + + // \} + + + /*! \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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/Hurricane.dox b/hurricane/doc/hurricane/Hurricane.dox new file mode 100644 index 00000000..30b595ff --- /dev/null +++ b/hurricane/doc/hurricane/Hurricane.dox @@ -0,0 +1,11 @@ + + // -*- C++ -*- + + + namespace Hurricane { + + /*! \namespace Hurricane + * \brief The namespace dedicated to Hurricane. + */ + + } diff --git a/hurricane/doc/hurricane/Instance.dox b/hurricane/doc/hurricane/Instance.dox new file mode 100644 index 00000000..2bf0bc56 --- /dev/null +++ b/hurricane/doc/hurricane/Instance.dox @@ -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 "owner + * cell") and references (calls) a model cell which we will + * call the "mater cell". 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 "slave + * instances" 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 + * + * Hurricane::Instance::GetIsUnderFilter + */ + + + + /*! \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 \ belonging to the cell \c \ and refering + * the cell \c \ through a transformation + * \c \ if it is provided (else the identity + * transform is assumed). + * + * \caution Throws an exception if the cell \c \ is null, if the + * \c \ is null, if an instance of same name + * already exists or if a cyclic assembly is detected. + * + * \remark If the \c \ 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 \ 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 \ 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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/Interruption.dox b/hurricane/doc/hurricane/Interruption.dox new file mode 100644 index 00000000..87a16ab0 --- /dev/null +++ b/hurricane/doc/hurricane/Interruption.dox @@ -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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/Interval.dox b/hurricane/doc/hurricane/Interval.dox new file mode 100644 index 00000000..289bbce2 --- /dev/null +++ b/hurricane/doc/hurricane/Interval.dox @@ -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 VMin and VMax 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 + * makeEmpy is set to true (default) or full span + * otherwise. + */ + + /*! \function Interval::Interval(const Unit& v); + * Builds an interval of null size centered on the value defined + * by \c \. + */ + + /*! \function Interval::Interval(const Unit& v1, const Unit& v2); + * Builds the minimal interval enclosing the two values defined + * by \c \ and \c \. + */ + + /*! \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 \ and \c \. 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 \ else \false. + */ + + /*! \function bool Interval::Contains(const Interval& interval) const; + * \Return \true if the two intervals are non empty and if the interval + * \c \ contains the interval \c \, 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 \. 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 \ and on the right of the + * quantity \c \. 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 \. 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 \. If the interval \c \ 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 + * [vMin,vMax]. + */ + + /*! \function Interval& Interval::Intersection(const Interval& interval); + * The interval becomes the intersection of itself and + * interval. + */ + + /*! \function Interval& Interval::Translate(const Unit& dv); + * Translates the interval, if not empty, of the quantity + * \c \. + * + * Exemple : +\code +Interval interval1 = Interval(10, 100); +Interval interval2 = interval1; + +assert(interval1.Translate(10) == interval2.Inflate(-10, 10)); +\endcode + * + * + */ + + // \} + + + + } diff --git a/hurricane/doc/hurricane/Layer.dox b/hurricane/doc/hurricane/Layer.dox new file mode 100644 index 00000000..492c5b59 --- /dev/null +++ b/hurricane/doc/hurricane/Layer.dox @@ -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 \ is completely included in the layer + * \c \ (that is if the basic layers of \c \ are + * a sub-set of the basic layers of \c \), else \false. + */ + + /*! \function bool Layer::Intersect(Layer* layer) const; + * \Return \true if the \c \ and the layer \c \ 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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/Library.dox b/hurricane/doc/hurricane/Library.dox new file mode 100644 index 00000000..8b83e044 --- /dev/null +++ b/hurricane/doc/hurricane/Library.dox @@ -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 \ for + * the data base \c \. + * + * \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 \ for + * the library \c \. + * + * \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 \ 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 \ 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 \ 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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/ListCollection.dox b/hurricane/doc/hurricane/ListCollection.dox new file mode 100644 index 00000000..70d936d1 --- /dev/null +++ b/hurricane/doc/hurricane/ListCollection.dox @@ -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 ListCollection as created by the generic + * function GetCollection(...) 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 + * + * Hurricane::ListCollection::GetCollection + * Hurricane::ListCollection::GetCollection + * + * + * \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 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 ListCollection::GetCollection(const list& elementList); + * \see below. + */ + + /*! \function GenericCollection ListCollection::GetCollection(const list* elementList);; + * Those two function return into generic collection bound to a + * ListCollection the content of the STL list given in + * argument. + */ + + // \} + + } diff --git a/hurricane/doc/hurricane/Locator.dox b/hurricane/doc/hurricane/Locator.dox new file mode 100644 index 00000000..663b4349 --- /dev/null +++ b/hurricane/doc/hurricane/Locator.dox @@ -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 + * + * Initialization 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. + * + * End of walk indicator The predicate IsValid() + * returns \true if the locator refers an element of the set, + * \false when all the elements have been visited. + * + * Getting the current element The current element is + * obtained by the accessor GetElement(). There is no + * risk to call this function when the visit is finished or the + * locator is non initialized (the returned value is + * meaningless). + * + * Walk progression The function Progress() 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* 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* locator1 = CellGetNets().GetLocator(); + while (locator1IsValid()) { + Net* net1 = locator1GetElement(); + + Locator* 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 Type() when the + * locator is not or no longer valid). + */ + + /*! \function Locator* 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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/MIGRATE.txt b/hurricane/doc/hurricane/MIGRATE.txt new file mode 100644 index 00000000..f8df1cdc --- /dev/null +++ b/hurricane/doc/hurricane/MIGRATE.txt @@ -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 > et < . + + 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! diff --git a/hurricane/doc/hurricane/MainView.dox b/hurricane/doc/hurricane/MainView.dox new file mode 100644 index 00000000..6a89fd9d --- /dev/null +++ b/hurricane/doc/hurricane/MainView.dox @@ -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 + * + * Hurricane::MainView::Create + */ + + + + /*! \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). + */ + + // \} + + } diff --git a/hurricane/doc/hurricane/Makefile.am b/hurricane/doc/hurricane/Makefile.am new file mode 100644 index 00000000..b0e775c2 --- /dev/null +++ b/hurricane/doc/hurricane/Makefile.am @@ -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) + diff --git a/hurricane/doc/hurricane/Makefile.in b/hurricane/doc/hurricane/Makefile.in new file mode 100644 index 00000000..7d17d6f8 --- /dev/null +++ b/hurricane/doc/hurricane/Makefile.in @@ -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: diff --git a/hurricane/doc/hurricane/MapCollection.dox b/hurricane/doc/hurricane/MapCollection.dox new file mode 100644 index 00000000..ea71bd8d --- /dev/null +++ b/hurricane/doc/hurricane/MapCollection.dox @@ -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 MapCollection as created by the generic + * function GetCollection(...) 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 + * + * Hurricane::MapCollection::GetCollection + * Hurricane::MapCollection::GetCollection + * + * + * \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 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 MapCollection::GetCollection(const map& elementMap); + * \see below. + */ + + /*! \function GenericCollection MapCollection::GetCollection(const map* elementMap);; + * Those two function return into generic collection bound to a + * MapCollection the content of the STL map given in + * argument. + */ + + // \} + + } diff --git a/hurricane/doc/hurricane/MapView.dox b/hurricane/doc/hurricane/MapView.dox new file mode 100644 index 00000000..aab5581d --- /dev/null +++ b/hurricane/doc/hurricane/MapView.dox @@ -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. + */ + + + + } diff --git a/hurricane/doc/hurricane/Name.dox b/hurricane/doc/hurricane/Name.dox new file mode 100644 index 00000000..235e9830 --- /dev/null +++ b/hurricane/doc/hurricane/Name.dox @@ -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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/Net.dox b/hurricane/doc/hurricane/Net.dox new file mode 100644 index 00000000..06c73538 --- /dev/null +++ b/hurricane/doc/hurricane/Net.dox @@ -0,0 +1,310 @@ + + // -*- C++ -*- + + + namespace Hurricane { + + /*! \class Net + * \brief Net description (\b API) + * + * \section secNetPredefinedFilters Predefined filters + * + * Hurricane::Net::GetIsGlobalFilter + * Hurricane::Net::GetIsExternalFilter + * Hurricane::Net::GetIsInternalFilter + * Hurricane::Net::GetIsClockFilter + * Hurricane::Net::GetIsSupplyFilter + */ + + + /*! \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 \ for the cell + * \c \. + * + * \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 \. + */ + + /*! \function void Net::SetGlobal(bool state); + * Sets global signal status to \c \. + */ + + /*! \function void Net::SetExternal(bool state); + * Sets the external net status to \c \. + * + * \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 \ to the net \c \ which keeps + * its characteristics (arity, global, external and direction). + * + * \caution An exception is thrown if the \c \ is null or equal to + * \c \, if the two nets don't belong to the same cell or + * if \c \ is external and master net of a connected plug + * while net \c \ is not external. + * + * \remark All the rubbers and the components of the \c \ (and + * also the plugs) become rubbers or components of the net + * \c \. Nevertheless if for a particular slave instance + * there was both a plug referencing the \c \ and an other + * plug referencing \c \, 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 \ 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. + */ + + // \} + + } diff --git a/hurricane/doc/hurricane/NotFilter.dox b/hurricane/doc/hurricane/NotFilter.dox new file mode 100644 index 00000000..a97bb26a --- /dev/null +++ b/hurricane/doc/hurricane/NotFilter.dox @@ -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 ! 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(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 + * IsExternalFilter which can be obtained by the static + * member function Net::GetIsExternalFilter(). + * + * The accessor GetInternalNets being written as follow : +\code +Nets Cell::GetInternalNets() const +// ******************************* +{ + return GetNets().GetSubSet(!Net::GetIsExternalFilter()); +} +\endcode + * The nets provide of course the filter + * IsInternalFilter, but we didn't use it here in order + * to illustrate the operator !. + */ + + + + } diff --git a/hurricane/doc/hurricane/Occurence.dox b/hurricane/doc/hurricane/Occurence.dox new file mode 100644 index 00000000..fec6f18d --- /dev/null +++ b/hurricane/doc/hurricane/Occurence.dox @@ -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 OwnerCell + * which is either the cell owning the path if this one is non + * void, else the cell owning the entity itself. and a + * MasterCell 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 \ 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 \ 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 \ 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 \ 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: Occurrences -\> Collection\ + * Collection representing a set of occurrences. + * + * type: OccurrenceLocator -\> + * GenericLocator\ Locator for traversing a set of + * occurrences. + * + * type: OccurrenceFilter -\> GenericFilter\ + * 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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/Occurrence.dox b/hurricane/doc/hurricane/Occurrence.dox new file mode 100644 index 00000000..75e57a40 --- /dev/null +++ b/hurricane/doc/hurricane/Occurrence.dox @@ -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 OwnerCell + * which is either the cell owning the path if this one is non + * void, else the cell owning the entity itself. and a + * MasterCell 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 \ 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 \ 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 \ 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 \ 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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/Pad.dox b/hurricane/doc/hurricane/Pad.dox new file mode 100644 index 00000000..e0e54152 --- /dev/null +++ b/hurricane/doc/hurricane/Pad.dox @@ -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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/Path.dox b/hurricane/doc/hurricane/Path.dox new file mode 100644 index 00000000..57326aad --- /dev/null +++ b/hurricane/doc/hurricane/Path.dox @@ -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 \ and + * tail path \c \. + * + * \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 \ and tail + * instance \c \. + * + * \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 + * SetPathNameSeparator 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 \). + * + * \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 SetPathNameSeparator). + * + * \Return the string "" 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 \. + */ + + // \} + + + /*! \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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/Pin.dox b/hurricane/doc/hurricane/Pin.dox new file mode 100644 index 00000000..58e1ee37 --- /dev/null +++ b/hurricane/doc/hurricane/Pin.dox @@ -0,0 +1,12 @@ + + // -*- C++ -*- + + + namespace Hurricane { + + /*! \class Pin + * \brief Pin description (\b API) + * + */ + + } diff --git a/hurricane/doc/hurricane/Plug.dox b/hurricane/doc/hurricane/Plug.dox new file mode 100644 index 00000000..28526cde --- /dev/null +++ b/hurricane/doc/hurricane/Plug.dox @@ -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 "master + * net" 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 + * + * + * Hurricane::Plug::GetIsConnectedFilter + * Hurricane::Plug::GetIsUnconnectedFilter + */ + + + + /*! \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 GetNet() 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. + */ + + // \} + + } diff --git a/hurricane/doc/hurricane/Point.dox b/hurricane/doc/hurricane/Point.dox new file mode 100644 index 00000000..d584e548 --- /dev/null +++ b/hurricane/doc/hurricane/Point.dox @@ -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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/Primitive.dox b/hurricane/doc/hurricane/Primitive.dox new file mode 100644 index 00000000..52284a72 --- /dev/null +++ b/hurricane/doc/hurricane/Primitive.dox @@ -0,0 +1,12 @@ + + // -*- C++ -*- + + + namespace Hurricane { + + /*! \class Primitive + * \brief Primitive description (\b API) + * + */ + + } diff --git a/hurricane/doc/hurricane/PrivateProperty.dox b/hurricane/doc/hurricane/PrivateProperty.dox new file mode 100644 index 00000000..42c272b1 --- /dev/null +++ b/hurricane/doc/hurricane/PrivateProperty.dox @@ -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 dbo-\>Put(property). The + * property then receives a message OnCapturedBy whose + * argument is the additional owner. From that time onwards, + * this object becomes partially responsible of the future of + * the property. + * + * What can happen then ? + * + * 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 OnReleasedBy + * 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 + * OnReleasedBy. + */ + + + + /*! \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 + */ + // \{ + diff --git a/hurricane/doc/hurricane/Property.dox b/hurricane/doc/hurricane/Property.dox new file mode 100644 index 00000000..8f534d3f --- /dev/null +++ b/hurricane/doc/hurricane/Property.dox @@ -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. + * + * + * Accessing a property by its name +\code +Property* DBo::GetProperty(const Name& name) const; +\endcode + * This member function returns the property of name \c \ + * 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 \ attached to the quark, if any, by calling + * the previous function (because quarks are data base objects). + * + * + * Accessing the set of all properties +\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). + * + * + * Does the object have properties ? +\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. + * + * + * Adding a property : things becomes a little harder +\code +void DBo::Put(Property* property); +\endcode + * Adds the property \c \ 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 and/or 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 (name unicity) or on an other + * object (unicity of owner for a private property). + * + * 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 : OnCapturedBy(DBo* dbo) when the + * property is attached to an object and OnReleasedBy(DBo* + * dbo) 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. + * + * + * Removing a property +\code +void DBo::Remove(Property* property); +\endcode + * Removes the property \c \ 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 OnReleasedBy is called upon as explained + * above. This call will decide of the future of the removed + * property. + * + * + * Clearing all properties +\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 OnReleasedBy 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 Create and not by the usual new + * (which is not available). + * + * + * \section secPropertyDeletionProcess Deletion process + * + * Hurricane::Property::Delete + * + * + * \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 hurricaners + * + * \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 is_a 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(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 \. + * + * 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 \ properties. + * + * \important The argument \c \ 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). + */ + + // \} + + } diff --git a/hurricane/doc/hurricane/QuadTree.dox b/hurricane/doc/hurricane/QuadTree.dox new file mode 100644 index 00000000..f4520a69 --- /dev/null +++ b/hurricane/doc/hurricane/QuadTree.dox @@ -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 \. + */ + + // \} + + + /*! \name Predicates + */ + // \{ + + /*! \function bool QuadTree::IsEmpty() const; + * \Return true if the quadtree doesn't contain any object, else + * false. + */ + + // \} + + + /*! \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 Materialize + * and removed by the method Unmaterialize. + * + * 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(); } } + */ + + + + } diff --git a/hurricane/doc/hurricane/Quark.dox b/hurricane/doc/hurricane/Quark.dox new file mode 100644 index 00000000..7e6e4900 --- /dev/null +++ b/hurricane/doc/hurricane/Quark.dox @@ -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 : + * occurence.ClearProperties() 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(property)) { + for_each_dbo(dbo, ((SharedProperty*)property)GetOwners()) { + if (!is_a(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. + */ + + // \} + + + + } diff --git a/hurricane/doc/hurricane/RecordHandles.dox b/hurricane/doc/hurricane/RecordHandles.dox new file mode 100644 index 00000000..a4246099 --- /dev/null +++ b/hurricane/doc/hurricane/RecordHandles.dox @@ -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 "" + */ + + /*! \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. + */ + + } diff --git a/hurricane/doc/hurricane/Relation.dox b/hurricane/doc/hurricane/Relation.dox new file mode 100644 index 00000000..170760b3 --- /dev/null +++ b/hurricane/doc/hurricane/Relation.dox @@ -0,0 +1,12 @@ + + // -*- C++ -*- + + + namespace Hurricane { + + /*! \class Relation + * \brief Relation description (\b API) + * + */ + + } diff --git a/hurricane/doc/hurricane/Rubber.dox b/hurricane/doc/hurricane/Rubber.dox new file mode 100644 index 00000000..5bbe5975 --- /dev/null +++ b/hurricane/doc/hurricane/Rubber.dox @@ -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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/Segment.dox b/hurricane/doc/hurricane/Segment.dox new file mode 100644 index 00000000..c57967cf --- /dev/null +++ b/hurricane/doc/hurricane/Segment.dox @@ -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 + * SourceHook, 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 + * TargetHook, 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 \ is the source + * hook of the segment. + * + * \Return the source hook of the segment if \c \ 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 \ is the + * source anchor of the segment (may be NULL) + * + * \Return the source anchor of the segment if \c \ 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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/SelectCommand.dox b/hurricane/doc/hurricane/SelectCommand.dox new file mode 100644 index 00000000..ebb5accd --- /dev/null +++ b/hurricane/doc/hurricane/SelectCommand.dox @@ -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 : "Select" and has to be + * installed on the mouse middle button. + * + * + * \section secSelectCommandPrinciple Principle + * + * After defining a rectangle, the selection proceeds in two + * steps : + * + * Identification of candidate occurences : + * + * 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. + * + * Modification of the current selection : + * + * 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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/SelectNetCommand.dox b/hurricane/doc/hurricane/SelectNetCommand.dox new file mode 100644 index 00000000..4db4c71c --- /dev/null +++ b/hurricane/doc/hurricane/SelectNetCommand.dox @@ -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 : "Select nets" and bound to the + * mouse right button. + * + * + * \section secSelectNetCommandPrinciple Principle + * + * After having defined a point, the selection proceeds in two + * steps : + * + * Identification of candidate occurences : + * + * Candidate occurences are those located below this point. + * + * Only visible occurences are potentially candidates. + * + * Modification of the current selection : + * + * 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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/Selector.dox b/hurricane/doc/hurricane/Selector.dox new file mode 100644 index 00000000..f877f003 --- /dev/null +++ b/hurricane/doc/hurricane/Selector.dox @@ -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. + */ + + + + } diff --git a/hurricane/doc/hurricane/SetCollection.dox b/hurricane/doc/hurricane/SetCollection.dox new file mode 100644 index 00000000..5139f4b3 --- /dev/null +++ b/hurricane/doc/hurricane/SetCollection.dox @@ -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 SetCollection as created by the generic + * function GetCollection(...) 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 + * + * Hurricane::SetCollection::GetCollection + * Hurricane::SetCollection::GetCollection + * + * + * \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 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 SetCollection::GetCollection(const set& elementSet); + * See below. + */ + + /*! \function GenericCollection SetCollection::GetCollection(const set* elementSet);; + * Those two function return into generic collection bound to a + * SetCollection the content of the STL set given in + * argument. + */ + + // \} + + } diff --git a/hurricane/doc/hurricane/SharedProperty.dox b/hurricane/doc/hurricane/SharedProperty.dox new file mode 100644 index 00000000..bc4a38d0 --- /dev/null +++ b/hurricane/doc/hurricane/SharedProperty.dox @@ -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 dbo-\>Put(property). The + * property then receives a message OnCapturedBy whose + * argument is the additional owner. From that time onwards, + * this object becomes partially responsible of the future of + * the property. + * + * What can happen then ? + * + * 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 OnReleasedBy + * 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 OnReleasedBy 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 + */ + // \{ + diff --git a/hurricane/doc/hurricane/Slice.dox b/hurricane/doc/hurricane/Slice.dox new file mode 100644 index 00000000..ff2eb407 --- /dev/null +++ b/hurricane/doc/hurricane/Slice.dox @@ -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 \. + */ + + // \} + + + + /*! \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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/SlotAdapter.dox b/hurricane/doc/hurricane/SlotAdapter.dox new file mode 100644 index 00000000..b5130dd8 --- /dev/null +++ b/hurricane/doc/hurricane/SlotAdapter.dox @@ -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 : + *
    + *
  • \b _GetTypeName() : the inspected object's type. + *
  • \b _GetString() : a synthetic string description of the + * object's state. + *
  • \b _GetRecord() : the complete description of all object's + * attributes (a list of Slot). + *
  • \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. + *
+ * + * + * \subsection ssObjectTypology Typology of inspectables objects + * + * We distinguish three kind of objects, corresponding to three + * different ways of association to a SlotAdapter. + *
    + *
  • User defined, with virtual methods : those objects + * must inherit from the NestedSlotAdapter class. + *
  • User defined, without virtual methods : thoses + * objects must provides (as ordinary methods) + * \b _GetTypeName() , \b _GetString() , \b _GetRecord() . + * But \b not \b _GetSlot(). + *
  • External objects : 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). + *
+ * + * + * \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 ""; }; + 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 ""; }; + 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 ( const bool* object ) { return ">"; } + +template<> + inline string ProxyString ( const bool* object ) { return (*object)?"True":"False" ; } + +template<> + inline Record* ProxyRecord ( 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 inline string GetString ( T* t ); +template inline string GetString ( T t ); +template inline Hurricane::Slot* GetSlot ( const string& name, T* t ); +template 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. + * + * Argument type policy + * + * As you noticed there are two overload for each function, + * one with pointer argument, the other with a value argument. + * This is meaningful : + *
    + *
  • 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. + *
  • 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. + *
+ * + * Default type support + * + * Hurricane provide support for the following types : + *
    + *
  • const char + *
  • const char* + *
  • const string* + *
  • const bool* + *
  • const void* + *
  • const int* + *
  • const long* + *
  • const unsigned int* + *
  • const unsigned long* + *
  • const unsigned long long* + *
  • const unsigned short int* + *
  • const float* + *
  • const double* + *
+ * 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 : + *
    + *
  • const vector* + *
  • const list* + *
  • const map* + *
  • const set* + *
  • const multiset* + *
+ * + * + * \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. + */ + + } diff --git a/hurricane/doc/hurricane/StandardPrivateProperty.dox b/hurricane/doc/hurricane/StandardPrivateProperty.dox new file mode 100644 index 00000000..b10587d9 --- /dev/null +++ b/hurricane/doc/hurricane/StandardPrivateProperty.dox @@ -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 + */ + // \{ + diff --git a/hurricane/doc/hurricane/StandardRelation.dox b/hurricane/doc/hurricane/StandardRelation.dox new file mode 100644 index 00000000..aa98e6d3 --- /dev/null +++ b/hurricane/doc/hurricane/StandardRelation.dox @@ -0,0 +1,12 @@ + + // -*- C++ -*- + + + namespace Hurricane { + + /*! \class StandardRelation + * \brief StandardRelation description (\b API) + * + */ + + } diff --git a/hurricane/doc/hurricane/StandardSharedProperty.dox b/hurricane/doc/hurricane/StandardSharedProperty.dox new file mode 100644 index 00000000..d6d31f82 --- /dev/null +++ b/hurricane/doc/hurricane/StandardSharedProperty.dox @@ -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 + */ + // \{ + diff --git a/hurricane/doc/hurricane/SubSetCollection.dox b/hurricane/doc/hurricane/SubSetCollection.dox new file mode 100644 index 00000000..6aac1030 --- /dev/null +++ b/hurricane/doc/hurricane/SubSetCollection.dox @@ -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 collection.GetSubSet(filter) + * 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 { +// *********************************** + + public: + + IsExternal() {}; + + IsExternal(const IsExternal& isExternal) {}; + + IsExternal& operator=(const IsExternal& isExternal) {return *this;}; + + virtual Filter* GetClone() const {return new IsExternal(*this);}; + + virtual bool Accept(Net* net) const {return netIsExternal();}; + +}; +\endcode + * Implementation of the accessor GetExternalNets 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 IsExternalFilter + * which can be obtained by calling the static member function + * Net::GetIsExternalFilter(). + * + * Then, the GetExternalNets accessor for cells is + * written like this : +\code +Nets Cell::GetExternalNets() const +// ******************************* +{ + return GetNets().GetSubSet(Net::GetIsExternalFilter()); +} +\endcode + */ + + + + } diff --git a/hurricane/doc/hurricane/SubTypeCollection.dox b/hurricane/doc/hurricane/SubTypeCollection.dox new file mode 100644 index 00000000..9f5cbbd9 --- /dev/null +++ b/hurricane/doc/hurricane/SubTypeCollection.dox @@ -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 Type from a collection of elements of type + * SuperType. + * + * In principle you don't need to use this collection directly, + * but through the call of + * collection-\>GetSubSet\c \() 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 + * GetContacts member function for a net, which returns + * the set of contacts in its layout. +\code +Contacts Net::GetContacts() const +// ****************************** +{ + return GetComponents()GetSubSet(); +} +\endcode + * It's very simple ... + */ + + + + } diff --git a/hurricane/doc/hurricane/Symbol.dox b/hurricane/doc/hurricane/Symbol.dox new file mode 100644 index 00000000..91edc2a5 --- /dev/null +++ b/hurricane/doc/hurricane/Symbol.dox @@ -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 \ for the + * library \c \. + * + * \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 \. + * + * \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 \ 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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/Tabulation.dox b/hurricane/doc/hurricane/Tabulation.dox new file mode 100644 index 00000000..a76a874c --- /dev/null +++ b/hurricane/doc/hurricane/Tabulation.dox @@ -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 = "   "); + * Default constructor : The string \c \ 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. + */ + + // \} + + + + } diff --git a/hurricane/doc/hurricane/Technology.dox b/hurricane/doc/hurricane/Technology.dox new file mode 100644 index 00000000..5e79ca56 --- /dev/null +++ b/hurricane/doc/hurricane/Technology.dox @@ -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 \ for the data base \c \. + * + * \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 \ if it exists, else \NULL. + */ + + /*! \function BasicLayer* Technology::GetBasicLayer ( const Name& name ) const; + * \Return the Layer named \c \ if it exists and is a BasicLayer, else \NULL. + */ + + /*! \function CompositeLayer* Technology::GetCompositeLayer ( const Name& name ) const; + * \Return the Layer named \c \ 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 \ (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). + */ + + // \} + + } diff --git a/hurricane/doc/hurricane/Transformation.dox b/hurricane/doc/hurricane/Transformation.dox new file mode 100644 index 00000000..280362af --- /dev/null +++ b/hurricane/doc/hurricane/Transformation.dox @@ -0,0 +1,264 @@ + + // -*- C++ -*- + + + namespace Hurricane { + + /*! \class Transformation + * \brief Transformation description (\b API) + * + * \section secTransformationIntro Introduction + * + * Transformation objects are a combination of a + * translation and an orientation defined by the + * new enumeration Transformation::Orientation whose + * different values are described in table below. + * + * + * \remark Rotations are done counter clock wise : + */ + + + + /*! \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 0 + * Identity 1 0 0 1 slots: R1 1 Simple + * rotation (90°) 0   -1   1 0 slots: R2 2 Double rotation (180°) + *   -1   0 0   -1   + * slots: R3 3 Triple rotation (270°) 0 + * 1   -1   0 slots: MX 4 Horizontal symetry (Miror X) + *   -1   0 0 1 slots: XR 5 Horizontal symetry followed by a 90° + * rotation 0   -1   + *   -1   0 slots: MY 6 Vertical symetry (Miror Y) 1 0 0 + *   -1   slots: YR + * 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 R1 : + * Transformation::Orientation::R1. 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 ID. + */ + + /*! \function Transformation::Transformation(const Point& translation, const Transformation::Orientation& orientation=Orientation::ID); + * Builds a transformation whose translation part is defined by + * the argument \c \ and whose default orientation is + * ID. + */ + + /*! \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 \ and \c \ and whose orientation + * is defined by \c \ (\c \ by default). + */ + + /*! \function Transformation::Transformation(const Point& translation, const Transformation::Orientation& orientation); + * Builds a transformation whose translation part is defined by + * the argument \c \ and whose orientation is + * defined by \c \. + */ + + /*! \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 \ et \c \. + */ + + /*! \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 \ et \c \. + */ + + /*! \function Unit Transformation::GetX(const Point& point) const; + * \Return the point abscissa resulting of the transformation + * application on \c \. + */ + + /*! \function Unit Transformation::GetY(const Point& point) const; + * \Return the point ordinate resulting of the transformation + * application on \c \. + */ + + /*! \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 \ et \c \. + */ + + /*! \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 \ et \c \. + */ + + /*! \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 \ et + * \c \. + */ + + /*! \function Point Transformation::GetPoint(const Point& point) const; + * \Return the point resulting from the application of the + * transformation on \c \. + */ + + /*! \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 \, \c \, \c \ et + * \c \. + */ + + /*! \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 \ et \c \. + */ + + /*! \function Box Transformation::GetBox(const Box& box) const; + * \Return the box resulting from the application of the transformation + * on the box \c \. + */ + + /*! \function Transformation Transformation::GetTransformation(const Transformation& transformation) const; + * \Return the transformation resulting from the application of the + * transformation on the transformation \c \. + */ + + /*! \function Transformation Transformation::GetInvert() const; + * \Return the inverse transformation. + */ + + // \} + + + /*! \name Modifiers + */ + // \{ + + /*! \function Transformation& Transformation::Invert(); + * Inverts the transformation \c \ and returns a + * reference to it in order to apply in sequence a new function. + */ + + // \} + + + /*! \section secTransformationTransformers Transformers + * + * + * Transformation::ApplyOn + * + * Transformation::ApplyOn + * + * Transformation::ApplyOn + * + * Transformation::ApplyOn + */ + + + + /* \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. + */ + + // \} + + } diff --git a/hurricane/doc/hurricane/Unit.dox b/hurricane/doc/hurricane/Unit.dox new file mode 100644 index 00000000..0926abb5 --- /dev/null +++ b/hurricane/doc/hurricane/Unit.dox @@ -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 long integer + * asociated with a precision 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. + * + *
    + *
  • Unit::GetPrecision + *
  • Unit::GetMaximalPrecisionAllowed + *
  • Unit::SetPrecision + *
+ * + * + * \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)). + * + * Unit::GetResolution + * + * + * \section secUnitGrid Grid + * + *
    + *
  • Unit::GetGridStep + *
  • Unit::SetGridStep + *
  • Unit::IsOnGrid + *
  • Unit::GetOnGridUnit + *
+ * + * + * \section secUnitTranslators Translators + * + *
    + *
  • Unit::GetUnit + *
  • Unit::GetValue + *
  • Unit::GetValueString + *
+ */ + + + + /*! \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 \ allows to consider on grid only multiples of + * \c \ 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 \ equals + * 0, the closest inferior location on grid if the argument + * \c \ equals -1 and the closest superior location on grid + * if the argument \c \ equals +1. + * + * \remark Throw an exception for any other \c \ argument value. + */ + + /*! \function Unit GetUnit(double value); + * \Return the unit corresponding to the value \c \ according to + * the current precision. + */ + + /*! \function double GetValue(const Unit& unit); + * \Return the external value associated to the unit \c \ + * according to the current precision. + */ + + /*! \function string GetValueString(const Unit& unit); + * \Return a character string representing the external value of + * \c \. + * + * \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. + */ + + // \} + + } diff --git a/hurricane/doc/hurricane/UpdateSession.dox b/hurricane/doc/hurricane/UpdateSession.dox new file mode 100644 index 00000000..d0352579 --- /dev/null +++ b/hurricane/doc/hurricane/UpdateSession.dox @@ -0,0 +1,12 @@ + + // -*- C++ -*- + + + namespace Hurricane { + + /*! \class UpdateSession + * \brief UpdateSession description (\b API) + * + */ + + } diff --git a/hurricane/doc/hurricane/VectorCollection.dox b/hurricane/doc/hurricane/VectorCollection.dox new file mode 100644 index 00000000..9c365d07 --- /dev/null +++ b/hurricane/doc/hurricane/VectorCollection.dox @@ -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 VectorCollection as created by the generic + * function GetCollection(...) 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 + * + *
    + *
  • Hurricane::VectorCollection::GetCollection + *
  • Hurricane::VectorCollection::GetCollection + *
+ * + * + * \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 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 VectorCollection::GetCollection(const vector& elementVector); + * See below. + */ + + /*! \function GenericCollection VectorCollection::GetCollection(const vector* elementVector);; + * Ces deux fonctions récupèrent sous forme de collection + * générique liée à un VectorCollection le contenu d'un + * vecteur passée en argument. + * + * Those two function return into generic collection bound to a + * VectorCollection the content of the STL vector given + * in argument. + */ + + // \} + + } diff --git a/hurricane/doc/hurricane/Vertical.dox b/hurricane/doc/hurricane/Vertical.dox new file mode 100644 index 00000000..64348a4e --- /dev/null +++ b/hurricane/doc/hurricane/Vertical.dox @@ -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 \) on + * \c \, whose extremity lies (through an offset equal + * to \c \) on \c \, with layer + * \c \, located at abscissa \c \ and of width + * \c \. + * + * \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 \, located at abscissa \c \ and of width + * \c \. The differents extremities ordinates are given + * by \c \ and \c \. + * + * \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 \. + */ + + // \} + + + /*! \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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/View.dox b/hurricane/doc/hurricane/View.dox new file mode 100644 index 00000000..df2a2bd0 --- /dev/null +++ b/hurricane/doc/hurricane/View.dox @@ -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 + * screen coordinate system which references screen pixel + * locations, the cell coordinate system and the + * client coordinate system. 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 GetCenter(). + * + * \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 + * ShowGrid posts an overall update area only if the + * display has to be redrawn and the function Update() + * 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 + * Update() all the view will be redrawn. + */ + + /*! \function void View::Invalidate(const Box& area); + * Invalidates the client area defined by \c \, therefore + * at the next call upon Update() 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 Update() which doesn't + * execute useless refreshes and which updates only the drawing + * of invalidated areas, but sometimes a Refresh() 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 \ and \c \. + * 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 \ 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 _OnDrawGhost() 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 \ 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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/Warning.dox b/hurricane/doc/hurricane/Warning.dox new file mode 100644 index 00000000..8c12dd5e --- /dev/null +++ b/hurricane/doc/hurricane/Warning.dox @@ -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 WARNING instead of + * ERROR. + * + * \section secWarningNouveauxTypes Nouveaux types + * + * type: Warning::Inherit -\> 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. + */ + + // \} + + + + } diff --git a/hurricane/doc/hurricane/ZoomCommand.dox b/hurricane/doc/hurricane/ZoomCommand.dox new file mode 100644 index 00000000..38454863 --- /dev/null +++ b/hurricane/doc/hurricane/ZoomCommand.dox @@ -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 "Zoom" and is bound to the mouse + * left button. + * + * 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(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. + */ + + // \} + + + } diff --git a/hurricane/doc/hurricane/asimbook.cls b/hurricane/doc/hurricane/asimbook.cls new file mode 100644 index 00000000..54270780 --- /dev/null +++ b/hurricane/doc/hurricane/asimbook.cls @@ -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'. diff --git a/hurricane/doc/hurricane/customHierarchy.html b/hurricane/doc/hurricane/customHierarchy.html new file mode 100644 index 00000000..33927698 --- /dev/null +++ b/hurricane/doc/hurricane/customHierarchy.html @@ -0,0 +1,219 @@ + + + + + + Hurricane Documentation + + +

Hurricane Documentation

+
+ + + + + + + + + +
SummaryNamespacesClass HierarchyClassesMember Index
+
+
+
+ +

Hurricane Synthetic Class Hierarchy

+
+ +

The complete class hierarchy could be accessed here.

+

All the classes below are in the Hurricane namespace.

+

The inheritance tree has been splitted/simplificated.

+ Legend :
+ 
+      
+        
+        
+      
ClassA  ClassA is abstract
ClassB  ClassB is instanciable

+
+
+ +

Exceptions

+ + +
Exception
+ + + + +
Error
Warning
Interruption
+ +

Collections

+ + +
Collection< Type >
+ + + + + + + + +
GenericCollection< Type >
SubSetCollection< Type >
SubTypeCollection< SuperType, Type >
ListCollection< Type >
VectorCollection< Type >
MapCollection< Type >
SetCollection< Type >
+ +

Locators

+ + +
Locator< Type >
+ + +
GenericLocator< Type >
+ +

Filters

+ + +
Filter< Type >
+ + + +
GenericFilter< Type >
NotFilter< Type >
+ +

Common Objects

+ + + + + + + + +
Tabulation
Unit
Point
Box
Interval
Transformation
Name
+ +

Data Base Objects

+ + +
DBo
+ + + + +
DataBase
Technology
Layer
+ + + +
BasicLayer
CompositeLayer
+ + + + +
Library
Symbol
Entity
+ + + + +
Cell
Net
Go
+ + + +
Instance
Component
+ + + + +
Plug
Contact
Segment
+ + + +
Vertical
Horizontal
+ + +
Pad
+ + +
Rubber
+ + + +
Quark
View
+ + +
MainView
+ + +
Editor
+ + +
MapView
+ + +
Command
+ + + + +
ZoomCommand
SelectCommand
SelectNetCommand
+ +

Properties

+ + +
Property
+ + +
PrivateProperty
+ + + +
StandardPrivateProperty< Value >
Selector
+ + +
SharedProperty
+ + + +
StandardSharedProperty< Value >
Relation
+ + +
StandardRelation
+ + +
UpdateSession
+ +

Hooks

+ + +
Hook
+ + + + + +
Component::BodyHook
Component::AnchorHook
Component::SourceHook
Component::TargetHook
+ +

Pathes and Occurrences

+ + + +
Path
Occurrence
+ +

Fast Access Structures

+ + + +
Component::QuadTree
Component::Slice
+ + +
+ + + + + +
Customized Class HierarchyReturn to top of page
+ + + + + +
Hurricane DocumentationCopyright © 2000-2007 Bull S.A. All rights reserved
+ + diff --git a/hurricane/doc/hurricane/customSummary.html b/hurricane/doc/hurricane/customSummary.html new file mode 100644 index 00000000..0ddcfb02 --- /dev/null +++ b/hurricane/doc/hurricane/customSummary.html @@ -0,0 +1,65 @@ + + + + + + Hurricane Documentation + + +

Hurricane Documentation

+
+ + + + + + + + + +
SummaryNamespacesClass HierarchyClassesMember Index
+
+
+
+ + + +

Hurricane Concepts

+
+

The classical Doxygen class hierarchy could be accessed here.

+

API documentations

+ +

Extending Hurricane (internal)

+ + + +
+ + + + + +
Customized Concepts (a.k.a. modules)Return to top of page
+ + + + + +
Hurricane DocumentationCopyright © 2000-2007 Bull S.A. All rights reserved
+ + diff --git a/hurricane/doc/hurricane/doxyfile b/hurricane/doc/hurricane/doxyfile new file mode 100644 index 00000000..178ca5bc --- /dev/null +++ b/hurricane/doc/hurricane/doxyfile @@ -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=Returns:"\ + "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=STL" +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 diff --git a/hurricane/doc/hurricane/footer.html b/hurricane/doc/hurricane/footer.html new file mode 100644 index 00000000..e60172bd --- /dev/null +++ b/hurricane/doc/hurricane/footer.html @@ -0,0 +1,16 @@ +
+
+ + + + + +
Generated by doxygen $doxygenversion on $dateReturn to top of page
+ + + + + +
Hurricane DocumentationCopyright © 2000-2007 Bull S.A. All rights reserved
+ + diff --git a/hurricane/doc/hurricane/header.html b/hurricane/doc/hurricane/header.html new file mode 100644 index 00000000..0b392efb --- /dev/null +++ b/hurricane/doc/hurricane/header.html @@ -0,0 +1,23 @@ + + + + + Hurricane Documentation + + +

Hurricane Documentation

+
+ + + + + + + + + +
SummaryNamespacesClass HierarchyClassesMember Index
+
+
+
+ diff --git a/hurricane/doc/hurricane/header.tex b/hurricane/doc/hurricane/header.tex new file mode 100644 index 00000000..ec779312 --- /dev/null +++ b/hurricane/doc/hurricane/header.tex @@ -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} diff --git a/hurricane/doc/hurricane/html.entry b/hurricane/doc/hurricane/html.entry new file mode 100644 index 00000000..ae6f39d8 --- /dev/null +++ b/hurricane/doc/hurricane/html.entry @@ -0,0 +1 @@ +
  • Hurricane
    Fundamental C++ Database

    diff --git a/hurricane/doc/hurricane/images/DummyFig-1.fig b/hurricane/doc/hurricane/images/DummyFig-1.fig new file mode 100644 index 00000000..da66a163 --- /dev/null +++ b/hurricane/doc/hurricane/images/DummyFig-1.fig @@ -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 diff --git a/hurricane/doc/hurricane/images/DummyFig-1.pdf b/hurricane/doc/hurricane/images/DummyFig-1.pdf new file mode 100644 index 00000000..52f2a3f1 Binary files /dev/null and b/hurricane/doc/hurricane/images/DummyFig-1.pdf differ diff --git a/hurricane/doc/hurricane/images/DummyFig-1.png b/hurricane/doc/hurricane/images/DummyFig-1.png new file mode 100644 index 00000000..b47add20 Binary files /dev/null and b/hurricane/doc/hurricane/images/DummyFig-1.png differ diff --git a/hurricane/doc/hurricane/images/DummyFig-2.fig b/hurricane/doc/hurricane/images/DummyFig-2.fig new file mode 100644 index 00000000..77143572 --- /dev/null +++ b/hurricane/doc/hurricane/images/DummyFig-2.fig @@ -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 diff --git a/hurricane/doc/hurricane/images/DummyFig-2.pdf b/hurricane/doc/hurricane/images/DummyFig-2.pdf new file mode 100644 index 00000000..db853d08 Binary files /dev/null and b/hurricane/doc/hurricane/images/DummyFig-2.pdf differ diff --git a/hurricane/doc/hurricane/images/DummyFig-2.png b/hurricane/doc/hurricane/images/DummyFig-2.png new file mode 100644 index 00000000..cc00a7cc Binary files /dev/null and b/hurricane/doc/hurricane/images/DummyFig-2.png differ diff --git a/hurricane/doc/hurricane/images/Makefile.am b/hurricane/doc/hurricane/images/Makefile.am new file mode 100644 index 00000000..0ae0b32a --- /dev/null +++ b/hurricane/doc/hurricane/images/Makefile.am @@ -0,0 +1,4 @@ + + +EXTRA_DIST = DummyFig-1.fig \ + DummyFig-2.fig diff --git a/hurricane/doc/hurricane/images/Makefile.in b/hurricane/doc/hurricane/images/Makefile.in new file mode 100644 index 00000000..47667a40 --- /dev/null +++ b/hurricane/doc/hurricane/images/Makefile.in @@ -0,0 +1,327 @@ +# 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/images +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 = +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@ +EXTRA_DIST = DummyFig-1.fig \ + DummyFig-2.fig + +all: all-am + +.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/images/Makefile'; \ + cd $(top_srcdir) && \ + $(AUTOMAKE) --foreign documentation/hurricane/doc.new/images/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: +tags: TAGS +TAGS: + +ctags: CTAGS +CTAGS: + + +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 +check-am: all-am +check: check-am +all-am: Makefile +installdirs: +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +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: + +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-am + +clean-am: clean-generic clean-libtool mostlyclean-am + +distclean: distclean-am + -rm -f Makefile +distclean-am: clean-am distclean-generic distclean-libtool + +dvi: dvi-am + +dvi-am: + +html: html-am + +info: info-am + +info-am: + +install-data-am: + +install-exec-am: + +install-info: install-info-am + +install-man: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-generic mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-info-am + +.PHONY: all all-am check check-am clean clean-generic clean-libtool \ + distclean distclean-generic distclean-libtool distdir dvi \ + dvi-am html html-am info info-am install install-am \ + install-data install-data-am install-exec install-exec-am \ + install-info install-info-am install-man install-strip \ + installcheck installcheck-am installdirs maintainer-clean \ + maintainer-clean-generic mostlyclean mostlyclean-generic \ + mostlyclean-libtool pdf pdf-am ps ps-am uninstall uninstall-am \ + uninstall-info-am + +# 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: