Branch data Line data Source code
1 : : /**
2 : : * MOAB, a Mesh-Oriented datABase, is a software component for creating,
3 : : * storing and accessing finite element mesh data.
4 : : *
5 : : * Copyright 2004 Sandia Corporation. Under the terms of Contract
6 : : * DE-AC04-94AL85000 with Sandia Corporation, the U.S. Government
7 : : * retains certain rights in this software.
8 : : *
9 : : * This library is free software; you can redistribute it and/or
10 : : * modify it under the terms of the GNU Lesser General Public
11 : : * License as published by the Free Software Foundation; either
12 : : * version 2.1 of the License, or (at your option) any later version.
13 : : *
14 : : */
15 : :
16 : : #include <memory.h>
17 : : #include <algorithm>
18 : :
19 : : #include "SparseTag.hpp"
20 : : #include "moab/Range.hpp"
21 : : #include "TagCompare.hpp"
22 : : #include "SysUtil.hpp"
23 : : #include "SequenceManager.hpp"
24 : : #include "moab/Error.hpp"
25 : : #include "moab/ErrorHandler.hpp"
26 : : #include "moab/CN.hpp"
27 : :
28 : : namespace moab
29 : : {
30 : :
31 : 2119 : SparseTag::SparseTag( const char* name, int size, DataType type, const void* default_value )
32 [ + - ][ + - ]: 2119 : : TagInfo( name, size, type, default_value, size )
33 : : {
34 : 2119 : }
35 : :
36 : 6282 : SparseTag::~SparseTag()
37 : : {
38 : 2094 : release_all_data( 0, 0, true );
39 [ - + ]: 4188 : }
40 : :
41 : 1706 : TagType SparseTag::get_storage_type() const
42 : : {
43 : 1706 : return MB_TAG_SPARSE;
44 : : }
45 : :
46 : 4701 : ErrorCode SparseTag::release_all_data( SequenceManager*, Error*, bool )
47 : : {
48 [ + - ][ + - ]: 11266 : for( MapType::iterator i = mData.begin(); i != mData.end(); ++i )
[ + + ]
49 [ + - ][ + - ]: 6565 : mAllocator.destroy( i->second );
50 : 4701 : mData.clear();
51 : 4701 : return MB_SUCCESS;
52 : : }
53 : :
54 : 6780 : ErrorCode SparseTag::set_data( Error*, EntityHandle entity_handle, const void* data )
55 : : {
56 : : #ifdef MOAB_HAVE_UNORDERED_MAP
57 [ + - ]: 6780 : MapType::iterator iter = mData.find( entity_handle );
58 : : #else
59 : : MapType::iterator iter = mData.lower_bound( entity_handle );
60 : : #endif
61 : :
62 : : // Data space already exists
63 [ + - ][ + + ]: 6780 : if( iter != mData.end() && iter->first == entity_handle ) memcpy( iter->second, data, get_size() );
[ + - ][ + - ]
[ + - ][ + + ]
[ + - ][ + - ]
[ # # ]
64 : : // We need to make some data space
65 : : else
66 : : {
67 [ + - ][ + - ]: 6013 : void* new_data = allocate_data( entity_handle, iter, false );
68 [ + - ]: 6013 : memcpy( new_data, data, get_size() );
69 : : }
70 : :
71 : 6780 : return MB_SUCCESS;
72 : : }
73 : :
74 : 25838 : ErrorCode SparseTag::get_data_ptr( EntityHandle entity_handle, const void*& ptr, bool allocate ) const
75 : : {
76 [ + - ]: 25838 : MapType::const_iterator iter = mData.find( entity_handle );
77 : :
78 [ + - ][ + + ]: 25838 : if( iter != mData.end() )
79 [ + - ]: 19319 : ptr = iter->second;
80 [ + - ][ + + ]: 6519 : else if( get_default_value() && allocate )
[ + + ][ + + ]
81 [ + - ]: 1149 : ptr = const_cast< SparseTag* >( this )->allocate_data( entity_handle, iter, allocate );
82 : : else
83 : 5370 : return MB_FAILURE;
84 : :
85 : 25838 : return MB_SUCCESS;
86 : : }
87 : :
88 : 19548 : ErrorCode SparseTag::get_data( Error* /* error */, EntityHandle entity_handle, void* data ) const
89 : : {
90 : 19548 : const void* ptr = 0;
91 [ + - ]: 19548 : ErrorCode rval = get_data_ptr( entity_handle, ptr, false );
92 [ + + ]: 19548 : if( MB_SUCCESS == rval )
93 : : {
94 [ + - ]: 14255 : memcpy( data, ptr, get_size() );
95 : 14255 : return rval;
96 : : }
97 [ + - ][ + + ]: 5293 : else if( get_default_value() )
98 : : {
99 [ + - ][ + - ]: 5146 : memcpy( data, get_default_value(), get_size() );
100 : 5146 : return MB_SUCCESS;
101 : : }
102 : : else
103 : 19548 : return MB_TAG_NOT_FOUND;
104 : : }
105 : :
106 : 5342 : ErrorCode SparseTag::remove_data( Error* /* error */, EntityHandle entity_handle )
107 : : {
108 [ + - ]: 5342 : MapType::iterator i = mData.find( entity_handle );
109 [ + - ][ + + ]: 5342 : if( i == mData.end() ) return MB_TAG_NOT_FOUND;
110 : :
111 [ + - ][ + - ]: 356 : mAllocator.destroy( i->second );
112 [ + - ]: 356 : mData.erase( i );
113 : :
114 : 5342 : return MB_SUCCESS;
115 : : }
116 : :
117 : 17587 : ErrorCode SparseTag::get_data( const SequenceManager*, Error* /* error */, const EntityHandle* entities,
118 : : size_t num_entities, void* data ) const
119 : : {
120 : : ErrorCode rval;
121 : 17587 : unsigned char* ptr = reinterpret_cast< unsigned char* >( data );
122 [ + + ]: 35132 : for( size_t i = 0; i < num_entities; ++i, ptr += get_size() )
123 : : {
124 : 17687 : rval = get_data( NULL, entities[i], ptr );
125 [ + + ]: 17687 : if( MB_SUCCESS != rval ) return rval;
126 : : }
127 : :
128 : 17445 : return MB_SUCCESS;
129 : : }
130 : :
131 : 176 : ErrorCode SparseTag::get_data( const SequenceManager*, Error* /* error */, const Range& entities, void* data ) const
132 : : {
133 : : ErrorCode rval;
134 : 176 : unsigned char* ptr = reinterpret_cast< unsigned char* >( data );
135 [ + - ]: 176 : Range::const_iterator i;
136 [ + - ][ + - ]: 2032 : for( i = entities.begin(); i != entities.end(); ++i, ptr += get_size() )
[ + - ][ + - ]
[ + - ][ + + ]
137 : : {
138 [ + - ][ + - ]: 1861 : rval = get_data( NULL, *i, ptr );
139 [ + + ]: 1861 : if( MB_SUCCESS != rval ) return rval;
140 : : }
141 : :
142 : 176 : return MB_SUCCESS;
143 : : }
144 : :
145 : 270 : ErrorCode SparseTag::get_data( const SequenceManager*, Error* /* error */, const EntityHandle* entities,
146 : : size_t num_entities, const void** pointers, int* data_lengths ) const
147 : : {
148 [ + + ]: 270 : if( data_lengths )
149 : : {
150 [ + - ]: 264 : int len = get_size();
151 [ + - ]: 264 : SysUtil::setmem( data_lengths, &len, sizeof( int ), num_entities );
152 : : }
153 : :
154 : 270 : ErrorCode rval = MB_SUCCESS, rval_tmp;
155 [ + + ]: 464 : for( size_t i = 0; i < num_entities; ++i, ++pointers )
156 : : {
157 : 270 : rval_tmp = get_data_ptr( entities[i], *pointers );
158 [ + + ][ - + ]: 270 : if( MB_SUCCESS != rval_tmp && get_default_value() ) { *pointers = get_default_value(); }
[ - + ]
159 [ + + ]: 270 : else if( MB_SUCCESS != rval_tmp )
160 : : {
161 : 76 : return MB_TAG_NOT_FOUND;
162 : : }
163 : : }
164 : :
165 : 270 : return rval;
166 : : }
167 : :
168 : 14 : ErrorCode SparseTag::get_data( const SequenceManager*, Error* /* error */, const Range& entities, const void** pointers,
169 : : int* data_lengths ) const
170 : : {
171 [ + + ]: 14 : if( data_lengths )
172 : : {
173 [ + - ]: 2 : int len = get_size();
174 [ + - ][ + - ]: 2 : SysUtil::setmem( data_lengths, &len, sizeof( int ), entities.size() );
175 : : }
176 : :
177 : 14 : ErrorCode rval = MB_SUCCESS, rval_tmp;
178 [ + - ]: 14 : Range::const_iterator i;
179 [ + - ][ + - ]: 153 : for( i = entities.begin(); i != entities.end(); ++i, ++pointers )
[ + - ][ + - ]
[ + + ]
180 : : {
181 [ + - ][ + - ]: 140 : rval_tmp = get_data_ptr( *i, *pointers );
182 [ + + ][ + - ]: 140 : if( MB_SUCCESS != rval_tmp && get_default_value() ) { *pointers = get_default_value(); }
[ - + ][ - + ]
[ # # ]
183 [ + + ]: 140 : else if( MB_SUCCESS != rval_tmp )
184 : : {
185 : 1 : return MB_TAG_NOT_FOUND;
186 : : }
187 : : }
188 : :
189 : 14 : return rval;
190 : : }
191 : :
192 : 3751 : ErrorCode SparseTag::set_data( SequenceManager* seqman, Error* /* error */, const EntityHandle* entities,
193 : : size_t num_entities, const void* data )
194 : : {
195 [ + + ][ - + ]: 3751 : ErrorCode rval = seqman->check_valid_entities( NULL, entities, num_entities, true );MB_CHK_ERR( rval );
196 : :
197 : 3741 : const unsigned char* ptr = reinterpret_cast< const unsigned char* >( data );
198 [ + + ]: 7660 : for( size_t i = 0; i < num_entities; ++i, ptr += get_size() )
199 : : {
200 [ - + ][ # # ]: 3919 : rval = set_data( NULL, entities[i], ptr );MB_CHK_ERR( rval );
201 : : }
202 : :
203 : 3741 : return MB_SUCCESS;
204 : : }
205 : :
206 : 199 : ErrorCode SparseTag::set_data( SequenceManager* seqman, Error* /* error */, const Range& entities, const void* data )
207 : : {
208 [ + - ][ + + ]: 199 : ErrorCode rval = seqman->check_valid_entities( NULL, entities );MB_CHK_ERR( rval );
[ - + ][ + - ]
209 : :
210 : 197 : const unsigned char* ptr = reinterpret_cast< const unsigned char* >( data );
211 [ + - ]: 197 : Range::const_iterator i;
212 [ + - ][ + - ]: 3010 : for( i = entities.begin(); i != entities.end(); ++i, ptr += get_size() )
[ + - ][ + - ]
[ + - ][ + + ]
213 [ + - ][ + - ]: 2813 : if( MB_SUCCESS != ( rval = set_data( NULL, *i, ptr ) ) ) return rval;
[ - + ]
214 : :
215 : 199 : return MB_SUCCESS;
216 : : }
217 : :
218 : 6 : ErrorCode SparseTag::set_data( SequenceManager* seqman, Error* /* error */, const EntityHandle* entities,
219 : : size_t num_entities, void const* const* pointers, const int* lengths )
220 : : {
221 [ - + ][ # # ]: 6 : ErrorCode rval = validate_lengths( NULL, lengths, num_entities );MB_CHK_ERR( rval );
222 : :
223 [ + + ][ - + ]: 6 : rval = seqman->check_valid_entities( NULL, entities, num_entities, true );MB_CHK_ERR( rval );
224 : :
225 [ + + ]: 8 : for( size_t i = 0; i < num_entities; ++i, ++pointers )
226 : : {
227 [ - + ][ # # ]: 4 : rval = set_data( NULL, entities[i], *pointers );MB_CHK_ERR( rval );
228 : : }
229 : :
230 : 4 : return MB_SUCCESS;
231 : : }
232 : :
233 : 4 : ErrorCode SparseTag::set_data( SequenceManager* seqman, Error* /* error */, const Range& entities,
234 : : void const* const* pointers, const int* lengths )
235 : : {
236 [ + - ][ + - ]: 4 : ErrorCode rval = validate_lengths( NULL, lengths, entities.size() );MB_CHK_ERR( rval );
[ - + ][ # # ]
[ # # ]
237 : :
238 [ + - ][ + + ]: 4 : rval = seqman->check_valid_entities( NULL, entities );MB_CHK_ERR( rval );
[ - + ][ + - ]
239 : :
240 [ + - ]: 2 : Range::const_iterator i;
241 [ + - ][ + - ]: 22 : for( i = entities.begin(); i != entities.end(); ++i, ++pointers )
[ + - ][ + - ]
[ + + ]
242 : : {
243 [ + - ][ + - ]: 20 : rval = set_data( NULL, *i, *pointers );MB_CHK_ERR( rval );
[ - + ][ # # ]
[ # # ]
244 : : }
245 : :
246 : 4 : return MB_SUCCESS;
247 : : }
248 : :
249 : 4 : ErrorCode SparseTag::clear_data( SequenceManager* seqman, Error* /* error */, const EntityHandle* entities,
250 : : size_t num_entities, const void* value_ptr, int value_len )
251 : : {
252 [ - + ][ # # ]: 4 : if( value_len && value_len != get_size() )
[ - + ]
253 : : {
254 [ # # ][ # # ]: 0 : MB_SET_ERR( MB_INVALID_SIZE, "Invalid data size " << get_size() << " specified for sparse tag " << get_name()
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
255 : : << " of size " << value_len );
256 : : }
257 : :
258 [ - + ][ # # ]: 4 : ErrorCode rval = seqman->check_valid_entities( NULL, entities, num_entities, true );MB_CHK_ERR( rval );
259 : :
260 [ + + ]: 8 : for( size_t i = 0; i < num_entities; ++i )
261 : : {
262 [ - + ][ # # ]: 4 : rval = set_data( NULL, entities[i], value_ptr );MB_CHK_ERR( rval );
263 : : }
264 : :
265 : 4 : return MB_SUCCESS;
266 : : }
267 : :
268 : 2 : ErrorCode SparseTag::clear_data( SequenceManager* seqman, Error* /* error */, const Range& entities,
269 : : const void* value_ptr, int value_len )
270 : : {
271 [ - + ][ # # ]: 2 : if( value_len && value_len != get_size() )
[ # # ][ - + ]
272 : : {
273 [ # # ][ # # ]: 0 : MB_SET_ERR( MB_INVALID_SIZE, "Invalid data size " << get_size() << " specified for sparse tag " << get_name()
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
274 : : << " of size " << value_len );
275 : : }
276 : :
277 [ + - ][ - + ]: 2 : ErrorCode rval = seqman->check_valid_entities( NULL, entities );MB_CHK_ERR( rval );
[ # # ][ # # ]
278 : :
279 [ + - ]: 2 : Range::const_iterator i;
280 [ + - ][ + - ]: 22 : for( i = entities.begin(); i != entities.end(); ++i )
[ + - ][ + - ]
[ + + ]
281 : : {
282 [ + - ][ + - ]: 20 : rval = set_data( NULL, *i, value_ptr );MB_CHK_ERR( rval );
[ - + ][ # # ]
[ # # ]
283 : : }
284 : :
285 : 2 : return MB_SUCCESS;
286 : : }
287 : :
288 : 4927 : ErrorCode SparseTag::remove_data( SequenceManager*, Error* /* error */, const EntityHandle* entities,
289 : : size_t num_entities )
290 : : {
291 : : ErrorCode rval;
292 [ + + ]: 5261 : for( size_t i = 0; i < num_entities; ++i )
293 : : {
294 : 5129 : rval = remove_data( NULL, entities[i] );
295 [ + + ]: 5129 : if( MB_SUCCESS != rval ) return rval;
296 : : }
297 : :
298 : 132 : return MB_SUCCESS;
299 : : }
300 : :
301 : 361 : ErrorCode SparseTag::remove_data( SequenceManager*, Error* /* error */, const Range& entities )
302 : : {
303 [ + - ][ + - ]: 383 : for( Range::const_iterator i = entities.begin(); i != entities.end(); ++i )
[ + - ][ + - ]
[ + + ]
304 [ + - ][ + - ]: 213 : if( MB_SUCCESS != remove_data( NULL, *i ) ) return MB_TAG_NOT_FOUND;
[ + + ]
305 : :
306 : 361 : return MB_SUCCESS;
307 : : }
308 : :
309 : 5882 : ErrorCode SparseTag::tag_iterate( SequenceManager* seqman, Error* /* error */, Range::iterator& iter,
310 : : const Range::iterator& end, void*& data_ptr, bool allocate )
311 : : {
312 : : // Note: We are asked to returning a block of contiguous storage
313 : : // for some block of contiguous handles for which the tag
314 : : // storage is also contiguous. As sparse tag storage is
315 : : // never contiguous, all we can do is return a pointer to the
316 : : // data for the first entity.
317 : :
318 : : // If asked for nothing, successfully return nothing.
319 [ + - ][ - + ]: 5882 : if( iter == end ) return MB_SUCCESS;
320 : :
321 : : // Note: get_data_ptr will return the default value if the
322 : : // handle is not found, so test to make sure that the
323 : : // handle is valid.
324 [ + - ][ + - ]: 5882 : ErrorCode rval = seqman->check_valid_entities( NULL, &*iter, 1 );MB_CHK_ERR( rval );
[ + + ][ - + ]
[ + - ]
325 : :
326 : : // Get pointer to tag storage for entity pointed to by iter
327 : 5880 : const void* ptr = NULL;
328 [ + - ][ + - ]: 5880 : rval = get_data_ptr( *iter, ptr );
329 [ + - ]: 5880 : if( MB_SUCCESS == rval )
330 : 5880 : data_ptr = const_cast< void* >( ptr );
331 [ # # ][ # # ]: 0 : else if( get_default_value() && allocate )
[ # # ][ # # ]
332 : : {
333 [ # # ][ # # ]: 0 : ptr = allocate_data( *iter, mData.end() );
[ # # ]
334 : 0 : data_ptr = const_cast< void* >( ptr );
335 : : }
336 : : else
337 : : {
338 : : // If allocation was not requested, need to increment the iterator so that
339 : : // the count can be computed properly
340 [ # # ][ # # ]: 0 : if( get_default_value() && !allocate ) ++iter;
[ # # ][ # # ]
[ # # ]
341 : : // return not_found(get_name(), *iter);
342 : : }
343 : :
344 : : // Increment iterator and return
345 [ + - ]: 5880 : ++iter;
346 : 5882 : return MB_SUCCESS;
347 : : }
348 : :
349 : : template < class Container >
350 : 18 : static inline void get_tagged( const SparseTag::MapType& mData, EntityType type, Container& output_range )
351 : : {
352 [ + - ][ # # ]: 18 : SparseTag::MapType::const_iterator iter;
353 [ + - ][ # # ]: 18 : typename Container::iterator hint = output_range.begin();
354 [ + - ][ # # ]: 18 : if( MBMAXTYPE == type )
355 : : {
356 [ + - ][ + - ]: 20 : for( iter = mData.begin(); iter != mData.end(); ++iter )
[ + + ][ # # ]
[ # # ][ # # ]
357 [ + - ][ + - ]: 2 : hint = output_range.insert( hint, iter->first );
[ # # ][ # # ]
358 : : }
359 : : else
360 : : {
361 : : #ifdef MOAB_HAVE_UNORDERED_MAP
362 [ # # ][ # # ]: 0 : for( iter = mData.begin(); iter != mData.end(); ++iter )
[ # # ][ # # ]
[ # # ][ # # ]
363 [ # # ][ # # ]: 0 : if( TYPE_FROM_HANDLE( iter->first ) == type ) hint = output_range.insert( hint, iter->first );
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
364 : : #else
365 : : iter = mData.lower_bound( FIRST_HANDLE( type ) );
366 : : SparseTag::MapType::const_iterator end = mData.lower_bound( LAST_HANDLE( type ) + 1 );
367 : : for( ; iter != end; ++iter )
368 : : hint = output_range.insert( hint, iter->first );
369 : : #endif
370 : : }
371 : 18 : }
372 : :
373 : : template < class Container >
374 : 659 : static inline void get_tagged( const SparseTag::MapType& mData, Range::const_iterator begin, Range::const_iterator end,
375 : : Container& output_range )
376 : : {
377 [ + - ]: 659 : typename Container::iterator hint = output_range.begin();
378 [ + - ][ + - ]: 644447 : for( Range::const_iterator i = begin; i != end; ++i )
[ + + ][ + - ]
[ + - ][ + + ]
379 [ + - ][ + - ]: 643788 : if( mData.find( *i ) != mData.end() ) hint = output_range.insert( hint, *i );
[ + - ][ + + ]
[ + - ][ + - ]
[ + - ][ + - ]
[ + - ][ + + ]
[ + - ][ + - ]
380 : 659 : }
381 : :
382 : : template < class Container >
383 : 677 : static inline void get_tagged( const SparseTag::MapType& mData, Container& entities, EntityType type,
384 : : const Range* intersect )
385 : : {
386 [ + + ][ - + ]: 677 : if( !intersect )
387 : 18 : get_tagged< Container >( mData, type, entities );
388 [ + - ][ + + ]: 659 : else if( MBMAXTYPE == type )
389 : 382 : get_tagged< Container >( mData, intersect->begin(), intersect->end(), entities );
390 : : else
391 : : {
392 [ # # ][ + - ]: 277 : std::pair< Range::iterator, Range::iterator > r = intersect->equal_range( type );
393 [ # # ][ + - ]: 277 : get_tagged< Container >( mData, r.first, r.second, entities );
394 : : }
395 : 677 : }
396 : :
397 : : //! Gets all entity handles that match a type and tag
398 : 641 : ErrorCode SparseTag::get_tagged_entities( const SequenceManager*, Range& output_range, EntityType type,
399 : : const Range* intersect ) const
400 : : {
401 : 641 : get_tagged( mData, output_range, type, intersect );
402 : 641 : return MB_SUCCESS;
403 : : }
404 : :
405 : : //! Gets all entity handles that match a type and tag
406 : 36 : ErrorCode SparseTag::num_tagged_entities( const SequenceManager*, size_t& output_count, EntityType type,
407 : : const Range* intersect ) const
408 : : {
409 [ + - ]: 36 : InsertCount counter( output_count );
410 [ + - ]: 36 : get_tagged( mData, counter, type, intersect );
411 [ + - ]: 36 : output_count = counter.end();
412 : 36 : return MB_SUCCESS;
413 : : }
414 : :
415 : 1203 : ErrorCode SparseTag::find_entities_with_value(
416 : : #ifdef MOAB_HAVE_UNORDERED_MAP
417 : : const SequenceManager* seqman,
418 : : #else
419 : : const SequenceManager*,
420 : : #endif
421 : : Error* /* error */, Range& output_entities, const void* value, int value_bytes, EntityType type,
422 : : const Range* intersect_entities ) const
423 : : {
424 [ - + ][ # # ]: 1203 : if( value_bytes && value_bytes != get_size() )
[ # # ][ - + ]
425 : : {
426 [ # # ][ # # ]: 0 : MB_SET_ERR( MB_INVALID_SIZE, "Invalid data size " << get_size() << " specified for sparse tag " << get_name()
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
427 : : << " of size " << value_bytes );
428 : : }
429 : :
430 [ + - ][ + - ]: 1203 : MapType::const_iterator iter, end;
431 : : #ifdef MOAB_HAVE_UNORDERED_MAP
432 [ + - ]: 1203 : if( intersect_entities )
433 : : {
434 [ + - ]: 1203 : std::pair< Range::iterator, Range::iterator > r;
435 [ + + ]: 1203 : if( type == MBMAXTYPE )
436 : : {
437 [ + - ]: 24 : r.first = intersect_entities->begin();
438 [ + - ]: 24 : r.second = intersect_entities->end();
439 : : }
440 : : else
441 : : {
442 [ + - ]: 1179 : r = intersect_entities->equal_range( type );
443 : : }
444 : :
445 [ + - ][ + - ]: 1203 : find_map_values_equal( *this, value, get_size(), r.first, r.second, mData, output_entities );
446 : : }
447 [ # # ]: 0 : else if( type == MBMAXTYPE )
448 : : {
449 [ # # ][ # # ]: 0 : find_tag_values_equal( *this, value, get_size(), mData.begin(), mData.end(), output_entities );
450 : : }
451 : : else
452 : : {
453 [ # # ]: 0 : Range tmp;
454 [ # # ]: 0 : seqman->get_entities( type, tmp );
455 [ # # ][ # # ]: 0 : find_map_values_equal( *this, value, get_size(), tmp.begin(), tmp.end(), mData, output_entities );
[ # # ][ # # ]
456 : : }
457 : : #else
458 : : if( intersect_entities )
459 : : {
460 : : for( Range::const_pair_iterator p = intersect_entities->begin(); p != intersect_entities->end(); ++p )
461 : : {
462 : : iter = mData.lower_bound( p->first );
463 : : end = mData.upper_bound( p->second );
464 : : find_tag_values_equal( *this, value, get_size(), iter, end, output_entities );
465 : : }
466 : : }
467 : : else
468 : : {
469 : : if( type == MBMAXTYPE )
470 : : {
471 : : iter = mData.begin();
472 : : end = mData.end();
473 : : }
474 : : else
475 : : {
476 : : iter = mData.lower_bound( CREATE_HANDLE( type, MB_START_ID ) );
477 : : end = mData.upper_bound( CREATE_HANDLE( type, MB_END_ID ) );
478 : : }
479 : : find_tag_values_equal( *this, value, get_size(), iter, end, output_entities );
480 : : }
481 : : #endif
482 : :
483 : 1203 : return MB_SUCCESS;
484 : : }
485 : :
486 : 687 : bool SparseTag::is_tagged( const SequenceManager*, EntityHandle h ) const
487 : : {
488 [ + - ][ + - ]: 687 : return mData.find( h ) != mData.end();
489 : : }
490 : :
491 : 36 : ErrorCode SparseTag::get_memory_use( const SequenceManager*, unsigned long& total, unsigned long& per_entity ) const
492 : :
493 : : {
494 : 36 : per_entity = get_size() + 4 * sizeof( void* );
495 : 36 : total = ( mData.size() * per_entity ) + sizeof( *this ) + TagInfo::get_memory_use();
496 : :
497 : 36 : return MB_SUCCESS;
498 : : }
499 : :
500 : : } // namespace moab
|
