Branch data Line data Source code
1 : : #ifndef TAG_COMPARE_HPP
2 : : #define TAG_COMPARE_HPP
3 : :
4 : : #include "TagInfo.hpp"
5 : : #include "VarLenTag.hpp"
6 : : #include <vector>
7 : :
8 : : namespace moab
9 : : {
10 : :
11 : : /* OPAQUE FUNCTORS */
12 : :
13 : : /** Test fixed-length opaque tags for equality */
14 : : class TagBytesEqual
15 : : {
16 : : private:
17 : : const void* value;
18 : : int size;
19 : :
20 : : public:
21 : 17 : TagBytesEqual( const void* v, int s ) : value( v ), size( s ) {}
22 : 3 : bool operator()( const void* data ) const
23 : : {
24 : 3 : return !memcmp( value, data, size );
25 : : }
26 : : };
27 : : /** Test if fixed-length opaque tag values are less than a value */
28 : : class TagBytesLess
29 : : {
30 : : private:
31 : : const void* value;
32 : : int size;
33 : :
34 : : public:
35 : : TagBytesLess( const void* v, int s ) : value( v ), size( s ) {}
36 : : bool operator()( const void* data ) const
37 : : {
38 : : return 0 < memcmp( value, data, size );
39 : : }
40 : : };
41 : : /** Test variable-length opaque tags for equality */
42 : : class TagVarBytesEqual
43 : : {
44 : : private:
45 : : const void* value;
46 : : int size;
47 : :
48 : : public:
49 : 0 : TagVarBytesEqual( const void* v, int s ) : value( v ), size( s ) {}
50 : 0 : bool operator()( const void* data ) const
51 : : {
52 : 0 : const VarLenTag* vdata = reinterpret_cast< const VarLenTag* >( data );
53 [ # # ][ # # ]: 0 : return (int)vdata->size() == size && !memcmp( value, vdata->data(), size );
54 : : }
55 : 0 : bool operator()( const VarLenTag& vdata ) const
56 : : {
57 [ # # ][ # # ]: 0 : return (int)vdata.size() == size && !memcmp( value, vdata.data(), size );
58 : : }
59 : : };
60 : : /** Test if variable-length opaque tag values are less than a value */
61 : : class TagVarBytesLess
62 : : {
63 : : private:
64 : : const void* value;
65 : : int size;
66 : :
67 : : public:
68 : : TagVarBytesLess( const void* v, int s ) : value( v ), size( s ) {}
69 : : bool operator()( const void* data ) const
70 : : {
71 : : const VarLenTag* vdata = reinterpret_cast< const VarLenTag* >( data );
72 : : if( (int)vdata->size() < size )
73 : : return 0 <= memcmp( vdata->data(), value, vdata->size() );
74 : : else
75 : : return 0 < memcmp( vdata->data(), value, size );
76 : : }
77 : : bool operator()( const VarLenTag& vdata ) const
78 : : {
79 : : if( (int)vdata.size() < size )
80 : : return 0 <= memcmp( vdata.data(), value, vdata.size() );
81 : : else
82 : : return 0 < memcmp( vdata.data(), value, size );
83 : : }
84 : : };
85 : :
86 : : /* TEMPLATE FUNCTORS */
87 : :
88 : : /** Compare fixed-length tags containing a known data type */
89 : : template < typename T >
90 : : class TagTypeEqual
91 : : {
92 : : private:
93 : : const T* value;
94 : : int size;
95 : :
96 : : public:
97 : 0 : TagTypeEqual( const void* v, int s ) : value( reinterpret_cast< const T* >( v ) ), size( s / sizeof( T ) ) {}
98 : :
99 : 0 : bool operator()( const void* data ) const
100 : : {
101 : 0 : const T* ddata = reinterpret_cast< const T* >( data );
102 [ # # ]: 0 : for( int i = 0; i < size; ++i )
103 [ # # ]: 0 : if( value[i] != ddata[i] ) return false;
104 : 0 : return true;
105 : : }
106 : : };
107 : :
108 : : /** Compare fixed-length tags containing a known data type */
109 : : template < typename T >
110 : : class TagTypeLess
111 : : {
112 : : private:
113 : : const T* value;
114 : : int size;
115 : :
116 : : public:
117 : : TagTypeLess( const void* v, int s ) : value( reinterpret_cast< const T* >( v ) ), size( s / sizeof( T ) ) {}
118 : :
119 : : bool operator()( const void* data ) const
120 : : {
121 : : const T* ddata = reinterpret_cast< const T* >( data );
122 : : for( int i = 0; i < size; ++i )
123 : : if( value[i] <= ddata[i] ) return false;
124 : : return true;
125 : : }
126 : : };
127 : :
128 : : /** Compare single-value tags containing a known data type
129 : : * Optimization of TagTypeEqual for 1-value case.
130 : : */
131 : : template < typename T >
132 : : class TagOneTypeEqual
133 : : {
134 : : private:
135 : : T value;
136 : : int size;
137 : :
138 : : public:
139 : 1361 : TagOneTypeEqual( const void* v ) : value( *reinterpret_cast< const T* >( v ) ), size( 0 ) {}
140 : :
141 : 61573 : bool operator()( const void* data ) const
142 : : {
143 : 61573 : const T* ddata = reinterpret_cast< const T* >( data );
144 : 61573 : return *ddata == value;
145 : : }
146 : : };
147 : :
148 : : /** Compare single-value tags containing a known data type
149 : : * Optimization of TagTypeLess for 1-value case.
150 : : */
151 : : template < typename T >
152 : : class TagOneTypeLess
153 : : {
154 : : private:
155 : : T value;
156 : : int size;
157 : :
158 : : public:
159 : : TagOneTypeLess( const void* v ) : value( *reinterpret_cast< const T* >( v ) ), size( 0 ) {}
160 : :
161 : : bool operator()( const void* data ) const
162 : : {
163 : : const T* ddata = reinterpret_cast< const T* >( data );
164 : : return *ddata < value;
165 : : }
166 : : };
167 : :
168 : : /** Compare variable-length tags containing a known data type */
169 : : template < typename T >
170 : : class TagVarTypeEqual
171 : : {
172 : : private:
173 : : const T* value;
174 : : int size;
175 : :
176 : : public:
177 : 0 : TagVarTypeEqual( const void* v, int s ) : value( reinterpret_cast< const T* >( v ) ), size( s / sizeof( T ) ) {}
178 : :
179 : 0 : bool operator()( const void* data ) const
180 : : {
181 : 0 : const VarLenTag* vdata = reinterpret_cast< const VarLenTag* >( data );
182 [ # # ]: 0 : if( vdata->size() != size * sizeof( T ) ) return false;
183 : 0 : const T* ddata = reinterpret_cast< const T* >( vdata->data() );
184 [ # # ]: 0 : for( int i = 0; i < size; ++i )
185 [ # # ]: 0 : if( value[i] != ddata[i] ) return false;
186 : 0 : return true;
187 : : }
188 : :
189 : 0 : bool operator()( const VarLenTag& vdata ) const
190 : : {
191 [ # # ]: 0 : if( vdata.size() != size * sizeof( T ) ) return false;
192 : 0 : const T* ddata = reinterpret_cast< const T* >( vdata.data() );
193 [ # # ]: 0 : for( int i = 0; i < size; ++i )
194 [ # # ]: 0 : if( value[i] != ddata[i] ) return false;
195 : 0 : return true;
196 : : }
197 : : };
198 : :
199 : : /** Compare variable-length tags containing a known data type */
200 : : template < typename T >
201 : : class TagVarTypeLess
202 : : {
203 : : private:
204 : : const T* value;
205 : : int size;
206 : :
207 : : public:
208 : : TagVarTypeLess( const void* v, int s ) : value( reinterpret_cast< const T* >( v ) ), size( s / sizeof( T ) ) {}
209 : : bool operator()( const void* data ) const
210 : : {
211 : : const VarLenTag* vdata = reinterpret_cast< const VarLenTag* >( data );
212 : : const T* ddata = reinterpret_cast< const T* >( vdata->data() );
213 : : if( (int)vdata->size() < sizeof( T ) * size )
214 : : {
215 : : for( int i = 0; i < vdata->size() / sizeof( T ); ++i )
216 : : if( value[i] < ddata[i] ) return false;
217 : : }
218 : : else
219 : : {
220 : : for( int i = 0; i < vdata->size() / sizeof( T ); ++i )
221 : : if( value[i] <= ddata[i] ) return false;
222 : : }
223 : : return true;
224 : : }
225 : : bool operator()( const VarLenTag& vdata ) const
226 : : {
227 : : const T* ddata = reinterpret_cast< const T* >( vdata.data() );
228 : : if( (int)vdata.size() < sizeof( T ) * size )
229 : : {
230 : : for( int i = 0; i < vdata.size() / sizeof( T ); ++i )
231 : : if( value[i] < ddata[i] ) return false;
232 : : }
233 : : else
234 : : {
235 : : for( int i = 0; i < vdata.size() / sizeof( T ); ++i )
236 : : if( value[i] <= ddata[i] ) return false;
237 : : }
238 : : return true;
239 : : }
240 : : };
241 : :
242 : : /* TYPE FUNCTORS */
243 : :
244 : : typedef TagBytesEqual TagIntsEqual;
245 : : typedef TagVarBytesEqual TagVarIntsEqual;
246 : : typedef TagTypeLess< int > TagIntsLess;
247 : : typedef TagVarTypeLess< int > TagVarIntsLess;
248 : : typedef TagOneTypeEqual< int > TagOneIntEqual;
249 : : typedef TagOneTypeLess< int > TagOneIntLess;
250 : :
251 : : typedef TagBytesEqual TagHandlesEqual;
252 : : typedef TagVarBytesEqual TagVarHandlesEqual;
253 : : typedef TagTypeLess< EntityHandle > TagHandlesLess;
254 : : typedef TagVarTypeLess< EntityHandle > TagVarHandlesLess;
255 : : typedef TagOneTypeEqual< EntityHandle > TagOneHandleEqual;
256 : : typedef TagOneTypeLess< EntityHandle > TagOneHandleLess;
257 : :
258 : : typedef TagTypeEqual< double > TagDoublesEqual;
259 : : typedef TagVarTypeEqual< double > TagVarDoublesEqual;
260 : : typedef TagTypeLess< double > TagDoublesLess;
261 : : typedef TagVarTypeLess< double > TagVarDoublesLess;
262 : : typedef TagOneTypeEqual< double > TagOneDoubleEqual;
263 : : typedef TagOneTypeLess< double > TagOneDoubleLess;
264 : :
265 : : /* SEARCHING */
266 : :
267 : : template < class Functor, class IteratorType >
268 : 175 : static inline void find_tag_values( Functor compare, IteratorType begin, IteratorType end, Range& results )
269 : : {
270 [ + - ][ # # ]: 175 : Range::iterator insert = results.begin();
[ + - ][ # # ]
[ + - ]
271 [ + - ][ + - ]: 2829 : for( IteratorType i = begin; i != end; ++i )
[ + + ][ # # ]
[ # # ][ # # ]
[ + - ][ + - ]
[ + + ][ # # ]
[ # # ][ # # ]
[ + - ][ + - ]
[ + + ]
272 [ + - ][ + - ]: 2654 : if( compare( i->second ) ) insert = results.insert( insert, i->first );
[ + + ][ + - ]
[ + - ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ + - ][ + - ]
[ + + ][ + - ]
[ + - ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ + - ][ + - ]
[ + + ][ + - ]
[ + - ]
273 : 175 : }
274 : :
275 : : template < class Functor, class IteratorType >
276 : : static inline void find_tag_values( Functor compare, IteratorType begin, IteratorType end,
277 : : std::vector< EntityHandle >& results )
278 : : {
279 : : for( IteratorType i = begin; i != end; ++i )
280 : : if( compare( i->second ) ) results.push_back( i->first );
281 : : }
282 : :
283 : : template < class Functor, class TagMap >
284 : 1203 : static inline void find_map_values( Functor compare, Range::const_iterator lower, Range::const_iterator upper,
285 : : const TagMap& tag_map, Range& results )
286 : : {
287 [ + - ][ # # ]: 1203 : Range::iterator insert = results.begin();
[ # # ][ + - ]
[ + - ]
288 [ + - ][ + - ]: 279956 : for( ; lower != upper; ++lower )
[ + + ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ + - ]
[ + - ][ + + ]
[ + - ][ + - ]
[ + + ]
289 : : {
290 [ + - ][ + - ]: 278753 : typename TagMap::const_iterator i = tag_map.find( *lower );
[ # # ][ # # ]
[ # # ][ # # ]
[ + - ][ + - ]
[ + - ][ + - ]
291 [ + - ][ + - ]: 278753 : if( i != tag_map.end() && compare( i->second ) ) insert = results.insert( insert, *lower );
[ + - ][ + - ]
[ + + ][ + - ]
[ + + ][ + - ]
[ + - ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ + - ][ + + ]
[ + - ][ + - ]
[ + + ][ + - ]
[ + + ][ + - ]
[ + - ][ # # ]
[ + - ][ + + ]
[ + - ][ + - ]
[ + + ][ + - ]
[ + + ][ + - ]
[ + - ][ # # ]
292 : : }
293 : 1203 : }
294 : :
295 : : /** Find all entities for which a tag has a specific value
296 : : *\param IteratorType : an iterator that has map behavior:
297 : : * the value of 'first' is the entity handle.
298 : : * the value of 'second' is a pointer to the tag data.
299 : : *\param ContainerType : std::vector<EntityHandle> or Range
300 : : */
301 : : template < class IteratorType, class ContainerType >
302 : 175 : static inline void find_tag_values_equal( const TagInfo& tag_info, const void* value, int size, IteratorType begin,
303 : : IteratorType end, ContainerType& results )
304 : : {
305 [ + + + - ]: 175 : switch( tag_info.get_data_type() )
306 : : {
307 : : case MB_TYPE_INTEGER:
308 [ + - ]: 139 : if( size == sizeof( int ) )
309 [ + - ]: 139 : find_tag_values< TagOneIntEqual, IteratorType >( TagOneIntEqual( value ), begin, end, results );
310 : : else
311 [ # # ]: 0 : find_tag_values< TagIntsEqual, IteratorType >( TagIntsEqual( value, size ), begin, end, results );
312 : 139 : break;
313 : :
314 : : case MB_TYPE_DOUBLE:
315 [ + - ]: 1 : if( size == sizeof( double ) )
316 [ + - ]: 1 : find_tag_values< TagOneDoubleEqual, IteratorType >( TagOneDoubleEqual( value ), begin, end, results );
317 : : else
318 [ # # ]: 0 : find_tag_values< TagDoublesEqual, IteratorType >( TagDoublesEqual( value, size ), begin, end, results );
319 : 1 : break;
320 : :
321 : : case MB_TYPE_HANDLE:
322 [ + - ]: 35 : if( size == sizeof( EntityHandle ) )
323 [ + - ]: 35 : find_tag_values< TagOneHandleEqual, IteratorType >( TagOneHandleEqual( value ), begin, end, results );
324 : : else
325 [ # # ]: 0 : find_tag_values< TagHandlesEqual, IteratorType >( TagHandlesEqual( value, size ), begin, end, results );
326 : 35 : break;
327 : :
328 : : default:
329 [ # # ]: 0 : find_tag_values< TagBytesEqual, IteratorType >( TagBytesEqual( value, size ), begin, end, results );
330 : 0 : break;
331 : : }
332 : 175 : }
333 : : template < class IteratorType, class ContainerType >
334 : 0 : static inline void find_tag_varlen_values_equal( const TagInfo& tag_info, const void* value, int size,
335 : : IteratorType begin, IteratorType end, ContainerType& results )
336 : : {
337 [ # # # # ]: 0 : switch( tag_info.get_data_type() )
338 : : {
339 : : case MB_TYPE_INTEGER:
340 [ # # ]: 0 : find_tag_values< TagVarIntsEqual, IteratorType >( TagVarIntsEqual( value, size ), begin, end, results );
341 : 0 : break;
342 : : case MB_TYPE_DOUBLE:
343 [ # # ]: 0 : find_tag_values< TagVarDoublesEqual, IteratorType >( TagVarDoublesEqual( value, size ), begin, end,
344 : 0 : results );
345 : 0 : break;
346 : : case MB_TYPE_HANDLE:
347 [ # # ]: 0 : find_tag_values< TagVarHandlesEqual, IteratorType >( TagVarHandlesEqual( value, size ), begin, end,
348 : 0 : results );
349 : 0 : break;
350 : : default:
351 [ # # ]: 0 : find_tag_values< TagVarBytesEqual, IteratorType >( TagVarBytesEqual( value, size ), begin, end, results );
352 : 0 : break;
353 : : }
354 : 0 : }
355 : :
356 : : /** Find all entities for which a tag has a specific value
357 : : *\param IteratorType : an iterator that has map behavior:
358 : : * the value of 'first' is the entity handle.
359 : : * the value of 'second' is a pointer to the tag data.
360 : : *\param ContainerType : std::vector<EntityHandle> or Range
361 : : */
362 : : template < class TagMap >
363 : 1203 : static inline void find_map_values_equal( const TagInfo& tag_info, const void* value, int size,
364 : : Range::const_iterator begin, Range::const_iterator end, const TagMap& tag_map,
365 : : Range& results )
366 : : {
367 [ + - + + ]: 1203 : switch( tag_info.get_data_type() )
368 : : {
369 : : case MB_TYPE_INTEGER:
370 [ + - ]: 1151 : if( size == sizeof( int ) )
371 [ + - ]: 1151 : find_map_values< TagOneIntEqual, TagMap >( TagOneIntEqual( value ), begin, end, tag_map, results );
372 : : else
373 [ # # ]: 0 : find_map_values< TagIntsEqual, TagMap >( TagIntsEqual( value, size ), begin, end, tag_map, results );
374 : 1151 : break;
375 : :
376 : : case MB_TYPE_DOUBLE:
377 [ # # ]: 0 : if( size == sizeof( double ) )
378 [ # # ]: 0 : find_map_values< TagOneDoubleEqual, TagMap >( TagOneDoubleEqual( value ), begin, end, tag_map,
379 : 0 : results );
380 : : else
381 [ # # ]: 0 : find_map_values< TagDoublesEqual, TagMap >( TagDoublesEqual( value, size ), begin, end, tag_map,
382 : 0 : results );
383 : 0 : break;
384 : :
385 : : case MB_TYPE_HANDLE:
386 [ + - ]: 35 : if( size == sizeof( EntityHandle ) )
387 [ + - ]: 35 : find_map_values< TagOneHandleEqual, TagMap >( TagOneHandleEqual( value ), begin, end, tag_map,
388 : 70 : results );
389 : : else
390 [ # # ]: 0 : find_map_values< TagHandlesEqual, TagMap >( TagHandlesEqual( value, size ), begin, end, tag_map,
391 : 0 : results );
392 : 35 : break;
393 : :
394 : : default:
395 [ + - ]: 17 : find_map_values< TagBytesEqual, TagMap >( TagBytesEqual( value, size ), begin, end, tag_map, results );
396 : 17 : break;
397 : : }
398 : 1203 : }
399 : : template < class TagMap >
400 : 0 : static inline void find_map_varlen_values_equal( const TagInfo& tag_info, const void* value, int size,
401 : : Range::const_iterator begin, Range::const_iterator end,
402 : : const TagMap& tag_map, Range& results )
403 : : {
404 [ # # # # ]: 0 : switch( tag_info.get_data_type() )
405 : : {
406 : : case MB_TYPE_INTEGER:
407 [ # # ]: 0 : find_map_values< TagVarIntsEqual, TagMap >( TagVarIntsEqual( value, size ), begin, end, tag_map, results );
408 : 0 : break;
409 : : case MB_TYPE_DOUBLE:
410 [ # # ]: 0 : find_map_values< TagVarDoublesEqual, TagMap >( TagVarDoublesEqual( value, size ), begin, end, tag_map,
411 : 0 : results );
412 : 0 : break;
413 : : case MB_TYPE_HANDLE:
414 [ # # ]: 0 : find_map_values< TagVarHandlesEqual, TagMap >( TagVarHandlesEqual( value, size ), begin, end, tag_map,
415 : 0 : results );
416 : 0 : break;
417 : : default:
418 [ # # ]: 0 : find_map_values< TagVarBytesEqual, TagMap >( TagVarBytesEqual( value, size ), begin, end, tag_map,
419 : 0 : results );
420 : 0 : break;
421 : : }
422 : 0 : }
423 : :
424 : : /** Iterator to use in find_tag_values_equal for arrays of data */
425 : : class ByteArrayIterator
426 : : {
427 : : public:
428 : : typedef std::pair< EntityHandle, const char* > data_type;
429 : :
430 : : private:
431 : : size_t step;
432 : : data_type data;
433 : :
434 : : public:
435 : 175 : ByteArrayIterator( EntityHandle start_handle, const void* data_array, size_t tag_size )
436 [ + - ]: 175 : : step( tag_size ), data( start_handle, reinterpret_cast< const char* >( data_array ) )
437 : :
438 : : {
439 : 175 : }
440 : 175 : ByteArrayIterator( EntityHandle start_handle, const void* data_array, const TagInfo& tag_info )
441 : 350 : : step( tag_info.get_size() == MB_VARIABLE_LENGTH ? sizeof( VarLenTag ) : tag_info.get_size() ),
442 [ - + ][ + - ]: 350 : data( start_handle, reinterpret_cast< const char* >( data_array ) )
443 : : {
444 : 175 : }
445 : : bool operator==( const ByteArrayIterator& other ) const
446 : : {
447 : : return data.first == other.data.first;
448 : : }
449 : 2829 : bool operator!=( const ByteArrayIterator& other ) const
450 : : {
451 : 2829 : return data.first != other.data.first;
452 : : }
453 : 2654 : ByteArrayIterator& operator++()
454 : : {
455 : 2654 : ++data.first;
456 : 2654 : data.second += step;
457 : 2654 : return *this;
458 : : }
459 : : ByteArrayIterator operator++( int )
460 : : {
461 : : ByteArrayIterator result( *this );
462 : : operator++();
463 : : return result;
464 : : }
465 : : ByteArrayIterator& operator--()
466 : : {
467 : : --data.first;
468 : : data.second -= step;
469 : : return *this;
470 : : }
471 : : ByteArrayIterator operator--( int )
472 : : {
473 : : ByteArrayIterator result( *this );
474 : : operator--();
475 : : return result;
476 : : }
477 : 0 : ByteArrayIterator& operator+=( size_t amt )
478 : : {
479 : 0 : data.first += amt;
480 : 0 : data.second += amt * step;
481 : 0 : return *this;
482 : : }
483 : : ByteArrayIterator& operator-=( size_t amt )
484 : : {
485 : : data.first -= amt;
486 : : data.second -= amt * step;
487 : : return *this;
488 : : }
489 : : EntityHandle operator-( const ByteArrayIterator& other ) const
490 : : {
491 : : return data.first - other.data.first;
492 : : }
493 : : const data_type& operator*() const
494 : : {
495 : : return data;
496 : : }
497 : 2828 : const data_type* operator->() const
498 : : {
499 : 2828 : return &data;
500 : : }
501 : : };
502 : :
503 : 209 : static inline std::pair< EntityType, EntityType > type_range( EntityType type )
504 : : {
505 [ + + ]: 209 : if( type == MBMAXTYPE )
506 [ + - ]: 88 : return std::pair< EntityType, EntityType >( MBVERTEX, MBMAXTYPE );
507 : : else
508 : : {
509 : 121 : EntityType next = type;
510 [ + - ]: 121 : ++next;
511 [ + - ]: 209 : return std::pair< EntityType, EntityType >( type, next );
512 : : }
513 : : }
514 : :
515 : : /** Dummy container that counts insertions rather than maintaining a list of entities */
516 : : class InsertCount
517 : : {
518 : : private:
519 : : size_t mCount;
520 : :
521 : : public:
522 : 36 : InsertCount( size_t initial_count = 0 ) : mCount( initial_count ) {}
523 : :
524 : : typedef int iterator;
525 : 36 : iterator begin() const
526 : : {
527 : 36 : return 0;
528 : : }
529 : 40 : iterator end() const
530 : : {
531 : 40 : return mCount;
532 : : }
533 : 0 : iterator insert( iterator /* hint */, EntityHandle first, EntityHandle last )
534 : : {
535 : 0 : mCount += last - first + 1;
536 : 0 : return end();
537 : : }
538 : 4 : iterator insert( iterator /* hint */, EntityHandle /* value */ )
539 : : {
540 : 4 : ++mCount;
541 : 4 : return end();
542 : : }
543 : : };
544 : :
545 : : } // namespace moab
546 : :
547 : : #endif
|
