jcarr
/
coriolis
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
coriolis/documentation/_build/html/PythonCpp/DBoStandalone.html

676 lines
51 KiB
HTML
Raw Blame History

<!DOCTYPE html>
<!--[if IE 8]><html class="no-js lt-ie9" lang="en" > <![endif]-->
<!--[if gt IE 8]><!--> <html class="no-js" lang="en" > <!--<![endif]-->
<head>
<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>3. Case 1 - DBo Derived, Standalone &mdash; Coriolis 2 documentation</title>
<link rel="stylesheet" href="../_static/SoC.css" type="text/css" />
<link rel="index" title="Index"
href="../genindex.html"/>
<link rel="search" title="Search" href="../search.html"/>
<link rel="top" title="Coriolis 2 documentation" href="../index.html"/>
<link rel="up" title="Hurricane Python/C++ API Tutorial" href="index.html"/>
<link rel="next" title="4. Case 2 - Hierarchy of DBo Derived Classes" href="DBoHierarchy.html"/>
<link rel="prev" title="2. Basic File Structure and CMake configuration" href="Configuration.html"/>
<script src="_static/js/modernizr.min.js"></script>
</head>
<body class="wy-body-for-nav" role="document">
<div class="wy-grid-for-nav">
<nav data-toggle="wy-nav-shift" class="wy-nav-side">
<div class="wy-side-nav-search">
<a href="../index.html" class="icon icon-home"> Coriolis
</a>
<div role="search">
<form id="rtd-search-form" class="wy-form" action="../search.html" method="get">
<input type="text" name="q" placeholder="Search docs" />
<input type="hidden" name="check_keywords" value="yes" />
<input type="hidden" name="area" value="default" />
</form>
</div>
</div>
<div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
<ul class="current">
<li class="toctree-l1"><a class="reference internal" href="../UsersGuide/index.html">Coriolis User&#8217;s Guide</a><ul>
<li class="toctree-l2"><a class="reference internal" href="../UsersGuide/LicenseCredits.html">Credits &amp; License</a></li>
<li class="toctree-l2"><a class="reference internal" href="../UsersGuide/Releases.html">Release Notes</a><ul>
<li class="toctree-l3"><a class="reference internal" href="../UsersGuide/Releases.html#release-1-0-1475">Release 1.0.1475</a></li>
<li class="toctree-l3"><a class="reference internal" href="../UsersGuide/Releases.html#release-1-0-1963">Release 1.0.1963</a></li>
<li class="toctree-l3"><a class="reference internal" href="../UsersGuide/Releases.html#release-1-0-2049">Release 1.0.2049</a></li>
<li class="toctree-l3"><a class="reference internal" href="../UsersGuide/Releases.html#release-v2-0-1">Release v2.0.1</a></li>
<li class="toctree-l3"><a class="reference internal" href="../UsersGuide/Releases.html#release-v2-1">Release v2.1</a></li>
<li class="toctree-l3"><a class="reference internal" href="../UsersGuide/Releases.html#release-v2-2"><strong>Release v2.2</strong></a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="../UsersGuide/Installation.html">Installation</a><ul>
<li class="toctree-l3"><a class="reference internal" href="../UsersGuide/Installation.html#fixed-directory-tree">Fixed Directory Tree</a></li>
<li class="toctree-l3"><a class="reference internal" href="../UsersGuide/Installation.html#building-coriolis">Building Coriolis</a><ul>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/Installation.html#building-the-devel-branch">Building the Devel Branch</a></li>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/Installation.html#additionnal-requirement-under-macos">Additionnal Requirement under <span class="sc">MacOS</span></a></li>
</ul>
</li>
<li class="toctree-l3"><a class="reference internal" href="../UsersGuide/Installation.html#packaging-coriolis">Packaging Coriolis</a></li>
<li class="toctree-l3"><a class="reference internal" href="../UsersGuide/Installation.html#hooking-up-into-alliance">Hooking up into <span class="sc">Alliance</span></a></li>
<li class="toctree-l3"><a class="reference internal" href="../UsersGuide/Installation.html#setting-up-the-environment-coriolisenv-py">Setting up the Environment (coriolisEnv.py)</a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="../UsersGuide/Configuration.html">Coriolis Configuration &amp; Initialisation</a><ul>
<li class="toctree-l3"><a class="reference internal" href="../UsersGuide/Configuration.html#general-software-architecture">General Software Architecture</a></li>
<li class="toctree-l3"><a class="reference internal" href="../UsersGuide/Configuration.html#first-stage-symbolic-technology-selection">First Stage: Symbolic Technology Selection</a></li>
<li class="toctree-l3"><a class="reference internal" href="../UsersGuide/Configuration.html#second-stage-technology-configuration-loading">Second Stage: Technology Configuration Loading</a></li>
<li class="toctree-l3"><a class="reference internal" href="../UsersGuide/Configuration.html#configuration-helpers">Configuration Helpers</a><ul>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/Configuration.html#alliance-helper"><span class="sc">Alliance</span> Helper</a></li>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/Configuration.html#tools-configuration-helpers">Tools Configuration Helpers</a></li>
</ul>
</li>
<li class="toctree-l3"><a class="reference internal" href="../UsersGuide/Configuration.html#hacking-the-configuration-files">Hacking the Configuration Files</a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="../UsersGuide/ViewerTools.html">CGT - The Graphical Interface</a><ul>
<li class="toctree-l3"><a class="reference internal" href="../UsersGuide/ViewerTools.html#viewer-tools">Viewer &amp; Tools</a><ul>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/ViewerTools.html#stratus-netlist-capture"><span class="sc">Stratus</span> Netlist Capture</a></li>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/ViewerTools.html#the-hurricane-data-base">The <span class="sc">Hurricane</span> Data-Base</a></li>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/ViewerTools.html#synthetizing-and-loading-a-design">Synthetizing and loading a design</a></li>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/ViewerTools.html#etesian-placer">Etesian &#8211; Placer</a></li>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/ViewerTools.html#knik-global-router">Knik &#8211; Global Router</a></li>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/ViewerTools.html#kite-detailed-router">Kite &#8211; Detailed Router</a></li>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/ViewerTools.html#executing-python-scripts-in-cgt">Executing Python Scripts in Cgt</a></li>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/ViewerTools.html#printing-snapshots">Printing &amp; Snapshots</a></li>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/ViewerTools.html#memento-of-shortcuts-in-graphic-mode">Memento of Shortcuts in Graphic Mode</a></li>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/ViewerTools.html#cgt-command-line-options">Cgt Command Line Options</a></li>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/ViewerTools.html#miscellaneous-settings">Miscellaneous Settings</a></li>
</ul>
</li>
<li class="toctree-l3"><a class="reference internal" href="../UsersGuide/ViewerTools.html#the-controller">The Controller</a><ul>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/ViewerTools.html#the-look-tab">The Look Tab</a></li>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/ViewerTools.html#the-filter-tab">The Filter Tab</a></li>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/ViewerTools.html#the-layers-go-tab">The Layers&amp;Go Tab</a></li>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/ViewerTools.html#the-netlist-tab">The Netlist Tab</a></li>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/ViewerTools.html#the-selection-tab">The Selection Tab</a></li>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/ViewerTools.html#the-inspector-tab">The Inspector Tab</a></li>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/ViewerTools.html#the-settings-tab">The Settings Tab</a></li>
</ul>
</li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="../UsersGuide/ScriptsPlugins.html">Python Interface for <span class="sc">Hurricane</span> / <span class="sc">Coriolis</span></a><ul>
<li class="toctree-l3"><a class="reference internal" href="../UsersGuide/ScriptsPlugins.html#plugins">Plugins</a><ul>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/ScriptsPlugins.html#chip-placement">Chip Placement</a></li>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/ScriptsPlugins.html#clock-tree">Clock Tree</a></li>
<li class="toctree-l4"><a class="reference internal" href="../UsersGuide/ScriptsPlugins.html#recursive-save-rsave">Recursive-Save (RSave)</a></li>
</ul>
</li>
<li class="toctree-l3"><a class="reference internal" href="../UsersGuide/ScriptsPlugins.html#a-simple-example-am2901">A Simple Example: AM2901</a></li>
</ul>
</li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="../Stratus/Stratus.html">Stratus Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../DpGen/DpGen.html">DpGen Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../Patterns/Patterns.html">Patterns Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../Hurricane/Hurricane.html">Hurricane Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../Viewer/Viewer.html">Viewer Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../CrlCore/CrlCore.html">CRL Core Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../Katabatic/Katabatic.html">Katabatic Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../Kite/Kite.html">Kite Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../Unicorn/Unicorn.html">Unicorn Reference</a></li>
<li class="toctree-l1 current"><a class="reference internal" href="index.html">Hurricane Python/C++ API Tutorial</a><ul class="current">
<li class="toctree-l2"><a class="reference internal" href="Introduction.html">1. Introduction</a><ul>
<li class="toctree-l3"><a class="reference internal" href="Introduction.html#first-a-disclaimer">1.1 First, A Disclaimer</a></li>
<li class="toctree-l3"><a class="reference internal" href="Introduction.html#about-technical-choices">1.2 About Technical Choices</a></li>
<li class="toctree-l3"><a class="reference internal" href="Introduction.html#botched-design">1.3 Botched Design</a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="Configuration.html">2. Basic File Structure and CMake configuration</a></li>
<li class="toctree-l2 current"><a class="current reference internal" href="#">3. Case 1 - DBo Derived, Standalone</a><ul>
<li class="toctree-l3"><a class="reference internal" href="#class-associated-header-file">3.1 Class Associated Header File</a></li>
<li class="toctree-l3"><a class="reference internal" href="#class-associated-file">3.2 Class Associated File</a><ul>
<li class="toctree-l4"><a class="reference internal" href="#head-of-the-file">3.2.1 Head of the file</a></li>
<li class="toctree-l4"><a class="reference internal" href="#the-python-module-part">3.2.2 The Python Module Part</a></li>
<li class="toctree-l4"><a class="reference internal" href="#python-type-linking">3.2.3 Python Type Linking</a></li>
<li class="toctree-l4"><a class="reference internal" href="#the-shared-library-part">3.2.4 The Shared Library Part</a></li>
</ul>
</li>
<li class="toctree-l3"><a class="reference internal" href="#python-module-c-namespace">3.3 Python Module (C++ namespace)</a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="DBoHierarchy.html">4. Case 2 - Hierarchy of DBo Derived Classes</a><ul>
<li class="toctree-l3"><a class="reference internal" href="DBoHierarchy.html#base-class-header">4.1 Base Class Header</a></li>
<li class="toctree-l3"><a class="reference internal" href="DBoHierarchy.html#base-class-file">4.2 Base Class File</a></li>
<li class="toctree-l3"><a class="reference internal" href="DBoHierarchy.html#intermediate-class-header">4.3 Intermediate Class Header</a></li>
<li class="toctree-l3"><a class="reference internal" href="DBoHierarchy.html#intermediate-class-file">4.4 Intermediate Class File</a></li>
<li class="toctree-l3"><a class="reference internal" href="DBoHierarchy.html#terminal-class-header">4.5 Terminal Class Header</a></li>
<li class="toctree-l3"><a class="reference internal" href="DBoHierarchy.html#terminal-class-file">4.6 Terminal Class File</a></li>
<li class="toctree-l3"><a class="reference internal" href="DBoHierarchy.html#python-module">4.8 Python Module</a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="NonDBo.html">5. Case 3 - Non-DBo Standalone Classe</a><ul>
<li class="toctree-l3"><a class="reference internal" href="NonDBo.html#class-header">5.1 Class Header</a></li>
<li class="toctree-l3"><a class="reference internal" href="NonDBo.html#class-file">5.2 Class File</a></li>
<li class="toctree-l3"><a class="reference internal" href="NonDBo.html#id1">5.2 Class File</a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="DbU.html">6. Encapsulating DbU</a></li>
<li class="toctree-l2"><a class="reference internal" href="Name.html">7. No C++ Hurricane::Name encapsulation</a></li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="../RDS/index.html">Symbolic to Real Conversion in Alliance</a><ul>
<li class="toctree-l2"><a class="reference internal" href="../RDS/RDSpage.html">Symbolic Layout</a><ul>
<li class="toctree-l3"><a class="reference internal" href="../RDS/RDSpage.html#symbolic-components">Symbolic Components</a></li>
<li class="toctree-l3"><a class="reference internal" href="../RDS/RDSpage.html#symbolic-segments">Symbolic Segments</a></li>
</ul>
</li>
<li class="toctree-l2"><a class="reference internal" href="../RDS/RDSpage.html#the-rds-file">The RDS File</a><ul>
<li class="toctree-l3"><a class="reference internal" href="../RDS/RDSpage.html#physical-grid-lambda-value">Physical Grid &amp; Lambda Value</a></li>
<li class="toctree-l3"><a class="reference internal" href="../RDS/RDSpage.html#the-mbk-to-rds-segment-table">The <code class="docutils literal"><span class="pre">MBK_TO_RDS_SEGMENT</span></code> table</a></li>
<li class="toctree-l3"><a class="reference internal" href="../RDS/RDSpage.html#the-mbk-to-rds-via-table">The <code class="docutils literal"><span class="pre">MBK_TO_RDS_VIA</span></code> table</a></li>
<li class="toctree-l3"><a class="reference internal" href="../RDS/RDSpage.html#the-mbk-to-rds-bigvia-hole-table">The <code class="docutils literal"><span class="pre">MBK_TO_RDS_BIGVIA_HOLE</span></code> table</a></li>
<li class="toctree-l3"><a class="reference internal" href="../RDS/RDSpage.html#the-mbk-to-rds-bigvia-metal-table">The <code class="docutils literal"><span class="pre">MBK_TO_RDS_BIGVIA_METAL</span></code> table</a></li>
<li class="toctree-l3"><a class="reference internal" href="../RDS/RDSpage.html#the-mbk-wiresetting-table">The <code class="docutils literal"><span class="pre">MBK_WIRESETTING</span></code> table</a></li>
</ul>
</li>
</ul>
</li>
<li class="toctree-l1"><a class="reference internal" href="../lefapi/lefapi.html">LEF API Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../defapi/defapi.html">DEF API Reference</a></li>
<li class="toctree-l1"><a class="reference internal" href="../lefdef/lefdef.html">LEF/DEF Language Reference</a></li>
</ul>
</div>
&nbsp;
</nav>
<section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">
<nav class="wy-nav-top" role="navigation" aria-label="top navigation">
<i data-toggle="wy-nav-top" class="fa fa-bars"></i>
<a href="../index.html">Coriolis</a>
</nav>
<div class="wy-nav-content">
<div class="rst-content">
<div role="navigation" aria-label="breadcrumbs navigation">
<ul class="wy-breadcrumbs">
<li><a href="../index.html">Docs</a> &raquo;</li>
<li><a href="index.html">Hurricane Python/C++ API Tutorial</a> &raquo;</li>
<li>3. Case 1 - DBo Derived, Standalone</li>
<li class="wy-breadcrumbs-aside">
</li>
</ul>
<hr/>
</div>
<div role="main" class="document">
<div class="section" id="case-1-dbo-derived-standalone">
<h1>3. Case 1 - DBo Derived, Standalone<a class="headerlink" href="#case-1-dbo-derived-standalone" title="Permalink to this headline"></a></h1>
<p>As example, we take <code class="docutils literal"><span class="pre">Library</span></code>. This a <code class="docutils literal"><span class="pre">DBo</span></code> derived class, but we
choose not to export the parent classes. From Python, it will appear
as a base class.</p>
<div class="section" id="class-associated-header-file">
<span id="id1"></span><span id="id2"></span><h2>3.1 Class Associated Header File<a class="headerlink" href="#class-associated-header-file" title="Permalink to this headline"></a></h2>
<p>Here is the typical content of a header file (for <code class="docutils literal"><span class="pre">PyLibrary</span></code>):</p>
<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="cp">#ifndef PY_LIBRARY_H</span>
<span class="cp">#define PY_LIBRARY_H</span>
<span class="cp">#include</span> <span class="cpf">&quot;hurricane/isobar/PyHurricane.h&quot;</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">&quot;hurricane/Library.h&quot;</span><span class="cp"></span>
<span class="k">namespace</span> <span class="n">Isobar</span> <span class="p">{</span>
<span class="k">using</span> <span class="k">namespace</span> <span class="n">Hurricane</span><span class="p">;</span>
<span class="k">extern</span> <span class="s">&quot;C&quot;</span> <span class="p">{</span>
<span class="k">typedef</span> <span class="k">struct</span> <span class="p">{</span>
<span class="n">PyObject_HEAD</span>
<span class="n">Library</span><span class="o">*</span> <span class="n">_object</span><span class="p">;</span>
<span class="p">}</span> <span class="n">PyLibrary</span><span class="p">;</span>
<span class="k">extern</span> <span class="n">PyTypeObject</span> <span class="n">PyTypeLibrary</span><span class="p">;</span>
<span class="k">extern</span> <span class="n">PyMethodDef</span> <span class="n">PyLibrary_Methods</span><span class="p">[];</span>
<span class="k">extern</span> <span class="n">PyObject</span><span class="o">*</span> <span class="nf">PyLibrary_Link</span> <span class="p">(</span> <span class="n">Hurricane</span><span class="o">::</span><span class="n">Library</span><span class="o">*</span> <span class="n">lib</span> <span class="p">);</span>
<span class="k">extern</span> <span class="kt">void</span> <span class="nf">PyLibrary_LinkPyType</span> <span class="p">();</span>
<span class="cp">#define IsPyLibrary(v) ( (v)-&gt;ob_type == &amp;PyTypeLibrary )</span>
<span class="cp">#define PYLIBRARY(v) ( (PyLibrary*)(v) )</span>
<span class="cp">#define PYLIBRARY_O(v) ( PYLIBRARY(v)-&gt;_object )</span>
<span class="p">}</span> <span class="c1">// extern &quot;C&quot;.</span>
<span class="p">}</span> <span class="c1">// Isobar namespace.</span>
<span class="cp">#endif </span><span class="c1">// PY_LIBRARY_H</span>
</pre></div>
</div>
<p>The code is organized as follow:</p>
<ol class="arabic">
<li><p class="first">It must have, <em>as the first include</em> <code class="docutils literal"><span class="pre">PyHurricane.h</span></code>, which provides
the complete bunch of macros needed to build the module. Then the include
of the C++ class we want to wrap (<code class="docutils literal"><span class="pre">Library.h</span></code>).</p>
</li>
<li><p class="first">As Python is written in C, all the wrapper code has to be but inside
an <code class="docutils literal"><span class="pre">extern</span> <span class="pre">&quot;C&quot;</span></code> namespace.</p>
</li>
<li><p class="first">Definition of the wrapped <span class="cb">struct</span>, <code class="docutils literal"><span class="pre">PyLibrary</span></code>. It is standard Python here.</p>
<div class="admonition note">
<p class="first admonition-title">Note</p>
<p class="last">For our set of macros to work, the name of the pointer to the
C++ class must always be <strong>_object</strong>, and the various functions and
macros defined here must take the name of the class (either in
lowercase, camel case or capitals).</p>
</div>
</li>
<li><p class="first">Declaration of the Python type <code class="docutils literal"><span class="pre">PyTypeLibrary</span></code> (standard).</p>
</li>
<li><p class="first">Declaration of the Python type table of methods <code class="docutils literal"><span class="pre">PyLibrary_Methods</span></code> (standard).</p>
</li>
</ol>
<ol class="arabic simple" id="id3" start="6">
<li>Declaration of <code class="docutils literal"><span class="pre">PyLibrary_Link()</span></code>, helper to convert a C++ <code class="docutils literal"><span class="pre">Lybrary</span></code> into
a <code class="docutils literal"><span class="pre">PyLibrary</span></code> (put in the support shared library).</li>
<li>Declaration of <code class="docutils literal"><span class="pre">PyLibrary_LinkPyType()</span></code>, this function setup the class-level
function of the new Python type (here, <code class="docutils literal"><span class="pre">PyTypeLibrary</span></code>).</li>
<li>And, lastly, three macros to:<ul>
<li><code class="docutils literal"><span class="pre">IsPylibrary()</span></code>, know if a Python object is a <code class="docutils literal"><span class="pre">PyLibrary</span></code></li>
<li><code class="docutils literal"><span class="pre">PYLIBRARY()</span></code>, force cast (C style) of a <code class="docutils literal"><span class="pre">PyObject</span></code> into a <code class="docutils literal"><span class="pre">PyLibrary</span></code>.</li>
<li><code class="docutils literal"><span class="pre">PYLIBRARY_O()</span></code>, extract the C++ object (<code class="docutils literal"><span class="pre">Library*</span></code>) from the Python
object (<code class="docutils literal"><span class="pre">PyLibrary</span></code>).</li>
</ul>
</li>
</ol>
</div>
<div class="section" id="class-associated-file">
<span id="id4"></span><h2>3.2 Class Associated File<a class="headerlink" href="#class-associated-file" title="Permalink to this headline"></a></h2>
<div class="section" id="head-of-the-file">
<h3>3.2.1 Head of the file<a class="headerlink" href="#head-of-the-file" title="Permalink to this headline"></a></h3>
<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="cp">#include</span> <span class="cpf">&quot;hurricane/isobar/PyLibrary.h&quot;</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">&quot;hurricane/isobar/PyDataBase.h&quot;</span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf">&quot;hurricane/isobar/PyCell.h&quot;</span><span class="cp"></span>
<span class="k">namespace</span> <span class="n">Isobar</span> <span class="p">{</span>
<span class="k">using</span> <span class="k">namespace</span> <span class="n">Hurricane</span><span class="p">;</span>
<span class="k">extern</span> <span class="s">&quot;C&quot;</span> <span class="p">{</span>
<span class="cp">#define METHOD_HEAD(function) GENERIC_METHOD_HEAD(Library,lib,function)</span>
</pre></div>
</div>
<p>As for the header, all the code must be put inside a <code class="docutils literal"><span class="pre">extern</span> <span class="pre">&quot;C&quot;</span></code> namespace.</p>
<p>A convenience macro <code class="docutils literal"><span class="pre">METHOD_HEAD()</span></code> must be defined, by refining
<code class="docutils literal"><span class="pre">GENERIC_METHOD_HEAD()</span></code>. This macro will be used in the method wrappers
below to cast the <code class="docutils literal"><span class="pre">_object</span></code> field of the Python object into the
appropriate C++ class, this is done using a C-style cast.
The parameters of that macro are:</p>
<ol class="arabic simple">
<li>The C++ encapsulated class (<code class="docutils literal"><span class="pre">Library</span></code>).</li>
<li>The name of the <em>variable</em> that will be used to store a pointer
to the C++ working object.</li>
<li>The name of the C++ method which is to be wrapped.</li>
</ol>
</div>
<div class="section" id="the-python-module-part">
<h3>3.2.2 The Python Module Part<a class="headerlink" href="#the-python-module-part" title="Permalink to this headline"></a></h3>
<p>First, we have to build all the wrappers to the C++ methods of
the class. For common predicates, accessors, and mutators macros
are supplied.</p>
<p>Wrapping of the <code class="docutils literal"><span class="pre">Library::getCell()</span></code> method:</p>
<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">static</span> <span class="n">PyObject</span><span class="o">*</span> <span class="nf">PyLibrary_getCell</span> <span class="p">(</span> <span class="n">PyLibrary</span><span class="o">*</span> <span class="n">self</span><span class="p">,</span> <span class="n">PyObject</span><span class="o">*</span> <span class="n">args</span> <span class="p">)</span>
<span class="p">{</span>
<span class="n">Cell</span><span class="o">*</span> <span class="n">cell</span> <span class="o">=</span> <span class="nb">NULL</span><span class="p">;</span>
<span class="n">HTRY</span>
<span class="n">METHOD_HEAD</span><span class="p">(</span> <span class="s">&quot;Library.getCell()&quot;</span> <span class="p">)</span>
<span class="kt">char</span><span class="o">*</span> <span class="n">name</span> <span class="o">=</span> <span class="nb">NULL</span><span class="p">;</span>
<span class="k">if</span> <span class="p">(</span><span class="n">PyArg_ParseTuple</span><span class="p">(</span><span class="n">args</span><span class="p">,</span><span class="s">&quot;s:Library.getCell&quot;</span><span class="p">,</span> <span class="o">&amp;</span><span class="n">name</span><span class="p">))</span> <span class="p">{</span>
<span class="n">cell</span> <span class="o">=</span> <span class="n">lib</span><span class="o">-&gt;</span><span class="n">getCell</span><span class="p">(</span> <span class="n">Name</span><span class="p">(</span><span class="n">name</span><span class="p">)</span> <span class="p">);</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="n">PyErr_SetString</span><span class="p">(</span> <span class="n">ConstructorError</span>
<span class="p">,</span> <span class="s">&quot;invalid number of parameters for Library::getCell.&quot;</span> <span class="p">);</span>
<span class="k">return</span> <span class="nb">NULL</span><span class="p">;</span>
<span class="p">}</span>
<span class="n">HCATCH</span>
<span class="k">return</span> <span class="n">PyCell_Link</span><span class="p">(</span><span class="n">cell</span><span class="p">);</span>
<span class="p">}</span>
</pre></div>
</div>
<p>Key points about this method wrapper:</p>
<ol class="arabic simple">
<li>The <code class="docutils literal"><span class="pre">HTRY</span></code> / <code class="docutils literal"><span class="pre">HCATCH</span></code> macros provides an insulation from the C++
exceptions. If one is emitted, it will be catched and transformed in
a Python one. This way, the Python program will be cleanly interrupted
and the usual stack trace displayed.</li>
<li>The returned value of this method is of type <code class="docutils literal"><span class="pre">Cell*</span></code>, we have to
transform it into a Python one. This is done with <code class="docutils literal"><span class="pre">PyCell_Link()</span></code>.
This macro is supplied by the <code class="docutils literal"><span class="pre">PyCell.h</span></code> header and this is why
it must be included.</li>
</ol>
<p></p>
<p>Wrapping of the <code class="docutils literal"><span class="pre">Library::create()</span></code> method:</p>
<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="k">static</span> <span class="n">PyObject</span><span class="o">*</span> <span class="nf">PyLibrary_create</span><span class="p">(</span> <span class="n">PyObject</span><span class="o">*</span><span class="p">,</span> <span class="n">PyObject</span><span class="o">*</span> <span class="n">args</span> <span class="p">)</span>
<span class="p">{</span>
<span class="n">PyObject</span><span class="o">*</span> <span class="n">arg0</span><span class="p">;</span>
<span class="n">PyObject</span><span class="o">*</span> <span class="n">arg1</span><span class="p">;</span>
<span class="n">Library</span><span class="o">*</span> <span class="n">library</span> <span class="o">=</span> <span class="nb">NULL</span><span class="p">;</span>
<span class="n">HTRY</span>
<span class="n">__cs</span><span class="p">.</span><span class="n">init</span><span class="p">(</span> <span class="s">&quot;Library.create&quot;</span> <span class="p">);</span> <span class="c1">// Step (1).</span>
<span class="k">if</span> <span class="p">(</span><span class="n">not</span> <span class="n">PyArg_ParseTuple</span><span class="p">(</span> <span class="n">args</span><span class="p">,</span> <span class="s">&quot;O&amp;O&amp;:Library.create&quot;</span>
<span class="p">,</span> <span class="n">Converter</span><span class="p">,</span> <span class="o">&amp;</span><span class="n">arg0</span>
<span class="p">,</span> <span class="n">Converter</span><span class="p">,</span> <span class="o">&amp;</span><span class="n">arg1</span> <span class="p">))</span> <span class="p">{</span> <span class="c1">// Step (2).</span>
<span class="n">PyErr_SetString</span><span class="p">(</span> <span class="n">ConstructorError</span>
<span class="p">,</span> <span class="s">&quot;invalid number of parameters for Library constructor.&quot;</span> <span class="p">);</span>
<span class="k">return</span> <span class="nb">NULL</span><span class="p">;</span>
<span class="p">}</span>
<span class="k">if</span> <span class="p">(</span><span class="n">__cs</span><span class="p">.</span><span class="n">getObjectIds</span><span class="p">()</span> <span class="o">==</span> <span class="s">&quot;:db:string&quot;</span><span class="p">)</span> <span class="p">{</span> <span class="c1">// Step (3.a)</span>
<span class="n">DataBase</span><span class="o">*</span> <span class="n">db</span> <span class="o">=</span> <span class="n">PYDATABASE_O</span><span class="p">(</span><span class="n">arg0</span><span class="p">);</span>
<span class="n">library</span> <span class="o">=</span> <span class="n">Library</span><span class="o">::</span><span class="n">create</span><span class="p">(</span> <span class="n">db</span><span class="p">,</span> <span class="n">Name</span><span class="p">(</span><span class="n">PyString_AsString</span><span class="p">(</span><span class="n">arg1</span><span class="p">))</span> <span class="p">);</span>
<span class="p">}</span> <span class="k">else</span> <span class="k">if</span> <span class="p">(</span><span class="n">__cs</span><span class="p">.</span><span class="n">getObjectIds</span><span class="p">()</span> <span class="o">==</span> <span class="s">&quot;:library:string&quot;</span><span class="p">)</span> <span class="p">{</span> <span class="c1">// Step (3.b)</span>
<span class="n">Library</span><span class="o">*</span> <span class="n">masterLibrary</span> <span class="o">=</span> <span class="n">PYLIBRARY_O</span><span class="p">(</span><span class="n">arg0</span><span class="p">);</span>
<span class="n">library</span> <span class="o">=</span> <span class="n">Library</span><span class="o">::</span><span class="n">create</span><span class="p">(</span> <span class="n">masterLibrary</span><span class="p">,</span> <span class="n">Name</span><span class="p">(</span><span class="n">PyString_AsString</span><span class="p">(</span><span class="n">arg1</span><span class="p">))</span> <span class="p">);</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="n">PyErr_SetString</span><span class="p">(</span> <span class="n">ConstructorError</span>
<span class="p">,</span> <span class="s">&quot;invalid number of parameters for Library constructor.&quot;</span> <span class="p">);</span>
<span class="k">return</span> <span class="nb">NULL</span><span class="p">;</span>
<span class="p">}</span>
<span class="n">HCATCH</span>
<span class="k">return</span> <span class="n">PyLibrary_Link</span><span class="p">(</span> <span class="n">library</span> <span class="p">);</span>
<span class="p">}</span>
</pre></div>
</div>
<p>Key point about this constructor:</p>
<ol class="arabic simple">
<li>We want the Python interface to mimic as closely as possible the
C++ API. As such, Python object will be created using a static
<code class="docutils literal"><span class="pre">.create()</span></code> method. So we do not use the usual Python allocation
mechanism.</li>
<li>As it is a <em>static</em> method, there is no first argument.</li>
<li>Python do not allow function overload like C++. To emulate that
behavior we use the <code class="docutils literal"><span class="pre">__cs</span></code> object (which is a global variable).<ol class="arabic">
<li>Init/reset the <code class="docutils literal"><span class="pre">__cs</span></code> object: see <em>step (1)</em>.</li>
<li>Call <code class="docutils literal"><span class="pre">PyArg_ParseTuple()</span></code>, read every mandatory or optional
argument as a Python object (<code class="docutils literal"><span class="pre">&quot;O&amp;&quot;</span></code>) and use <code class="docutils literal"><span class="pre">Converter</span></code>
on each one. <code class="docutils literal"><span class="pre">Converter</span></code> will determine the real type of
the Python object given as argument by looking at the
encapsulated C++ class. It then update the <code class="docutils literal"><span class="pre">__cs</span></code> object.
Done in <em>step (2)</em></li>
<li>After the call to <code class="docutils literal"><span class="pre">PyArg_ParseTuple()</span></code>, the function
<code class="docutils literal"><span class="pre">__cs.getObjectIds()</span></code> will return the <em>signature</em> of
the various arguments. In our case, the valid signatures
will be <code class="docutils literal"><span class="pre">&quot;:db:string&quot;</span></code> (<em>step (3.a)*a) and ``&#8221;:library:string&#8221;``
(*step (3.b)</em>).</li>
<li>Call the C++ method after extracting the C++ objects from
the Python arguments. Note the use of the <code class="docutils literal"><span class="pre">PYLIBRARY_O()</span></code>
and <code class="docutils literal"><span class="pre">PYDATABSE_O()</span></code> macros to perform the conversion.</li>
</ol>
</li>
<li>Return the result, encapsulated through a call to <code class="docutils literal"><span class="pre">PyLibrary_Link()</span></code>.</li>
</ol>
<p></p>
<p>Wrapping of the <code class="docutils literal"><span class="pre">Library::destroy()</span></code> method:</p>
<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="n">DBoDestroyAttribute</span><span class="p">(</span><span class="n">PyLibrary_destroy</span><span class="p">,</span> <span class="n">PyLibrary</span><span class="p">)</span>
</pre></div>
</div>
<p>For C++ classes <strong>that are derived</strong> from <code class="docutils literal"><span class="pre">DBo</span></code>, the destroy method
wrapper must be defined using the macro <code class="docutils literal"><span class="pre">DBoDestroyAttribute()</span></code>.
This macro implements the bi-directional communication mechanism
using <code class="docutils literal"><span class="pre">Hurricane::Property</span></code>. It <strong>must not</strong> be used for
non <code class="docutils literal"><span class="pre">DBo</span></code> derived classes.</p>
<p>Defining the method table of the PyLibrary type:</p>
<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="n">PyMethodDef</span> <span class="n">PyLibrary_Methods</span><span class="p">[]</span> <span class="o">=</span>
<span class="p">{</span> <span class="p">{</span> <span class="s">&quot;create&quot;</span> <span class="p">,</span> <span class="p">(</span><span class="n">PyCFunction</span><span class="p">)</span><span class="n">PyLibrary_create</span> <span class="p">,</span> <span class="n">METH_VARARGS</span><span class="o">|</span><span class="n">METH_STATIC</span>
<span class="p">,</span> <span class="s">&quot;Creates a new library.&quot;</span> <span class="p">}</span>
<span class="p">,</span> <span class="p">{</span> <span class="s">&quot;getCell&quot;</span> <span class="p">,</span> <span class="p">(</span><span class="n">PyCFunction</span><span class="p">)</span><span class="n">PyLibrary_getCell</span><span class="p">,</span> <span class="n">METH_VARARGS</span>
<span class="p">,</span> <span class="s">&quot;Get the cell of name &lt;name&gt;&quot;</span> <span class="p">}</span>
<span class="p">,</span> <span class="p">{</span> <span class="s">&quot;destroy&quot;</span> <span class="p">,</span> <span class="p">(</span><span class="n">PyCFunction</span><span class="p">)</span><span class="n">PyLibrary_destroy</span><span class="p">,</span> <span class="n">METH_NOARGS</span>
<span class="p">,</span> <span class="s">&quot;Destroy associated hurricane object The python object remains.&quot;</span> <span class="p">}</span>
<span class="p">,</span> <span class="p">{</span><span class="nb">NULL</span><span class="p">,</span> <span class="nb">NULL</span><span class="p">,</span> <span class="mi">0</span><span class="p">,</span> <span class="nb">NULL</span><span class="p">}</span> <span class="cm">/* sentinel */</span>
<span class="p">};</span>
</pre></div>
</div>
<p>This is standard Python/C API. The name of the <code class="docutils literal"><span class="pre">PyMethodDef</span></code> table must be
named from the class: <code class="docutils literal"><span class="pre">PyLibrary_Methods</span></code>.</p>
</div>
<div class="section" id="python-type-linking">
<h3>3.2.3 Python Type Linking<a class="headerlink" href="#python-type-linking" title="Permalink to this headline"></a></h3>
<p>Defining the <code class="docutils literal"><span class="pre">PyTypeLibrary</span></code> class methods and the type linking function.</p>
<p>Those are the functions for the Python object itself to work, not the
wrapped method from the C++ class.</p>
<div class="admonition note">
<p class="first admonition-title">Note</p>
<p class="last">At this point we <strong>do not</strong> define the <code class="docutils literal"><span class="pre">PyTypeLibrary</span></code> itself.
Only it&#8217;s functions and a function to set them up <em>once</em> the
type will be defined.</p>
</div>
<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="n">DBoDeleteMethod</span><span class="p">(</span><span class="n">Library</span><span class="p">)</span>
<span class="n">PyTypeObjectLinkPyType</span><span class="p">(</span><span class="n">Library</span><span class="p">)</span>
</pre></div>
</div>
<p>The macro <code class="docutils literal"><span class="pre">DBoDeleteMethod()</span></code> define the function to delete a
<code class="docutils literal"><span class="pre">PyLibrary</span></code> <em>Python</em> object. Again, do not mistake it for the deletion
of the C++ class (implemented by <code class="docutils literal"><span class="pre">DBoDestroyAttribute()</span></code>).
Here again, <code class="docutils literal"><span class="pre">DBoDeleteMethod()</span></code> is specially tailored for
<code class="docutils literal"><span class="pre">DBo</span></code> derived classes.</p>
<p id="pylibrary-linkpytype">To define <code class="docutils literal"><span class="pre">PyLibrary_LinkPyType()</span></code>, use the <code class="docutils literal"><span class="pre">PyTypeObjectLinkPyType()</span></code>
macro. This macro is specific for <code class="docutils literal"><span class="pre">DBo</span></code> derived classes that are seen as
base classes under Python (i.e. we don&#8217;t bother exposing the base
class under Python). <code class="docutils literal"><span class="pre">PyLibrary_LinkPyType()</span></code> setup the class functions
in the <code class="docutils literal"><span class="pre">PyTypeLibrary</span></code> type object, it <strong>must</strong> be called in the
Python module this class is part of (in this case: <code class="docutils literal"><span class="pre">PyHurricane.cpp</span></code>).
This particular flavor of the macro <em>will define</em> and setup the
following class functions:</p>
<ul class="simple">
<li><code class="docutils literal"><span class="pre">PyTypeLibrary.tp_compare</span></code> (defined by the macro).</li>
<li><code class="docutils literal"><span class="pre">PyTypeLibrary.tp_repr</span></code> (defined by the macro).</li>
<li><code class="docutils literal"><span class="pre">PyTypeLibrary.tp_str</span></code> (defined by the macro).</li>
<li><code class="docutils literal"><span class="pre">PyTypeLibrary.tp_hash</span></code> (defined by the macro).</li>
<li><code class="docutils literal"><span class="pre">PyTypeLibrary.tp_methods</span></code> sets to the previously defined <code class="docutils literal"><span class="pre">PyLibrary_Methods</span></code> table.</li>
<li><code class="docutils literal"><span class="pre">PyTypeLibrary.tp_dealloc</span></code> is set to a function that <em>must</em> be named <code class="docutils literal"><span class="pre">PyLibrary_DeAlloc</span></code>,
this is what <code class="docutils literal"><span class="pre">DBoDeleteMethod</span></code> does. It is <em>not</em> done by <code class="docutils literal"><span class="pre">PyTypeObjectLinkPyType</span></code>.</li>
</ul>
<p>Defining the <code class="docutils literal"><span class="pre">PyTypeLibrary</span></code> type:</p>
</div>
<div class="section" id="the-shared-library-part">
<h3>3.2.4 The Shared Library Part<a class="headerlink" href="#the-shared-library-part" title="Permalink to this headline"></a></h3>
<p>This part will be put in a separate supporting shared library, allowing
other Python module to link against it (and make use of its symbols).</p>
<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="n">DBoLinkCreateMethod</span><span class="p">(</span><span class="n">Library</span><span class="p">)</span>
<span class="n">PyTypeObjectDefinitions</span><span class="p">(</span><span class="n">Library</span><span class="p">)</span>
</pre></div>
</div>
<p>To define <code class="docutils literal"><span class="pre">PyTypeLibrary</span></code>, use the <code class="docutils literal"><span class="pre">PyTypeObjectDefinitions()</span></code> macro.
This macro is specific for classes that, as exposed by Python,
are neither <em>derived</em> classes nor <em>base</em> classes for others.
That is, they are standalone from the inheritance point of view.</p>
<p>The <code class="docutils literal"><span class="pre">DBoLinkCreateMethod()</span></code> macro will define the <code class="docutils literal"><span class="pre">PyLibrary_Link()</span></code>
function which is responsible for encapsulating a C++ <code class="docutils literal"><span class="pre">Library</span></code> object
into a Python <code class="docutils literal"><span class="pre">PyLibrary</span></code> one.</p>
</div>
</div>
<div class="section" id="python-module-c-namespace">
<h2>3.3 Python Module (C++ namespace)<a class="headerlink" href="#python-module-c-namespace" title="Permalink to this headline"></a></h2>
<p>We use the Python module to replicate the C++ <em>namespace</em>. Thus, for the
<code class="docutils literal"><span class="pre">Hurricane</span></code> namespace we create a Python <code class="docutils literal"><span class="pre">Hurricane</span></code> module which is
defined in the <code class="docutils literal"><span class="pre">PyHurricane.cpp</span></code> file, then we add into that module
dictionary all the Python types encapsulating the C++ classes of that
namespace.</p>
<div class="highlight-c++"><div class="highlight"><pre><span></span><span class="n">DL_EXPORT</span><span class="p">(</span><span class="kt">void</span><span class="p">)</span> <span class="n">initHurricane</span> <span class="p">()</span>
<span class="p">{</span>
<span class="n">PyLibrary_LinkPyType</span><span class="p">();</span> <span class="c1">// step 1.</span>
<span class="n">PYTYPE_READY</span><span class="p">(</span> <span class="n">Library</span> <span class="p">)</span> <span class="c1">// step 2.</span>
<span class="n">__cs</span><span class="p">.</span><span class="n">addType</span><span class="p">(</span> <span class="s">&quot;library&quot;</span><span class="p">,</span> <span class="o">&amp;</span><span class="n">PyTypeLibrary</span><span class="p">,</span> <span class="s">&quot;&lt;Library&gt;&quot;</span><span class="p">,</span> <span class="nb">false</span> <span class="p">);</span> <span class="c1">// step 3.</span>
<span class="n">PyObject</span><span class="o">*</span> <span class="n">module</span> <span class="o">=</span> <span class="n">Py_InitModule</span><span class="p">(</span> <span class="s">&quot;Hurricane&quot;</span><span class="p">,</span> <span class="n">PyHurricane_Methods</span> <span class="p">);</span>
<span class="k">if</span> <span class="p">(</span><span class="n">module</span> <span class="o">==</span> <span class="nb">NULL</span><span class="p">)</span> <span class="p">{</span>
<span class="n">cerr</span> <span class="o">&lt;&lt;</span> <span class="s">&quot;[ERROR]</span><span class="se">\n</span><span class="s">&quot;</span>
<span class="o">&lt;&lt;</span> <span class="s">&quot; Failed to initialize Hurricane module.&quot;</span> <span class="o">&lt;&lt;</span> <span class="n">endl</span><span class="p">;</span>
<span class="k">return</span><span class="p">;</span>
<span class="p">}</span>
<span class="n">Py_INCREF</span><span class="p">(</span> <span class="o">&amp;</span><span class="n">PyTypeLibrary</span> <span class="p">);</span> <span class="c1">// step 4.</span>
<span class="n">PyModule_AddObject</span><span class="p">(</span> <span class="n">module</span><span class="p">,</span> <span class="s">&quot;Library&quot;</span><span class="p">,</span> <span class="p">(</span><span class="n">PyObject</span><span class="o">*</span><span class="p">)</span><span class="o">&amp;</span><span class="n">PyTypeLibrary</span> <span class="p">);</span> <span class="c1">// step 4.</span>
<span class="p">}</span>
</pre></div>
</div>
<p>The <code class="docutils literal"><span class="pre">initHurricane()</span></code> initialisation function shown above has
been scrubbed of everything not relevant to the <code class="docutils literal"><span class="pre">PyLibrary</span></code> class.
The integration of the <code class="docutils literal"><span class="pre">PyLibrary</span></code> class into the module needs
four steps:</p>
<ol class="arabic">
<li><p class="first">A call to <a class="reference internal" href="#pylibrary-linkpytype">PyLibrary_LinkPyType()</a> to hook the Python type functions
in the Python type object.</p>
</li>
<li><p class="first">A call to the <code class="docutils literal"><span class="pre">PYTYPE_READY()</span></code> macro (standard Python).</p>
</li>
<li><p class="first">Registering the type into the <code class="docutils literal"><span class="pre">__cs</span></code> object, with <code class="docutils literal"><span class="pre">addType()</span></code>.
The arguments are self explanatory, save for the last which is a
boolean to tell if this is a <em>derived</em> class or not.</p>
</li>
<li><p class="first">Adding the type object (<code class="docutils literal"><span class="pre">PyTypeLibrary</span></code>) into the dictionnary of
the module itself. This allow to mimic closely the C++ syntax:</p>
<div class="highlight-python"><div class="highlight"><pre><span></span><span class="kn">import</span> <span class="nn">Hurricane</span>
<span class="n">lib</span> <span class="o">=</span> <span class="n">Hurricane</span><span class="o">.</span><span class="n">Library</span><span class="o">.</span><span class="n">create</span><span class="p">(</span> <span class="n">db</span><span class="p">,</span> <span class="s1">&#39;root&#39;</span> <span class="p">)</span>
</pre></div>
</div>
</li>
</ol>
</div>
</div>
</div>
<footer>
<div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
<a href="DBoHierarchy.html" class="btn btn-neutral float-right" title="4. Case 2 - Hierarchy of DBo Derived Classes" accesskey="n">Next <span class="fa fa-arrow-circle-right"></span></a>
<a href="Configuration.html" class="btn btn-neutral" title="2. Basic File Structure and CMake configuration" accesskey="p"><span class="fa fa-arrow-circle-left"></span> Previous</a>
</div>
<hr/>
<div role="contentinfo">
<table class="footer1">
<tr>
<td class="LFooter"><small>
Generated by <a href="http://sphinx-doc.org/">Sphinx</a>
using a <a href="https://readthedocs.org">RTD</a> theme on Oct 30, 2017.
</small></td>
<td class="RFooter"></td>
</tr>
</table>
<table class="footer2">
<tr>
<td class="LFooter">Coriolis 2 Documentation</td>
<td class="RFooter"><small>
&copy; Copyright 2000-2017, UPMC.
</small></td>
</tr>
</table>
</div>
</footer>
</div>
</div>
</section>
</div>
<script type="text/javascript">
var DOCUMENTATION_OPTIONS = {
URL_ROOT:'../',
VERSION:'2',
COLLAPSE_INDEX:false,
FILE_SUFFIX:'.html',
HAS_SOURCE: true
};
</script>
<script type="text/javascript" src="../_static/jquery.js"></script>
<script type="text/javascript" src="../_static/underscore.js"></script>
<script type="text/javascript" src="../_static/doctools.js"></script>
<script type="text/javascript" src="../_static/js/theme.js"></script>
<script type="text/javascript">
jQuery(function () {
SphinxRtdTheme.StickyNav.enable();
});
</script>
</body>
</html>
Reference in New Issue View Git Blame Copy Permalink