Branch data Line data Source code
1 : : #include "BitTag.hpp"
2 : : #include "BitPage.hpp"
3 : : #include "moab/Range.hpp"
4 : : #include "TagCompare.hpp"
5 : : #include "SequenceManager.hpp"
6 : : #include "moab/Error.hpp"
7 : : #include "moab/ErrorHandler.hpp"
8 : : #include <stdlib.h>
9 : : #include <string.h>
10 : :
11 : : namespace moab
12 : : {
13 : :
14 [ + - ][ + + ]: 2400 : BitTag::~BitTag()
15 : : {
16 : 160 : release_all_data( 0, 0, true );
17 [ - + ]: 320 : }
18 : :
19 : 24 : TagType BitTag::get_storage_type() const
20 : : {
21 : 24 : return MB_TAG_BIT;
22 : : }
23 : :
24 : 160 : BitTag* BitTag::create_tag( const char* name, int size, const void* default_value )
25 : : {
26 [ + - ]: 160 : BitTag* result = new BitTag( name, size, default_value );
27 [ - + ]: 160 : if( MB_SUCCESS != result->reserve( size ) )
28 : : {
29 [ # # ]: 0 : delete result;
30 : 0 : result = NULL;
31 : : }
32 : :
33 : 160 : return result;
34 : : }
35 : :
36 : 160 : ErrorCode BitTag::reserve( unsigned bits )
37 : : {
38 [ - + ]: 160 : if( bits > 8 ) return MB_FAILURE;
39 : :
40 : 160 : requestedBitsPerEntity = bits;
41 : : // Store smallest power of two greater than or
42 : : // equal to the number of bits
43 : 160 : storedBitsPerEntity = 1;
44 : 160 : unsigned ln2storedbits = 0;
45 [ + + ]: 183 : while( storedBitsPerEntity < bits )
46 : : {
47 : 23 : storedBitsPerEntity *= 2;
48 : 23 : ++ln2storedbits;
49 : : }
50 : :
51 : : // pageShift = log2(ents_per_page())
52 : : // = log2(8 * pageSize / storedBitsPerEntity )
53 : : // = log2(8) + log2(pageSize) - log2(storedBitsPerEntity)
54 : : // = 3 + Ln2PageSize - ln2storedbits;
55 : 160 : pageShift = 3 + Ln2PageSize - ln2storedbits;
56 : :
57 : 160 : return MB_SUCCESS;
58 : : }
59 : :
60 : 320 : ErrorCode BitTag::release_all_data( SequenceManager*, Error*, bool )
61 : : {
62 [ + - ][ + + ]: 4160 : for( EntityType t = (EntityType)0; t != MBMAXTYPE; ++t )
63 : : {
64 [ + + ]: 4028 : for( size_t i = 0; i < pageList[t].size(); ++i )
65 [ + - ]: 188 : delete pageList[t][i];
66 : 3840 : pageList[t].clear();
67 : : }
68 : :
69 : 320 : return MB_SUCCESS;
70 : : }
71 : :
72 : 2520767 : ErrorCode BitTag::get_data( const SequenceManager*, Error*, const EntityHandle* handles, size_t num_handles,
73 : : void* gen_data ) const
74 : : {
75 : : EntityType type;
76 : : size_t page;
77 : : int offset;
78 [ + - ]: 2520767 : unsigned char def = default_val();
79 : 2520767 : unsigned char* data = reinterpret_cast< unsigned char* >( gen_data );
80 [ + + ]: 5091116 : for( size_t i = 0; i < num_handles; ++i )
81 : : {
82 [ + - ]: 2570349 : unpack( handles[i], type, page, offset );
83 [ + + ][ + - ]: 2570349 : if( pageList[type].size() <= page || !pageList[type][page] )
[ - + ][ + + ]
84 : 44133 : data[i] = def;
85 : : else
86 [ + - ][ + - ]: 2526216 : data[i] = pageList[type][page]->get_bits( offset, storedBitsPerEntity );
87 : : }
88 : :
89 : 2520767 : return MB_SUCCESS;
90 : : }
91 : :
92 : 4268012 : ErrorCode BitTag::set_data( SequenceManager* seqman, Error* /* error */, const EntityHandle* handles,
93 : : size_t num_handles, const void* gen_data )
94 : : {
95 [ + - ][ + + ]: 4268012 : ErrorCode rval = seqman->check_valid_entities( NULL, handles, num_handles, true );MB_CHK_ERR( rval );
[ - + ][ + - ]
96 : :
97 : : EntityType type;
98 : : size_t page;
99 : : int offset;
100 : 4268010 : const unsigned char* data = reinterpret_cast< const unsigned char* >( gen_data );
101 [ + + ]: 8536068 : for( size_t i = 0; i < num_handles; ++i )
102 : : {
103 [ + - ]: 4268058 : unpack( handles[i], type, page, offset );
104 [ + + ][ + - ]: 4268058 : if( pageList[type].size() <= page ) pageList[type].resize( page + 1, 0 );
105 [ + - ][ + + ]: 4268058 : if( !pageList[type][page] ) pageList[type][page] = new BitPage( storedBitsPerEntity, default_val() );
[ + - ][ + - ]
[ + - ][ + - ]
106 [ + - ][ + - ]: 4268058 : pageList[type][page]->set_bits( offset, storedBitsPerEntity, data[i] );
107 : : }
108 : :
109 : 4268012 : return MB_SUCCESS;
110 : : }
111 : :
112 : 0 : ErrorCode BitTag::clear_data( SequenceManager* seqman, Error* /* error */, const EntityHandle* handles,
113 : : size_t num_handles, const void* value_ptr, int value_len )
114 : : {
115 [ # # ]: 0 : if( value_len ) return MB_INVALID_SIZE;
116 : :
117 [ # # ][ # # ]: 0 : ErrorCode rval = seqman->check_valid_entities( NULL, handles, num_handles, true );MB_CHK_ERR( rval );
[ # # ][ # # ]
118 : :
119 : : EntityType type;
120 : : size_t page;
121 : : int offset;
122 : 0 : const unsigned char value = *reinterpret_cast< const unsigned char* >( value_ptr );
123 [ # # ]: 0 : for( size_t i = 0; i < num_handles; ++i )
124 : : {
125 [ # # ]: 0 : unpack( handles[i], type, page, offset );
126 [ # # ][ # # ]: 0 : if( pageList[type].size() <= page ) pageList[type].resize( page + 1, 0 );
127 [ # # ][ # # ]: 0 : if( !pageList[type][page] ) pageList[type][page] = new BitPage( storedBitsPerEntity, default_val() );
[ # # ][ # # ]
[ # # ][ # # ]
128 [ # # ][ # # ]: 0 : pageList[type][page]->set_bits( offset, storedBitsPerEntity, value );
129 : : }
130 : :
131 : 0 : return MB_SUCCESS;
132 : : }
133 : :
134 : 191 : ErrorCode BitTag::remove_data( SequenceManager*, Error*, const EntityHandle* handles, size_t num_handles )
135 : : {
136 : : EntityType type;
137 : : size_t page;
138 : : int offset;
139 [ + - ]: 191 : const unsigned char val = default_val();
140 [ + + ]: 3052 : for( size_t i = 0; i < num_handles; ++i )
141 : : {
142 [ + - ]: 2861 : unpack( handles[i], type, page, offset );
143 [ + + ][ + - ]: 2861 : if( pageList[type].size() > page && pageList[type][page] )
[ + - ][ + + ]
144 [ + - ][ + - ]: 181 : pageList[type][page]->set_bits( offset, storedBitsPerEntity, val );
145 : : }
146 : :
147 : 191 : return MB_SUCCESS;
148 : : }
149 : :
150 : 6 : ErrorCode BitTag::get_data( const SequenceManager*, Error*, const Range& handles, void* gen_data ) const
151 : : {
152 : : EntityType type;
153 : : EntityID count;
154 : : size_t page;
155 [ + - ]: 6 : int offset, per_page = ents_per_page();
156 [ + - ]: 6 : unsigned char def = default_val();
157 : 6 : unsigned char* data = reinterpret_cast< unsigned char* >( gen_data );
158 [ + - ]: 6 : Range::const_pair_iterator i;
159 [ + - ][ + - ]: 12 : for( i = handles.const_pair_begin(); i != handles.const_pair_end(); ++i )
[ + - ][ + - ]
[ + + ]
160 : : {
161 [ + - ][ + - ]: 6 : unpack( i->first, type, page, offset );
162 [ + - ][ + - ]: 6 : assert( TYPE_FROM_HANDLE( i->second ) == type ); // Should be true because id of zero is never used
[ - + ]
163 [ + - ][ + - ]: 6 : count = i->second - i->first + 1;
164 [ - + ]: 6 : if( page >= pageList[type].size() )
165 : : {
166 : 0 : memset( data, def, count );
167 : 0 : data += count;
168 : 0 : continue;
169 : : }
170 : :
171 [ + + ]: 15 : while( count )
172 : : {
173 [ + - ]: 9 : size_t pcount = std::min( ( EntityID )( per_page - offset ), count );
174 [ + - ][ + - ]: 9 : if( pageList[type][page] )
175 [ + - ][ + - ]: 9 : pageList[type][page]->get_bits( offset, pcount, storedBitsPerEntity, data );
176 : : else
177 : 0 : memset( data, def, pcount );
178 : 9 : data += pcount;
179 : 9 : count -= pcount;
180 : 9 : offset = 0;
181 : 9 : ++page;
182 : : }
183 : : }
184 : :
185 : 6 : return MB_SUCCESS;
186 : : }
187 : :
188 : 34 : ErrorCode BitTag::set_data( SequenceManager* seqman, Error* /* error */, const Range& handles, const void* gen_data )
189 : : {
190 [ + - ][ + + ]: 34 : ErrorCode rval = seqman->check_valid_entities( NULL, handles );MB_CHK_ERR( rval );
[ - + ][ + - ]
191 : :
192 : : EntityType type;
193 : : EntityID count;
194 : : size_t page;
195 [ + - ]: 32 : int offset, per_page = ents_per_page();
196 [ + - ]: 32 : unsigned char def = default_val();
197 : 32 : const unsigned char* data = reinterpret_cast< const unsigned char* >( gen_data );
198 [ + - ]: 32 : Range::const_pair_iterator i;
199 [ + - ][ + - ]: 337 : for( i = handles.const_pair_begin(); i != handles.const_pair_end(); ++i )
[ + - ][ + - ]
[ + + ]
200 : : {
201 [ + - ][ + - ]: 305 : unpack( i->first, type, page, offset );
202 [ + - ][ + - ]: 305 : assert( TYPE_FROM_HANDLE( i->second ) == type ); // Should be true because id of zero is never used
[ - + ]
203 [ + - ][ + - ]: 305 : count = i->second - i->first + 1;
204 : :
205 [ + + ]: 613 : while( count )
206 : : {
207 [ + + ][ + - ]: 308 : if( page >= pageList[type].size() ) pageList[type].resize( page + 1, 0 );
208 [ + - ][ + + ]: 308 : if( !pageList[type][page] ) pageList[type][page] = new BitPage( storedBitsPerEntity, def );
[ + - ][ + - ]
[ + - ]
209 : :
210 [ + - ]: 308 : size_t pcount = std::min( ( EntityID )( per_page - offset ), count );
211 [ + - ][ + - ]: 308 : pageList[type][page]->set_bits( offset, pcount, storedBitsPerEntity, data );
212 : 308 : data += pcount;
213 : 308 : count -= pcount;
214 : 308 : offset = 0;
215 : 308 : ++page;
216 : : }
217 : : }
218 : :
219 : 34 : return MB_SUCCESS;
220 : : }
221 : :
222 : 1 : ErrorCode BitTag::clear_data( SequenceManager* seqman, Error* /* error */, const Range& handles, const void* value_ptr,
223 : : int value_len )
224 : : {
225 [ - + ]: 1 : if( value_len ) return MB_INVALID_SIZE;
226 : :
227 [ + - ][ - + ]: 1 : ErrorCode rval = seqman->check_valid_entities( NULL, handles );MB_CHK_ERR( rval );
[ # # ][ # # ]
228 : :
229 : : EntityType type;
230 : : EntityID count;
231 : : size_t page;
232 [ + - ]: 1 : int offset, per_page = ents_per_page();
233 : 1 : const unsigned char value = *reinterpret_cast< const unsigned char* >( value_ptr );
234 [ + - ]: 1 : Range::const_pair_iterator i;
235 [ + - ][ + - ]: 6 : for( i = handles.const_pair_begin(); i != handles.const_pair_end(); ++i )
[ + - ][ + - ]
[ + + ]
236 : : {
237 [ + - ][ + - ]: 5 : unpack( i->first, type, page, offset );
238 [ + - ][ + - ]: 5 : assert( TYPE_FROM_HANDLE( i->second ) == type ); // Should be true because id of zero is never used
[ - + ]
239 [ + - ][ + - ]: 5 : count = i->second - i->first + 1;
240 : :
241 [ + + ]: 10 : while( count )
242 : : {
243 [ + + ][ + - ]: 5 : if( page >= pageList[type].size() ) pageList[type].resize( page + 1, 0 );
244 [ + - ][ + + ]: 5 : if( !pageList[type][page] ) pageList[type][page] = new BitPage( storedBitsPerEntity, default_val() );
[ + - ][ + - ]
[ + - ][ + - ]
245 : :
246 [ + - ]: 5 : size_t pcount = std::min( ( EntityID )( per_page - offset ), count );
247 [ + - ][ + - ]: 5 : pageList[type][page]->set_bits( offset, pcount, storedBitsPerEntity, value );
248 : 5 : count -= pcount;
249 : 5 : offset = 0;
250 : 5 : ++page;
251 : : }
252 : : }
253 : :
254 : 1 : return MB_SUCCESS;
255 : : }
256 : :
257 : 8 : ErrorCode BitTag::remove_data( SequenceManager*, Error*, const Range& handles )
258 : : {
259 : : EntityType type;
260 : : EntityID count;
261 : : size_t page;
262 [ + - ]: 8 : int offset, per_page = ents_per_page();
263 [ + - ]: 8 : unsigned char val = default_val();
264 [ + - ]: 8 : Range::const_pair_iterator i;
265 [ + - ][ + - ]: 2308 : for( i = handles.const_pair_begin(); i != handles.const_pair_end(); ++i )
[ + - ][ + - ]
[ + + ]
266 : : {
267 [ + - ][ + - ]: 2300 : unpack( i->first, type, page, offset );
268 [ + - ][ + - ]: 2300 : assert( TYPE_FROM_HANDLE( i->second ) == type ); // Should be true because id of zero is never used
[ - + ]
269 [ + - ][ + - ]: 2300 : count = i->second - i->first + 1;
270 : :
271 [ + + ]: 4600 : while( count )
272 : : {
273 [ + - ]: 2300 : size_t pcount = std::min( ( EntityID )( per_page - offset ), count );
274 [ + + ][ + - ]: 2300 : if( page < pageList[type].size() && pageList[type][page] )
[ + - ][ + + ]
275 [ + - ][ + - ]: 1146 : pageList[type][page]->set_bits( offset, pcount, storedBitsPerEntity, val );
276 : 2300 : count -= pcount;
277 : 2300 : offset = 0;
278 : 2300 : ++page;
279 : : }
280 : : }
281 : :
282 : 8 : return MB_SUCCESS;
283 : : }
284 : :
285 : 0 : ErrorCode BitTag::get_data( const SequenceManager*, Error* /* error */, const EntityHandle*, size_t, const void**,
286 : : int* ) const
287 : : {
288 [ # # ][ # # ]: 0 : MB_SET_ERR( MB_TYPE_OUT_OF_RANGE, "Operation get_data not supported for bit tags" );
[ # # ][ # # ]
[ # # ]
289 : : }
290 : :
291 : 0 : ErrorCode BitTag::get_data( const SequenceManager*, Error* /* error */, const Range&, const void**, int* ) const
292 : : {
293 [ # # ][ # # ]: 0 : MB_SET_ERR( MB_TYPE_OUT_OF_RANGE, "Operation get_data not supported for bit tags" );
[ # # ][ # # ]
[ # # ]
294 : : }
295 : :
296 : 0 : ErrorCode BitTag::set_data( SequenceManager*, Error* /* error */, const EntityHandle*, size_t, void const* const*,
297 : : const int* )
298 : : {
299 [ # # ][ # # ]: 0 : MB_SET_ERR( MB_TYPE_OUT_OF_RANGE, "Operation set_data not supported for bit tags" );
[ # # ][ # # ]
[ # # ]
300 : : }
301 : :
302 : 0 : ErrorCode BitTag::set_data( SequenceManager*, Error* /* error */, const Range&, void const* const*, const int* )
303 : : {
304 [ # # ][ # # ]: 0 : MB_SET_ERR( MB_TYPE_OUT_OF_RANGE, "Operation set_data not supported for bit tags" );
[ # # ][ # # ]
[ # # ]
305 : : }
306 : :
307 : 1 : ErrorCode BitTag::tag_iterate( SequenceManager*, Error* /* error */, Range::iterator&, const Range::iterator&, void*&,
308 : : bool )
309 : : {
310 [ + - ][ + - ]: 1 : MB_SET_ERR( MB_TYPE_OUT_OF_RANGE, "Operation tag_iterate not supported for bit tags" );
[ + - ][ - + ]
[ + - ]
311 : : }
312 : :
313 : : template < class Container >
314 : 0 : inline void BitTag::get_tagged( EntityType type, Container& entities ) const
315 : : {
316 [ # # ][ # # ]: 0 : std::pair< EntityType, EntityType > r = type_range( type );
317 [ # # ][ # # ]: 0 : typename Container::iterator hint = entities.begin();
318 [ # # ][ # # ]: 0 : const int per_page = ents_per_page();
319 [ # # ][ # # ]: 0 : for( EntityType t = r.first; t != r.second; ++t )
[ # # ][ # # ]
320 : : {
321 [ # # ][ # # ]: 0 : for( size_t i = 0; i < pageList[t].size(); ++i )
322 : : {
323 [ # # ][ # # ]: 0 : if( pageList[t][i] )
[ # # ][ # # ]
324 : : {
325 : 0 : EntityID id = i * per_page;
326 [ # # ][ # # ]: 0 : EntityHandle h = CREATE_HANDLE( t, id );
327 : 0 : EntityHandle last = h + per_page - 1;
328 : : // Never zero ID
329 [ # # ][ # # ]: 0 : if( 0 == id ) ++h;
330 [ # # ][ # # ]: 0 : hint = entities.insert( hint, h, last );
331 : : }
332 : : }
333 : : }
334 : 0 : }
335 : :
336 : : template < class Container >
337 : 15 : inline void BitTag::get_tagged( Range::const_iterator begin, Range::const_iterator end, Container& entities ) const
338 : : {
339 : : EntityType type;
340 : : EntityID count;
341 : : size_t page;
342 [ # # ][ + - ]: 15 : int offset, per_page = ents_per_page();
343 [ # # ][ + - ]: 15 : typename Container::iterator hint = entities.begin();
344 : : EntityHandle h;
345 : 15 : Range::const_iterator i = begin;
346 [ # # ][ # # ]: 31 : while( i != end )
[ + - ][ + + ]
347 : : {
348 [ # # ][ + - ]: 16 : h = *i;
349 [ # # ][ + - ]: 16 : unpack( h, type, page, offset );
350 : :
351 [ # # ][ + - ]: 16 : i = i.end_of_block();
352 [ # # ][ + - ]: 16 : count = *i - h + 1;
353 [ # # ][ + - ]: 16 : ++i;
354 [ # # ][ + + ]: 32 : while( count > 0 )
355 : : {
356 [ # # ][ + - ]: 16 : EntityID pcount = std::min( count, ( EntityID )( per_page - offset ) );
357 [ # # ][ # # ]: 16 : if( page < pageList[type].size() && pageList[type][page] )
[ # # ][ # # ]
[ + + ][ + - ]
[ + - ][ + + ]
358 [ # # ][ + - ]: 4 : hint = entities.insert( hint, h, h + pcount - 1 );
359 : :
360 : 16 : count -= pcount;
361 : 16 : h += pcount;
362 [ # # ][ # # ]: 16 : assert( TYPE_FROM_HANDLE( h ) == type );
[ + - ][ - + ]
363 : 16 : offset = 0;
364 : 16 : ++page;
365 : : }
366 : : }
367 : 15 : }
368 : :
369 : : template < class Container >
370 : 15 : inline void BitTag::get_tagged( Container& entities, EntityType type, const Range* intersect ) const
371 : :
372 : : {
373 [ # # ][ - + ]: 15 : if( !intersect )
374 : 0 : get_tagged< Container >( type, entities );
375 [ # # ][ - + ]: 15 : else if( MBMAXTYPE == type )
376 : 0 : get_tagged< Container >( intersect->begin(), intersect->end(), entities );
377 : : else
378 : : {
379 [ # # ][ + - ]: 15 : std::pair< Range::iterator, Range::iterator > r = intersect->equal_range( type );
380 [ # # ][ + - ]: 15 : get_tagged< Container >( r.first, r.second, entities );
381 : : }
382 : 15 : }
383 : :
384 : 15 : ErrorCode BitTag::get_tagged_entities( const SequenceManager*, Range& entities, EntityType type,
385 : : const Range* intersect ) const
386 : : {
387 : 15 : get_tagged< Range >( entities, type, intersect );
388 : 15 : return MB_SUCCESS;
389 : : }
390 : :
391 : 0 : ErrorCode BitTag::num_tagged_entities( const SequenceManager*, size_t& count, EntityType type,
392 : : const Range* intersect ) const
393 : : {
394 [ # # ]: 0 : InsertCount counter( count );
395 [ # # ]: 0 : get_tagged< InsertCount >( counter, type, intersect );
396 [ # # ]: 0 : count = counter.end();
397 : 0 : return MB_SUCCESS;
398 : : }
399 : :
400 : 3 : ErrorCode BitTag::find_entities_with_value( const SequenceManager*, Error* /* error */, Range& output_entities,
401 : : const void* value, int value_bytes, EntityType type,
402 : : const Range* intersect_entities ) const
403 : : {
404 [ - + ][ # # ]: 3 : if( value_bytes && value_bytes != 1 )
405 [ # # ][ # # ]: 0 : { MB_SET_ERR( MB_INVALID_SIZE, "Invalid tag size for bit tag: " << value_bytes << " bytes" ); }
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
406 : :
407 : 3 : const signed char bits = *reinterpret_cast< const unsigned char* >( value );
408 [ + - ]: 3 : if( intersect_entities )
409 : 3 : return get_entities_with_bits( *intersect_entities, type, output_entities, bits );
410 : : else
411 : 3 : return get_entities_with_bits( type, output_entities, bits );
412 : : }
413 : :
414 : 0 : ErrorCode BitTag::get_entities_with_bits( EntityType type, Range& entities, unsigned char bits ) const
415 : : {
416 [ # # ]: 0 : std::pair< EntityType, EntityType > r = type_range( type );
417 [ # # ]: 0 : const int per_page = ents_per_page();
418 [ # # ][ # # ]: 0 : for( EntityType t = r.first; t != r.second; ++t )
419 : : {
420 [ # # ]: 0 : for( size_t i = 0; i < pageList[t].size(); ++i )
421 : : {
422 [ # # ][ # # ]: 0 : if( pageList[t][i] )
423 : : {
424 : 0 : EntityID id = i * per_page;
425 [ # # ]: 0 : EntityHandle h = CREATE_HANDLE( t, id );
426 : 0 : int off = !i; // Never zero ID
427 [ # # ][ # # ]: 0 : pageList[t][i]->search( bits, off, per_page - off, storedBitsPerEntity, entities, h + off );
428 : : }
429 : : }
430 : : }
431 : :
432 : 0 : return MB_SUCCESS;
433 : : }
434 : :
435 : 3 : ErrorCode BitTag::get_entities_with_bits( const Range& range, EntityType in_type, Range& entities,
436 : : unsigned char bits ) const
437 : : {
438 [ - + ]: 3 : if( MBMAXTYPE == in_type )
439 : : {
440 : : ErrorCode rval;
441 [ # # ][ # # ]: 0 : for( --in_type; in_type >= MBVERTEX; --in_type )
[ # # ]
442 : : {
443 [ # # ][ # # ]: 0 : rval = get_entities_with_bits( range, in_type, entities, bits );MB_CHK_ERR( rval );
[ # # ][ # # ]
444 : : }
445 : 0 : return MB_SUCCESS;
446 : : }
447 : :
448 : : EntityType type;
449 : : EntityID count;
450 : : size_t page;
451 [ + - ]: 3 : int offset, per_page = ents_per_page();
452 [ + - ][ + - ]: 3 : Range::const_iterator i, end;
453 [ + - ]: 3 : std::pair< Range::iterator, Range::iterator > r = range.equal_range( in_type );
454 : 3 : i = r.first;
455 : 3 : end = r.second;
456 : : EntityHandle h;
457 [ + - ][ + + ]: 6 : while( i != end )
458 : : {
459 [ + - ]: 3 : h = *i;
460 [ + - ]: 3 : unpack( h, type, page, offset );
461 [ + - ][ - + ]: 3 : assert( MBMAXTYPE == in_type || type == in_type );
462 : :
463 [ + - ]: 3 : i = i.end_of_block();
464 [ + - ]: 3 : count = *i - h + 1;
465 [ + - ]: 3 : ++i;
466 [ + + ]: 9 : while( count > 0 )
467 : : {
468 [ + - ]: 6 : EntityID pcount = std::min( count, ( EntityID )( per_page - offset ) );
469 [ + - ][ + - ]: 6 : if( page < pageList[type].size() && pageList[type][page] )
[ + - ][ + - ]
470 [ + - ][ + - ]: 6 : pageList[type][page]->search( bits, offset, pcount, storedBitsPerEntity, entities, h );
471 : :
472 : 6 : count -= pcount;
473 : 6 : h += pcount;
474 [ + - ][ - + ]: 6 : assert( TYPE_FROM_HANDLE( h ) == type );
475 : 6 : offset = 0;
476 : 6 : ++page;
477 : : }
478 : : }
479 : :
480 : 3 : return MB_SUCCESS;
481 : : }
482 : :
483 : 0 : ErrorCode BitTag::get_memory_use( const SequenceManager*, unsigned long& total, unsigned long& per_entity ) const
484 : : {
485 : 0 : per_entity = ( storedBitsPerEntity > 4 ); // Cannot return fraction of bytes, so round
486 : 0 : total = 0;
487 [ # # ][ # # ]: 0 : for( EntityType t = (EntityType)0; t < MBMAXTYPE; ++t )
488 : : {
489 : 0 : total += pageList[t].capacity() * sizeof( BitPage* );
490 [ # # ]: 0 : for( size_t i = 0; i < pageList[t].size(); ++i )
491 [ # # ][ # # ]: 0 : if( pageList[t][i] ) total += sizeof( BitPage );
492 : : }
493 : :
494 : 0 : return MB_SUCCESS;
495 : : }
496 : :
497 : 38 : bool BitTag::is_tagged( const SequenceManager*, EntityHandle h ) const
498 : : {
499 : : EntityType type;
500 : : size_t page;
501 : : int offset;
502 [ + - ]: 38 : unpack( h, type, page, offset );
503 [ + + ][ + - ]: 38 : return page < pageList[type].size() && pageList[type][page];
[ + - ]
504 : : }
505 : :
506 : : } // namespace moab
|
