ceph/src/boost/libs/icl/doc/html/boost_icl/interface/required_concepts.html

   1 <html>
   2 <head>
   3 <meta http-equiv="Content-Type" content="text/html; charset=US-ASCII">
   4 <title>Required Concepts</title>
   5 <link rel="stylesheet" href="../../../../../../doc/src/boostbook.css" type="text/css">
   6 <meta name="generator" content="DocBook XSL Stylesheets V1.74.0">
   7 <link rel="home" href="../../index.html" title="Chapter&#160;1.&#160;Boost.Icl">
   8 <link rel="up" href="../interface.html" title="Interface">
   9 <link rel="prev" href="../interface.html" title="Interface">
  10 <link rel="next" href="associated_types.html" title="Associated Types">
  11 </head>
  12 <body bgcolor="white" text="black" link="#0000FF" vlink="#840084" alink="#0000FF">
  13 <table cellpadding="2" width="100%"><tr>
  14 <td valign="top"><img alt="Boost C++ Libraries" width="277" height="86" src="../../../../../../boost.png"></td>
  15 <td align="center"><a href="../../../../../../index.html">Home</a></td>
  16 <td align="center"><a href="../../../../../libraries.htm">Libraries</a></td>
  17 <td align="center"><a href="http://www.boost.org/users/people.html">People</a></td>
  18 <td align="center"><a href="http://www.boost.org/users/faq.html">FAQ</a></td>
  19 <td align="center"><a href="../../../../../../more/index.htm">More</a></td>
  20 </tr></table>
  21 <hr>
  22 <div class="spirit-nav">
  23 <a accesskey="p" href="../interface.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../interface.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="associated_types.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
  24 </div>
  25 <div class="section boost_icl_interface_required_concepts" lang="en">
  26 <div class="titlepage"><div><div><h3 class="title">
  27 <a name="boost_icl.interface.required_concepts"></a><a class="link" href="required_concepts.html" title="Required Concepts">Required Concepts</a>
  28 </h3></div></div></div>
  29 <p>
  30         There are uniform requirements for the template parameters across <span class="bold"><strong>icl's</strong></span> class templates. The template parameters can
  31         be grouped with respect to those requirements.
  32       </p>
  33 <div class="informaltable"><table class="table">
  34 <colgroup>
  35 <col>
  36 <col>
  37 <col>
  38 <col>
  39 <col>
  40 <col>
  41 </colgroup>
  42 <thead><tr>
  43 <th>
  44               <p>
  45               </p>
  46               </th>
  47 <th>
  48               <p>
  49                 used in
  50               </p>
  51               </th>
  52 <th>
  53               <p>
  54                 Kind
  55               </p>
  56               </th>
  57 <th>
  58               <p>
  59                 Parameter
  60               </p>
  61               </th>
  62 <th>
  63               <p>
  64                 Instance
  65               </p>
  66               </th>
  67 <th>
  68               <p>
  69                 Description
  70               </p>
  71               </th>
  72 </tr></thead>
  73 <tbody>
  74 <tr>
  75 <td>
  76               <p>
  77                 Domain order
  78               </p>
  79               </td>
  80 <td>
  81               <p>
  82                 <code class="computeroutput"><span class="identifier">Intervals</span><span class="special">,</span>
  83                 <span class="identifier">Sets</span><span class="special">,</span>
  84                 <span class="identifier">Maps</span></code>
  85               </p>
  86               </td>
  87 <td>
  88               <p>
  89                 <code class="computeroutput"><span class="keyword">typename</span></code>
  90               </p>
  91               </td>
  92 <td>
  93               <p>
  94                 <code class="computeroutput"><span class="identifier">DomainT</span></code>
  95               </p>
  96               </td>
  97 <td>
  98               <p>
  99               </p>
 100               </td>
 101 <td>
 102               <p>
 103                 For the type <code class="computeroutput"><span class="identifier">DomainT</span></code>
 104                 of key elements <code class="computeroutput"><span class="special">...</span></code>
 105               </p>
 106               </td>
 107 </tr>
 108 <tr>
 109 <td>
 110               <p>
 111               </p>
 112               </td>
 113 <td>
 114               <p>
 115               </p>
 116               </td>
 117 <td>
 118               <p>
 119                 <code class="computeroutput"><span class="keyword">template</span></code>
 120               </p>
 121               </td>
 122 <td>
 123               <p>
 124                 <code class="computeroutput"><span class="identifier">Compare</span></code>
 125               </p>
 126               </td>
 127 <td>
 128               <p>
 129                 <code class="computeroutput"><span class="identifier">Compare</span><span class="special">&lt;</span><span class="identifier">DomainT</span><span class="special">&gt;</span></code>
 130               </p>
 131               </td>
 132 <td>
 133               <p>
 134                 <code class="computeroutput"><span class="special">...</span></code> there is an order
 135                 <code class="computeroutput"><span class="identifier">Compare</span></code>
 136               </p>
 137               </td>
 138 </tr>
 139 <tr>
 140 <td>
 141               <p>
 142                 Interval type
 143               </p>
 144               </td>
 145 <td>
 146               <p>
 147                 <code class="computeroutput"><span class="identifier">interval_sets</span><span class="special">/</span><span class="identifier">maps</span></code>
 148               </p>
 149               </td>
 150 <td>
 151               <p>
 152                 <code class="computeroutput"><span class="keyword">typename</span></code>
 153               </p>
 154               </td>
 155 <td>
 156               <p>
 157                 <code class="computeroutput"><span class="identifier">IntervalT</span></code>
 158               </p>
 159               </td>
 160 <td>
 161               <p>
 162               </p>
 163               </td>
 164 <td>
 165               <p>
 166                 <code class="computeroutput"><span class="special">...</span></code> the <code class="computeroutput"><span class="identifier">IntervalT</span></code> parameter has to use
 167                 the same element type and order.
 168               </p>
 169               </td>
 170 </tr>
 171 <tr>
 172 <td>
 173               <p>
 174                 Codomain aggregation
 175               </p>
 176               </td>
 177 <td>
 178               <p>
 179                 <code class="computeroutput"><span class="identifier">Maps</span></code>
 180               </p>
 181               </td>
 182 <td>
 183               <p>
 184                 <code class="computeroutput"><span class="keyword">typename</span></code>
 185               </p>
 186               </td>
 187 <td>
 188               <p>
 189                 <code class="computeroutput"><span class="identifier">CodomainT</span></code>
 190               </p>
 191               </td>
 192 <td>
 193               <p>
 194               </p>
 195               </td>
 196 <td>
 197               <p>
 198                 For the type <code class="computeroutput"><span class="identifier">CodomainT</span></code>
 199                 of associated values <code class="computeroutput"><span class="special">...</span></code>
 200               </p>
 201               </td>
 202 </tr>
 203 <tr>
 204 <td>
 205               <p>
 206               </p>
 207               </td>
 208 <td>
 209               <p>
 210               </p>
 211               </td>
 212 <td>
 213               <p>
 214                 <code class="computeroutput"><span class="keyword">template</span></code>
 215               </p>
 216               </td>
 217 <td>
 218               <p>
 219                 <code class="computeroutput"><span class="identifier">Combine</span></code>
 220               </p>
 221               </td>
 222 <td>
 223               <p>
 224                 <code class="computeroutput"><span class="identifier">Combine</span><span class="special">&lt;</span><span class="identifier">CodomainT</span><span class="special">&gt;</span></code>
 225               </p>
 226               </td>
 227 <td>
 228               <p>
 229                 <code class="computeroutput"><span class="special">...</span></code> there is a binary
 230                 functor <code class="computeroutput"><span class="identifier">Combine</span><span class="special">&lt;</span><span class="identifier">CodomainT</span><span class="special">&gt;()</span></code>
 231                 to combine them
 232               </p>
 233               </td>
 234 </tr>
 235 <tr>
 236 <td>
 237               <p>
 238               </p>
 239               </td>
 240 <td>
 241               <p>
 242               </p>
 243               </td>
 244 <td>
 245               <p>
 246               </p>
 247               </td>
 248 <td>
 249               <p>
 250               </p>
 251               </td>
 252 <td>
 253               <p>
 254                 <code class="computeroutput"><span class="identifier">Inverse</span><span class="special">&lt;</span><span class="identifier">Combine</span><span class="special">&lt;</span><span class="identifier">CodomainT</span><span class="special">&gt;&gt;</span></code>
 255               </p>
 256               </td>
 257 <td>
 258               <p>
 259                 <code class="computeroutput"><span class="special">...</span></code> and implicitly an
 260                 <code class="computeroutput"><span class="identifier">Inverse</span></code> functor to
 261                 inversely combine them.
 262               </p>
 263               </td>
 264 </tr>
 265 <tr>
 266 <td>
 267               <p>
 268               </p>
 269               </td>
 270 <td>
 271               <p>
 272               </p>
 273               </td>
 274 <td>
 275               <p>
 276                 <code class="computeroutput"><span class="keyword">template</span></code>
 277               </p>
 278               </td>
 279 <td>
 280               <p>
 281                 <code class="computeroutput"><span class="identifier">Section</span></code>
 282               </p>
 283               </td>
 284 <td>
 285               <p>
 286                 <code class="computeroutput"><span class="identifier">Section</span><span class="special">&lt;</span><span class="identifier">CodomainT</span><span class="special">&gt;</span></code>
 287               </p>
 288               </td>
 289 <td>
 290               <p>
 291                 Intersection is propagated to CodomainT values via functor <code class="computeroutput"><span class="identifier">Section</span><span class="special">&lt;</span><span class="identifier">CodomainT</span><span class="special">&gt;()</span></code>
 292               </p>
 293               </td>
 294 </tr>
 295 <tr>
 296 <td>
 297               <p>
 298                 Memory allocation
 299               </p>
 300               </td>
 301 <td>
 302               <p>
 303                 <code class="computeroutput"><span class="identifier">Sets</span><span class="special">,</span>
 304                 <span class="identifier">Maps</span></code>
 305               </p>
 306               </td>
 307 <td>
 308               <p>
 309                 <code class="computeroutput"><span class="keyword">template</span></code>
 310               </p>
 311               </td>
 312 <td>
 313               <p>
 314                 <code class="computeroutput"><span class="identifier">Alloc</span></code>
 315               </p>
 316               </td>
 317 <td>
 318               <p>
 319                 <code class="computeroutput"><span class="identifier">Alloc</span><span class="special">&lt;</span></code><span class="emphasis"><em>various</em></span><code class="computeroutput"><span class="special">&gt;</span></code>
 320               </p>
 321               </td>
 322 <td>
 323               <p>
 324                 An allocator can be chosen for memory allocation.
 325               </p>
 326               </td>
 327 </tr>
 328 </tbody>
 329 </table></div>
 330 <a name="boost_icl.interface.required_concepts.requirements_on_domaint"></a><h5>
 331 <a name="id1107523"></a>
 332         <a class="link" href="required_concepts.html#boost_icl.interface.required_concepts.requirements_on_domaint">Requirements
 333         on DomainT</a>
 334       </h5>
 335 <p>
 336         The next table gives an overview over the requirements for template parameter
 337         <code class="computeroutput"><span class="identifier">DomainT</span></code>. Some requirements
 338         are dependent on <span class="emphasis"><em>conditions</em></span>. Column <span class="emphasis"><em>operators</em></span>
 339         shows the operators and functions that are expected for <code class="computeroutput"><span class="identifier">DomainT</span></code>,
 340         if the default order <code class="computeroutput"><span class="identifier">Compare</span> <span class="special">=</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">less</span></code> is used.
 341       </p>
 342 <div class="informaltable"><table class="table">
 343 <colgroup>
 344 <col>
 345 <col>
 346 <col>
 347 <col>
 348 </colgroup>
 349 <thead><tr>
 350 <th>
 351               <p>
 352                 Parameter
 353               </p>
 354               </th>
 355 <th>
 356               <p>
 357                 Condition
 358               </p>
 359               </th>
 360 <th>
 361               <p>
 362                 Operators
 363               </p>
 364               </th>
 365 <th>
 366               <p>
 367                 Requirement
 368               </p>
 369               </th>
 370 </tr></thead>
 371 <tbody>
 372 <tr>
 373 <td>
 374               <p>
 375                 <code class="computeroutput"><span class="identifier">DomainT</span></code>
 376               </p>
 377               </td>
 378 <td>
 379               <p>
 380               </p>
 381               </td>
 382 <td>
 383               <p>
 384                 <code class="computeroutput"><span class="identifier">DomainT</span><span class="special">(),</span>
 385                 <span class="special">&lt;</span></code>
 386               </p>
 387               </td>
 388 <td>
 389               <p>
 390                 <code class="computeroutput"><span class="identifier">Regular</span><span class="special">&lt;</span><span class="identifier">DomainT</span><span class="special">&gt;</span>
 391                 <span class="special">&amp;&amp;</span> <span class="identifier">StrictWeakOrdering</span><span class="special">&lt;</span><span class="identifier">DomainT</span><span class="special">,</span><span class="identifier">Compare</span><span class="special">&gt;</span></code>
 392               </p>
 393               </td>
 394 </tr>
 395 <tr>
 396 <td>
 397               <p>
 398               </p>
 399               </td>
 400 <td>
 401               <p>
 402               </p>
 403               </td>
 404 <td>
 405               <p>
 406                 <code class="computeroutput"><span class="special">++,</span> <span class="identifier">unit_element</span><span class="special">&lt;</span><span class="identifier">CodomainT</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">()</span></code>
 407               </p>
 408               </td>
 409 <td>
 410               <p>
 411                 <code class="computeroutput"><span class="special">&amp;&amp;</span> <span class="special">(</span><span class="identifier">IsIncrementable</span><span class="special">&lt;</span><span class="identifier">DomainT</span><span class="special">&gt;||</span><span class="identifier">HasUnitElement</span><span class="special">&lt;</span><span class="identifier">DomainT</span><span class="special">&gt;)</span></code>
 412               </p>
 413               </td>
 414 </tr>
 415 <tr>
 416 <td>
 417               <p>
 418               </p>
 419               </td>
 420 <td>
 421               <p>
 422                 <code class="computeroutput"><span class="identifier">IsIntegral</span><span class="special">&lt;</span><span class="identifier">DomainT</span><span class="special">&gt;</span></code>
 423               </p>
 424               </td>
 425 <td>
 426               <p>
 427                 <code class="computeroutput"><span class="special">++,</span> <span class="special">--</span></code>
 428               </p>
 429               </td>
 430 <td>
 431               <p>
 432                 <code class="computeroutput"><span class="identifier">IsIncrementable</span><span class="special">&lt;</span><span class="identifier">DomainT</span><span class="special">&gt;</span>
 433                 <span class="special">&amp;&amp;</span> <span class="identifier">IsDecrementable</span><span class="special">&lt;</span><span class="identifier">DomainT</span><span class="special">&gt;</span></code>
 434               </p>
 435               </td>
 436 </tr>
 437 </tbody>
 438 </table></div>
 439 <p>
 440         A domain type <code class="computeroutput"><span class="identifier">DomainT</span></code> for
 441         intervals and interval containers has to satisfy the requirements of concept
 442         <a href="http://www.informit.com/guides/content.aspx?g=cplusplus&amp;seqNum=314" target="_top"><code class="computeroutput"><span class="identifier">Regular</span></code></a> which implies among other
 443         properties the existence of a copy and a default constructor. In addition
 444         <code class="computeroutput"><span class="identifier">IsIncrementable</span></code> <span class="bold"><strong>or</strong></span> <code class="computeroutput"><span class="identifier">HasUnitElement</span></code>
 445         is required for <code class="computeroutput"><span class="identifier">DomainT</span></code>.
 446         In the <span class="bold"><strong>icl</strong></span> we represent an empty closed
 447         interval as interval <code class="computeroutput"><span class="special">[</span><span class="identifier">b</span><span class="special">,</span><span class="identifier">a</span><span class="special">]</span></code>
 448         where <code class="computeroutput"><span class="identifier">a</span> <span class="special">&lt;</span>
 449         <span class="identifier">b</span></code> (here <code class="computeroutput"><span class="special">&lt;</span></code>
 450         represents <code class="computeroutput"><span class="identifier">Compare</span><span class="special">&lt;</span><span class="identifier">DomainT</span><span class="special">&gt;()</span></code>).
 451         To construct one of these empty intervals as default constructor for any
 452         type <code class="computeroutput"><span class="identifier">DomainT</span></code> we choose <code class="computeroutput"><span class="special">[</span><span class="number">1</span><span class="special">,</span><span class="number">0</span><span class="special">]</span></code>, where
 453         <code class="computeroutput"><span class="number">0</span></code> is a null-value or <code class="computeroutput"><span class="identifier">identity_element</span></code> and <code class="computeroutput"><span class="number">1</span></code>
 454         is a one-value or <code class="computeroutput"><span class="identifier">unit_element</span></code>:
 455
 456 </p>
 457 <pre class="programlisting"><span class="identifier">interval</span><span class="special">()</span> <span class="special">:=</span> <span class="special">[</span><span class="identifier">unit_element</span><span class="special">&lt;</span><span class="identifier">DomainT</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">(),</span> <span class="identifier">identity_element</span><span class="special">&lt;</span><span class="identifier">DomainT</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">()]</span> <span class="comment">//pseudocode
 458 </span></pre>
 459 <p>
 460         <code class="computeroutput"><span class="identifier">Identity_elements</span></code> are implemented
 461         via call of the default constructor of <code class="computeroutput"><span class="identifier">DomainT</span></code>.
 462         A <code class="computeroutput"><span class="identifier">unit_element</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">()</span></code>
 463         is implemented <code class="computeroutput">by default</code>
 464         as a <code class="computeroutput"><span class="identifier">identity_element</span></code>, that
 465         is incremented once.
 466 </p>
 467 <pre class="programlisting"><span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">class</span> <span class="identifier">Type</span><span class="special">&gt;</span>
 468 <span class="keyword">inline</span> <span class="identifier">Type</span> <span class="identifier">unit_element</span><span class="special">&lt;</span><span class="identifier">Type</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">(){</span> <span class="keyword">return</span> <span class="identifier">succ</span><span class="special">(</span><span class="identifier">identity_element</span><span class="special">&lt;</span><span class="identifier">Type</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">());</span> <span class="special">};</span>
 469 </pre>
 470 <p>
 471         So a type <code class="computeroutput"><span class="identifier">DomainT</span></code> that is
 472         <code class="computeroutput"><span class="identifier">incrementable</span></code> will also have
 473         an <code class="computeroutput"><span class="identifier">unit_element</span></code>. If it does
 474         not, a <code class="computeroutput"><span class="identifier">unit_element</span></code> can be
 475         provided. A <code class="computeroutput"><span class="identifier">unit_element</span></code>
 476         can be any value, that is greater as the <code class="computeroutput"><span class="identifier">identity_element</span></code>
 477         in the <code class="computeroutput"><span class="identifier">Compare</span></code> order given.
 478         An example of a type, that has an <code class="computeroutput"><span class="identifier">identity_element</span></code>
 479         but no increment operation is <code class="computeroutput"><span class="identifier">string</span></code>.
 480         So for <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code> a unit_element is implemented like
 481         this:
 482 </p>
 483 <pre class="programlisting"><span class="comment">// Smallest 'visible' string that is greater than the empty string.
 484 </span><span class="keyword">template</span> <span class="special">&lt;&gt;</span>
 485 <span class="keyword">inline</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span> <span class="identifier">unit_element</span><span class="special">&lt;</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;::</span><span class="identifier">value</span><span class="special">(){</span> <span class="keyword">return</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">(</span><span class="string">" "</span><span class="special">);</span> <span class="special">};</span>
 486 </pre>
 487 <p>
 488       </p>
 489 <p>
 490         Just as for the key type of std::sets and maps template parameter <code class="computeroutput"><span class="identifier">Compare</span></code> is required to be a <a href="http://en.wikipedia.org/wiki/Strict_weak_ordering" target="_top">strict
 491         weak ordering</a> on <code class="computeroutput"><span class="identifier">DomainT</span></code>.
 492       </p>
 493 <p>
 494         Finally, if <code class="computeroutput"><span class="identifier">DomainT</span></code> is an
 495         integral type, <code class="computeroutput"><span class="identifier">DomainT</span></code> needs
 496         to be <code class="computeroutput"><span class="identifier">incrementable</span></code> and
 497         <code class="computeroutput"><span class="identifier">decrementable</span></code>. This <span class="emphasis"><em>'bicrementability'</em></span>
 498         needs to be implemented on the smallest possible unit of the integral type.
 499         This seems like being trivial but there are types like e.g. <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">date_time</span><span class="special">::</span><span class="identifier">ptime</span></code>, that are integral in nature but
 500         do not provide the required in- and decrementation on the least incrementable
 501         unit. For <code class="computeroutput"><a class="link" href="../../boost/icl/interval.html" title="Struct template interval">icl::intervals</a></code>
 502         incementation and decementation is used for computations between open to
 503         closed interval borders like e.g. <code class="computeroutput"><span class="special">[</span><span class="number">2</span><span class="special">,</span><span class="number">43</span><span class="special">)</span> <span class="special">==</span> <span class="special">[</span><span class="number">2</span><span class="special">,</span><span class="number">42</span><span class="special">]</span></code>. Such computations always need only one
 504         in- or decrementation, if <code class="computeroutput"><span class="identifier">DomainT</span></code>
 505         is an integral type.
 506       </p>
 507 <a name="boost_icl.interface.required_concepts.requirements_on_intervalt"></a><h6>
 508 <a name="id1108639"></a>
 509         <a class="link" href="required_concepts.html#boost_icl.interface.required_concepts.requirements_on_intervalt">Requirements
 510         on IntervalT</a>
 511       </h6>
 512 <p>
 513         Requirements on the <code class="computeroutput"><span class="identifier">IntervalT</span></code>
 514         parameter are closely related to the <code class="computeroutput"><span class="identifier">DomainT</span></code>
 515         parameter. <code class="computeroutput"><span class="identifier">IntervalT</span></code> has
 516         two associated types itself for an element type and a compare order that
 517         have to be consistent with the element and order parameters of their interval
 518         containers. <code class="computeroutput"><span class="identifier">IntervalT</span></code> then
 519         has to implement an order called <code class="computeroutput"><span class="identifier">exclusive_less</span></code>.
 520         Two intervals <code class="computeroutput"><span class="identifier">x</span><span class="special">,</span>
 521         <span class="identifier">y</span></code> are exclusive_less
 522 </p>
 523 <pre class="programlisting"><span class="identifier">icl</span><span class="special">::</span><span class="identifier">exclusive_less</span><span class="special">(</span><span class="identifier">x</span><span class="special">,</span> <span class="identifier">y</span><span class="special">)</span></pre>
 524 <p>
 525         if all <code class="computeroutput"><span class="identifier">DomainT</span></code> elements of
 526         <code class="computeroutput"><span class="identifier">x</span></code> are less than elements
 527         of <code class="computeroutput"><span class="identifier">y</span></code> in the <code class="computeroutput"><span class="identifier">Compare</span></code> order.
 528       </p>
 529 <div class="informaltable"><table class="table">
 530 <colgroup>
 531 <col>
 532 <col>
 533 <col>
 534 </colgroup>
 535 <thead><tr>
 536 <th>
 537               <p>
 538                 Parameter
 539               </p>
 540               </th>
 541 <th>
 542               <p>
 543                 Operators
 544               </p>
 545               </th>
 546 <th>
 547               <p>
 548                 Requirement
 549               </p>
 550               </th>
 551 </tr></thead>
 552 <tbody><tr>
 553 <td>
 554               <p>
 555                 <code class="computeroutput"><span class="identifier">IntervalT</span></code>
 556               </p>
 557               </td>
 558 <td>
 559               <p>
 560                 <code class="computeroutput"><span class="identifier">exclusive_less</span></code>
 561               </p>
 562               </td>
 563 <td>
 564               <p>
 565                 <code class="computeroutput"><span class="identifier">IsExclusiveLessComparable</span><span class="special">&lt;</span><span class="identifier">Interval</span><span class="special">&lt;</span><span class="identifier">DomainT</span><span class="special">,</span><span class="identifier">Compare</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>
 566               </p>
 567               </td>
 568 </tr></tbody>
 569 </table></div>
 570 <a name="boost_icl.interface.required_concepts.requirements_on_codomaint"></a><h5>
 571 <a name="id1108888"></a>
 572         <a class="link" href="required_concepts.html#boost_icl.interface.required_concepts.requirements_on_codomaint">Requirements
 573         on CodomainT</a>
 574       </h5>
 575 <p>
 576         Summarized in the next table are requirements for template parameter <code class="computeroutput"><span class="identifier">CodomainT</span></code> of associated values for <code class="computeroutput"><span class="identifier">Maps</span></code>. Again there are <span class="emphasis"><em>conditions</em></span>
 577         for some of the requirements. Column <span class="emphasis"><em>operators</em></span> contains
 578         the operators and functions required for <code class="computeroutput"><span class="identifier">CodomainT</span></code>,
 579         if we are using the default combiner <code class="computeroutput"><span class="identifier">Combine</span>
 580         <span class="special">=</span> <span class="identifier">icl</span><span class="special">::</span><span class="identifier">inplace_plus</span></code>.
 581       </p>
 582 <div class="informaltable"><table class="table">
 583 <colgroup>
 584 <col>
 585 <col>
 586 <col>
 587 <col>
 588 </colgroup>
 589 <thead><tr>
 590 <th>
 591               <p>
 592                 Parameter
 593               </p>
 594               </th>
 595 <th>
 596               <p>
 597                 Condition
 598               </p>
 599               </th>
 600 <th>
 601               <p>
 602                 Operators
 603               </p>
 604               </th>
 605 <th>
 606               <p>
 607                 Requirement
 608               </p>
 609               </th>
 610 </tr></thead>
 611 <tbody>
 612 <tr>
 613 <td>
 614               <p>
 615                 <code class="computeroutput"><span class="identifier">CodomainT</span></code>
 616               </p>
 617               </td>
 618 <td>
 619               <p>
 620                 <code class="computeroutput"><span class="identifier">add</span></code>, <code class="computeroutput"><span class="identifier">subtract</span></code>, <code class="computeroutput"><span class="identifier">intersect</span></code>
 621                 unused
 622               </p>
 623               </td>
 624 <td>
 625               <p>
 626                 <code class="computeroutput"><span class="identifier">CodomainT</span><span class="special">(),</span>
 627                 <span class="special">==</span></code>
 628               </p>
 629               </td>
 630 <td>
 631               <p>
 632                 <code class="computeroutput"><span class="identifier">Regular</span><span class="special">&lt;</span><span class="identifier">CodomainT</span><span class="special">&gt;</span></code>
 633                 which implies
 634               </p>
 635               </td>
 636 </tr>
 637 <tr>
 638 <td>
 639               <p>
 640               </p>
 641               </td>
 642 <td>
 643               <p>
 644               </p>
 645               </td>
 646 <td>
 647               <p>
 648               </p>
 649               </td>
 650 <td>
 651               <p>
 652                 <code class="computeroutput"><span class="identifier">DefaultConstructible</span><span class="special">&lt;</span><span class="identifier">CodomainT</span><span class="special">&gt;</span> <span class="special">&amp;&amp;</span>
 653                 <span class="identifier">EqualityComparable</span><span class="special">&lt;</span><span class="identifier">CodomainT</span><span class="special">&gt;</span></code>
 654               </p>
 655               </td>
 656 </tr>
 657 <tr>
 658 <td>
 659               <p>
 660               </p>
 661               </td>
 662 <td>
 663               <p>
 664                 only <code class="computeroutput"><span class="identifier">add</span></code> used
 665               </p>
 666               </td>
 667 <td>
 668               <p>
 669                 <code class="computeroutput"><span class="special">+=</span></code>
 670               </p>
 671               </td>
 672 <td>
 673               <p>
 674                 <code class="computeroutput"><span class="special">&amp;&amp;</span> <span class="identifier">Combinable</span><span class="special">&lt;</span><span class="identifier">CodomainT</span><span class="special">,</span><span class="identifier">Combine</span><span class="special">&gt;</span></code>
 675               </p>
 676               </td>
 677 </tr>
 678 <tr>
 679 <td>
 680               <p>
 681               </p>
 682               </td>
 683 <td>
 684               <p>
 685                 ... and also <code class="computeroutput"><span class="identifier">subtract</span></code>
 686                 used
 687               </p>
 688               </td>
 689 <td>
 690               <p>
 691                 <code class="computeroutput"><span class="special">-=</span></code>
 692               </p>
 693               </td>
 694 <td>
 695               <p>
 696                 <code class="computeroutput"><span class="special">&amp;&amp;</span> <span class="identifier">Combinable</span><span class="special">&lt;</span><span class="identifier">CodomainT</span><span class="special">,</span><span class="identifier">Inverse</span><span class="special">&lt;</span><span class="identifier">Combine</span><span class="special">&gt;</span> <span class="special">&gt;</span></code>
 697               </p>
 698               </td>
 699 </tr>
 700 <tr>
 701 <td>
 702               <p>
 703               </p>
 704               </td>
 705 <td>
 706               <p>
 707                 <code class="computeroutput"><span class="identifier">Section</span></code> used and
 708                 <code class="computeroutput"><span class="identifier">CodomainT</span></code> is a set
 709               </p>
 710               </td>
 711 <td>
 712               <p>
 713                 <code class="computeroutput"><span class="special">&amp;=</span></code>
 714               </p>
 715               </td>
 716 <td>
 717               <p>
 718                 <code class="computeroutput"><span class="special">&amp;&amp;</span> <span class="identifier">Intersectable</span><span class="special">&lt;</span><span class="identifier">CodomainT</span><span class="special">,</span><span class="identifier">Section</span><span class="special">&gt;</span></code>
 719               </p>
 720               </td>
 721 </tr>
 722 </tbody>
 723 </table></div>
 724 <p>
 725         The requirements on the type <code class="computeroutput"><span class="identifier">CodomainT</span></code>
 726         of associated values for a <code class="computeroutput"><a class="link" href="../../boost/icl/map.html" title="Class template map">icl::map</a></code>
 727         or <code class="computeroutput"><a class="link" href="../../boost/icl/interval_map.html" title="Class template interval_map">interval_map</a></code> depend
 728         on the usage of their aggregation functionality. If aggregation on overlap
 729         is never used, that is to say that none of the addition, subtraction and
 730         intersection operations (<code class="computeroutput"><span class="special">+,</span> <span class="special">+=,</span> <span class="identifier">add</span></code>,
 731         <code class="computeroutput"><span class="special">-,</span> <span class="special">-=,</span>
 732         <span class="identifier">subtract</span></code>, &amp;, &amp;=, add_intersection)
 733         are used on the <code class="computeroutput"><a class="link" href="../../boost/icl/interval_map.html" title="Class template interval_map">interval_map</a></code>,
 734         then <code class="computeroutput"><span class="identifier">CodomainT</span></code> only needs
 735         to be <a href="http://www.informit.com/guides/content.aspx?g=cplusplus&amp;seqNum=314" target="_top">Regular</a>.
 736       </p>
 737 <p>
 738         <span class="emphasis"><em><span class="bold"><strong>Regular</strong></span></em></span> object semantics
 739         implies <code class="computeroutput"><span class="identifier">DefaultConstructible</span></code>
 740         and <code class="computeroutput"><span class="identifier">EqualityComparable</span></code> which
 741         means it has a default ctor <code class="computeroutput"><span class="identifier">CodomainT</span><span class="special">()</span></code> and an <code class="computeroutput"><span class="keyword">operator</span>
 742         <span class="special">==</span></code>.
 743       </p>
 744 <p>
 745         Use <code class="computeroutput"><a class="link" href="../../boost/icl/interval_map.html" title="Class template interval_map">interval_maps</a></code>
 746         <span class="emphasis"><em><span class="bold"><strong>without aggregation</strong></span></em></span>,
 747         if the associated values are not addable but still are attached to intervals
 748         so you want to use <code class="computeroutput"><a class="link" href="../../boost/icl/interval_map.html" title="Class template interval_map">interval_maps</a></code>
 749         to handle them. As long as those values are added with <code class="computeroutput"><span class="identifier">insert</span></code>
 750         and deleted with <code class="computeroutput"><span class="identifier">erase</span></code> <code class="computeroutput"><a class="link" href="../../boost/icl/interval_map.html" title="Class template interval_map">interval_maps</a></code> will work fine with
 751         such values.
 752       </p>
 753 <p>
 754         If <span class="emphasis"><em><span class="bold"><strong>only addition</strong></span></em></span> is
 755         used via <code class="computeroutput"><a class="link" href="../../boost/icl/interval_map.html" title="Class template interval_map">interval_map's</a></code>
 756         <code class="computeroutput"><span class="special">+,</span> <span class="special">+=</span></code>
 757         or <code class="computeroutput"><span class="identifier">add</span></code> but no subtraction,
 758         then <code class="computeroutput"><span class="identifier">CodomainT</span></code> need to be
 759         <code class="computeroutput"><span class="identifier">Combinable</span></code> for functor template
 760         <code class="computeroutput"><span class="identifier">Combine</span></code>. That means in most
 761         cases when the default implementation <code class="computeroutput"><span class="identifier">inplace_plus</span></code>
 762         for <code class="computeroutput"><span class="identifier">Combine</span></code> is used, that
 763         <code class="computeroutput"><span class="identifier">CodomainT</span></code> has to implement
 764         <code class="computeroutput"><span class="keyword">operator</span> <span class="special">+=</span></code>.
 765       </p>
 766 <p>
 767         For associated value types, that are addable but not subtractable like e.g.
 768         <code class="computeroutput"><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span></code> it usually makes sense to use addition
 769         to combine values but the inverse combination is not desired.
 770 </p>
 771 <pre class="programlisting"><span class="identifier">interval_map</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">,</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">&gt;</span> <span class="identifier">cat_map</span><span class="special">;</span>
 772 <span class="identifier">cat_map</span> <span class="special">+=</span> <span class="identifier">make_pair</span><span class="special">(</span><span class="identifier">interval</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">rightopen</span><span class="special">(</span><span class="number">1</span><span class="special">,</span><span class="number">5</span><span class="special">),</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">(</span><span class="string">"Hello"</span><span class="special">));</span>
 773 <span class="identifier">cat_map</span> <span class="special">+=</span> <span class="identifier">make_pair</span><span class="special">(</span><span class="identifier">interval</span><span class="special">&lt;</span><span class="keyword">int</span><span class="special">&gt;::</span><span class="identifier">rightopen</span><span class="special">(</span><span class="number">3</span><span class="special">,</span><span class="number">7</span><span class="special">),</span><span class="identifier">std</span><span class="special">::</span><span class="identifier">string</span><span class="special">(</span><span class="string">" world"</span><span class="special">));</span>
 774 <span class="identifier">cout</span> <span class="special">&lt;&lt;</span> <span class="string">"cat_map: "</span> <span class="special">&lt;&lt;</span> <span class="identifier">cat_map</span> <span class="special">&lt;&lt;</span> <span class="identifier">endl</span><span class="special">;</span>
 775 <span class="comment">//cat_map: {([1,3)-&gt;Hello)([3,5)-&gt;Hello world)([5,7)-&gt; world)}
 776 </span></pre>
 777 <p>
 778       </p>
 779 <p>
 780         For <span class="emphasis"><em>complete aggregation functionality</em></span> an inverse aggregation
 781         functor on a <code class="computeroutput"><span class="identifier">Map</span></code>'s <code class="computeroutput"><span class="identifier">CodomainT</span></code> is needed. The icl provides a
 782         metafunction <code class="computeroutput"><a class="link" href="../../boost/icl/inverse.html" title="Struct template inverse">inverse</a></code> for
 783         that purpose. Using the default <code class="computeroutput"><span class="identifier">Combine</span>
 784         <span class="special">=</span> <span class="identifier">inplace_plus</span></code>
 785         that relies on the existence of <code class="computeroutput"><span class="keyword">operator</span>
 786         <span class="special">+=</span></code> on type <code class="computeroutput"><span class="identifier">CodomainT</span></code>
 787         metafunction <code class="computeroutput"><a class="link" href="../../boost/icl/inverse.html" title="Struct template inverse">inverse</a></code> will
 788         infer <code class="computeroutput"><a class="link" href="../../boost/icl/inplace_minus.html" title="Struct template inplace_minus">inplace_minus</a></code>
 789         as inverse functor, that requires <code class="computeroutput"><span class="keyword">operator</span>
 790         <span class="special">-=</span></code> on type <code class="computeroutput"><span class="identifier">CodomainT</span></code>.
 791       </p>
 792 <p>
 793         In the icl's design we make the assumption, in particular for the default
 794         setting of parameters <code class="computeroutput"><span class="identifier">Combine</span> <span class="special">=</span> </code><code class="computeroutput"><a class="link" href="../../boost/icl/inplace_minus.html" title="Struct template inplace_minus">inplace_plus</a></code>,
 795         that type <code class="computeroutput"><span class="identifier">CodomainT</span></code> has a
 796         neutral element or <code class="computeroutput"><span class="identifier">identity_element</span></code>
 797         with respect to the <code class="computeroutput"><span class="identifier">Combine</span></code>
 798         functor.
 799       </p>
 800 </div>
 801 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
 802 <td align="left"></td>
 803 <td align="right"><div class="copyright-footer">Copyright &#169; 2007 -2010 Joachim Faulhaber<br>Copyright &#169; 1999 -2006 Cortex Software GmbH<p>
 804         Distributed under the Boost Software License, Version 1.0. (See accompanying
 805         file LICENSE_1_0.txt or copy at <a href="http://www.boost.org/LICENSE_1_0.txt" target="_top">http://www.boost.org/LICENSE_1_0.txt</a>)
 806       </p>
 807 </div></td>
 808 </tr></table>
 809 <hr>
 810 <div class="spirit-nav">
 811 <a accesskey="p" href="../interface.html"><img src="../../../../../../doc/src/images/prev.png" alt="Prev"></a><a accesskey="u" href="../interface.html"><img src="../../../../../../doc/src/images/up.png" alt="Up"></a><a accesskey="h" href="../../index.html"><img src="../../../../../../doc/src/images/home.png" alt="Home"></a><a accesskey="n" href="associated_types.html"><img src="../../../../../../doc/src/images/next.png" alt="Next"></a>
 812 </div>
 813 </body>
 814 </html>