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