Branch data Line data Source code
1 : : /** \file DenseTag.cpp
2 : : * \author Jason Kraftcheck
3 : : * \date 2010-12-14
4 : : */
5 : :
6 : : #include "DenseTag.hpp"
7 : : #include "moab/Range.hpp"
8 : : #include "TagCompare.hpp"
9 : : #include "SysUtil.hpp"
10 : : #include "SequenceManager.hpp"
11 : : #include "SequenceData.hpp"
12 : : #include "moab/Error.hpp"
13 : : #include "moab/ErrorHandler.hpp"
14 : : #include "moab/CN.hpp"
15 : : #include <utility>
16 : :
17 : : namespace moab
18 : : {
19 : :
20 : 20 : inline static ErrorCode not_found( const std::string& /*name*/, EntityHandle /*h*/ )
21 : : {
22 : : // MB_TAG_NOT_FOUND could be a non-error condition, do not call MB_SET_ERR on it
23 : : #if 0
24 : : if (h)
25 : : fprintf(stderr, "[Warning]: No dense tag %s value for %s %ld\n",
26 : : name.c_str(),
27 : : CN::EntityTypeName(TYPE_FROM_HANDLE(h)),
28 : : (unsigned long)ID_FROM_HANDLE(h));
29 : : else
30 : : fprintf(stderr, "[Warning]: No dense tag %s value for root set\n", name.c_str());
31 : : #endif
32 : :
33 : 20 : return MB_TAG_NOT_FOUND;
34 : : }
35 : :
36 : 21622 : inline static ErrorCode ent_not_found( const std::string& /*name*/, EntityHandle /*h*/ )
37 : : {
38 : : // MB_ENTITY_NOT_FOUND could be a non-error condition, do not call MB_SET_ERR on it
39 : : #if 0
40 : : fprintf(
41 : : stderr,
42 : : "[Warning]: Invalid entity handle setting tag %s: %s %ld\n",
43 : : name.c_str(),
44 : : CN::EntityTypeName(TYPE_FROM_HANDLE(h)),
45 : : (unsigned long)ID_FROM_HANDLE(h)
46 : : );
47 : : #endif
48 : :
49 : 21622 : return MB_ENTITY_NOT_FOUND;
50 : : }
51 : :
52 : 643 : DenseTag::DenseTag( int index, const char* name, int size, DataType type, const void* default_value )
53 : 643 : : TagInfo( name, size, type, default_value, size ), mySequenceArray( index ), meshValue( 0 )
54 : : {
55 : 643 : }
56 : :
57 : 784 : TagType DenseTag::get_storage_type() const
58 : : {
59 : 784 : return MB_TAG_DENSE;
60 : : }
61 : :
62 : 643 : DenseTag* DenseTag::create_tag( SequenceManager* seqman, Error* /* error */, const char* name, int bytes, DataType type,
63 : : const void* default_value )
64 : : {
65 [ - + ]: 643 : if( bytes < 1 ) return 0;
66 : :
67 : : int index;
68 [ + - ][ - + ]: 643 : if( MB_SUCCESS != seqman->reserve_tag_array( NULL, bytes, index ) ) return 0;
69 : :
70 [ + - ][ + - ]: 643 : return new DenseTag( index, name, bytes, type, default_value );
71 : : }
72 : :
73 : 1908 : DenseTag::~DenseTag()
74 : : {
75 [ - + ]: 636 : assert( mySequenceArray < 0 );
76 [ + + ]: 636 : delete[] meshValue;
77 [ - + ]: 1272 : }
78 : :
79 : 752 : ErrorCode DenseTag::release_all_data( SequenceManager* seqman, Error* /* error */, bool delete_pending )
80 : : {
81 : 752 : ErrorCode result = seqman->release_tag_array( NULL, mySequenceArray, delete_pending );
82 [ + - ][ + + ]: 752 : if( MB_SUCCESS == result && delete_pending ) mySequenceArray = -1;
83 : 752 : return result;
84 : : }
85 : :
86 : 6185934 : ErrorCode DenseTag::get_array( const SequenceManager* seqman, Error* /* error */, EntityHandle h,
87 : : const unsigned char* const& ptr, size_t& count ) const
88 : : {
89 : : // cast away the const-ness; do we really want to do this?
90 : : // probably we are not calling this anywhere;
91 : : // clang compiler found this
92 : 6185934 : return get_array_private( seqman, NULL, h, const_cast< const unsigned char*& >( ptr ), count );
93 : : }
94 : :
95 : 6185934 : ErrorCode DenseTag::get_array_private( const SequenceManager* seqman, Error* /* error */, EntityHandle h,
96 : : const unsigned char*& ptr, size_t& count ) const
97 : : {
98 : 6185934 : const EntitySequence* seq = 0;
99 [ + - ]: 6185934 : ErrorCode rval = seqman->find( h, seq );
100 [ + + ]: 6185934 : if( MB_SUCCESS != rval )
101 : : {
102 [ + + ]: 22280 : if( !h )
103 : : { // Root set
104 : 668 : ptr = meshValue;
105 : 668 : count = 1;
106 : 668 : return MB_SUCCESS;
107 : : }
108 : : else
109 : : { // Not root set
110 : 21612 : ptr = 0;
111 : 21612 : count = 0;
112 [ + - ]: 21612 : return ent_not_found( get_name(), h );
113 : : }
114 : : }
115 : :
116 [ + - ][ + - ]: 6163654 : const void* mem = seq->data()->get_tag_data( mySequenceArray );
117 : 6163654 : ptr = reinterpret_cast< const unsigned char* >( mem );
118 [ + - ][ + - ]: 6163654 : count = seq->data()->end_handle() - h + 1;
119 [ + + ][ + - ]: 6163654 : if( ptr ) ptr += get_size() * ( h - seq->data()->start_handle() );
[ + - ][ + - ]
120 : :
121 : 6185934 : return MB_SUCCESS;
122 : : }
123 : :
124 : 0 : ErrorCode DenseTag::get_array( const EntitySequence* seq, const unsigned char* const& ptr ) const
125 : : {
126 : : // cast away the constness; otherwise it would be infinite recursion
127 : : // probably we are not calling this anywhere
128 : 0 : return get_array_private( seq, const_cast< const unsigned char*& >( ptr ) );
129 : : }
130 : :
131 : 0 : ErrorCode DenseTag::get_array_private( const EntitySequence* seq, const unsigned char*& ptr ) const
132 : : {
133 : 0 : ptr = reinterpret_cast< const unsigned char* >( seq->data()->get_tag_data( mySequenceArray ) );
134 [ # # ]: 0 : if( ptr ) ptr += get_size() * ( seq->start_handle() - seq->data()->start_handle() );
135 : :
136 : 0 : return MB_SUCCESS;
137 : : }
138 : :
139 : 1145619 : ErrorCode DenseTag::get_array_private( SequenceManager* seqman, Error* /* error */, EntityHandle h, unsigned char*& ptr,
140 : : size_t& count, bool allocate )
141 : : {
142 : 1145619 : EntitySequence* seq = 0;
143 [ + - ]: 1145619 : ErrorCode rval = seqman->find( h, seq );
144 [ + + ]: 1145619 : if( MB_SUCCESS != rval )
145 : : {
146 [ + + ]: 65 : if( !h )
147 : : { // Root set
148 [ + + ][ + - ]: 55 : if( !meshValue && allocate ) meshValue = new unsigned char[get_size()];
[ + - ][ + - ]
149 : 55 : ptr = meshValue;
150 : 55 : count = 1;
151 : 55 : return MB_SUCCESS;
152 : : }
153 : : else
154 : : { // Not root set
155 : 10 : ptr = 0;
156 : 10 : count = 0;
157 [ + - ]: 10 : return ent_not_found( get_name(), h );
158 : : }
159 : : }
160 : :
161 [ + - ][ + - ]: 1145554 : void* mem = seq->data()->get_tag_data( mySequenceArray );
162 [ + + ][ + + ]: 1145554 : if( !mem && allocate )
163 : : {
164 [ + - ][ + - ]: 817 : mem = seq->data()->allocate_tag_array( mySequenceArray, get_size(), get_default_value() );
[ + - ][ + - ]
165 [ - + ][ # # ]: 817 : if( !mem ) { MB_SET_ERR( MB_MEMORY_ALLOCATION_FAILED, "Memory allocation for dense tag data failed" ); }
[ # # ][ # # ]
[ # # ][ # # ]
166 : :
167 [ + - ][ + + ]: 817 : if( !get_default_value() ) memset( mem, 0, get_size() * seq->data()->size() );
[ + - ][ + - ]
[ + - ]
168 : : }
169 : :
170 : 1145554 : ptr = reinterpret_cast< unsigned char* >( mem );
171 [ + - ][ + - ]: 1145554 : count = seq->data()->end_handle() - h + 1;
172 [ + + ][ + - ]: 1145554 : if( ptr ) ptr += get_size() * ( h - seq->data()->start_handle() );
[ + - ][ + - ]
173 : 1145619 : return MB_SUCCESS;
174 : : }
175 : :
176 : 5151461 : ErrorCode DenseTag::get_data( const SequenceManager* seqman, Error* /* error */, const EntityHandle* entities,
177 : : size_t num_entities, void* adata ) const
178 : : {
179 : 5151461 : size_t junk = 0;
180 : 5151461 : unsigned char* ptr = reinterpret_cast< unsigned char* >( adata );
181 : 5151461 : const EntityHandle* const end = entities + num_entities;
182 [ + - ][ + + ]: 11291921 : for( const EntityHandle* i = entities; i != end; ++i, ptr += get_size() )
183 : : {
184 : 6140460 : const unsigned char* data = 0;
185 [ + - ][ - + ]: 6140460 : ErrorCode rval = get_array( seqman, NULL, *i, data, junk );MB_CHK_ERR( rval );
[ # # ][ # # ]
186 : :
187 [ + + ]: 6140460 : if( data )
188 [ + - ]: 6140197 : memcpy( ptr, data, get_size() );
189 [ + - ][ + - ]: 263 : else if( get_default_value() )
190 [ + - ][ + - ]: 263 : memcpy( ptr, get_default_value(), get_size() );
191 : : else
192 [ # # ]: 0 : return not_found( get_name(), *i );
193 : : }
194 : :
195 : 5151461 : return MB_SUCCESS;
196 : : }
197 : :
198 : 2507 : ErrorCode DenseTag::get_data( const SequenceManager* seqman, Error* /* error */, const Range& entities,
199 : : void* values ) const
200 : : {
201 : : ErrorCode rval;
202 : 2507 : size_t avail = 0;
203 : 2507 : const unsigned char* array = NULL; // Initialize to get rid of warning
204 : 2507 : unsigned char* data = reinterpret_cast< unsigned char* >( values );
205 : :
206 [ + - ][ + - ]: 25470 : for( Range::const_pair_iterator p = entities.const_pair_begin(); p != entities.const_pair_end(); ++p )
[ + - ][ + - ]
[ + + ]
207 : : {
208 [ + - ]: 22963 : EntityHandle start = p->first;
209 [ + - ][ + + ]: 45937 : while( start <= p->second )
210 : : {
211 [ + - ][ - + ]: 25481 : rval = get_array( seqman, NULL, start, array, avail );MB_CHK_ERR( rval );
[ # # ][ # # ]
212 : :
213 [ + - ][ + - ]: 22974 : const size_t count = std::min< size_t >( p->second - start + 1, avail );
214 [ + + ]: 22974 : if( array )
215 [ + - ]: 19656 : memcpy( data, array, get_size() * count );
216 [ + - ][ + - ]: 3318 : else if( get_default_value() )
217 [ + - ][ + - ]: 3318 : SysUtil::setmem( data, get_default_value(), get_size(), count );
[ + - ]
218 : : else
219 [ # # ]: 0 : return not_found( get_name(), start );
220 : :
221 [ + - ]: 22974 : data += get_size() * count;
222 : 22974 : start += count;
223 : : }
224 : : }
225 : :
226 : 2507 : return MB_SUCCESS;
227 : : }
228 : :
229 : 21867 : ErrorCode DenseTag::get_data( const SequenceManager* seqman, Error* /* error */, const EntityHandle* entities,
230 : : size_t num_entities, const void** pointers, int* data_lengths ) const
231 : : {
232 : : ErrorCode result;
233 : 21867 : const EntityHandle* const end = entities + num_entities;
234 : 21867 : size_t junk = 0;
235 : 21867 : const unsigned char* ptr = NULL; // Initialize to get rid of warning
236 : :
237 [ + + ]: 21867 : if( data_lengths )
238 : : {
239 [ + - ]: 67 : const int len = get_size();
240 [ + - ]: 67 : SysUtil::setmem( data_lengths, &len, sizeof( int ), num_entities );
241 : : }
242 : :
243 [ + + ]: 22102 : for( const EntityHandle* i = entities; i != end; ++i, ++pointers )
244 : : {
245 [ + - ][ + + ]: 21867 : result = get_array( seqman, NULL, *i, ptr, junk );MB_CHK_ERR( result );
[ - + ][ + - ]
246 : :
247 [ + + ]: 255 : if( ptr )
248 : 201 : *pointers = ptr;
249 [ + - ][ + + ]: 54 : else if( get_default_value() )
250 [ + - ]: 34 : *pointers = get_default_value();
251 : : else
252 [ + - ]: 20 : return not_found( get_name(), *i );
253 : : }
254 : :
255 : 21867 : return MB_SUCCESS;
256 : : }
257 : :
258 : 18 : ErrorCode DenseTag::get_data( const SequenceManager* seqman, Error* /* error */, const Range& entities,
259 : : const void** pointers, int* data_lengths ) const
260 : : {
261 : : ErrorCode rval;
262 : 18 : size_t avail = 0;
263 : 18 : const unsigned char* array = NULL;
264 : :
265 [ + + ]: 18 : if( data_lengths )
266 : : {
267 [ + - ]: 2 : int len = get_size();
268 [ + - ][ + - ]: 2 : SysUtil::setmem( data_lengths, &len, sizeof( int ), entities.size() );
269 : : }
270 : :
271 [ + - ][ + - ]: 72 : for( Range::const_pair_iterator p = entities.const_pair_begin(); p != entities.const_pair_end(); ++p )
[ + - ][ + - ]
[ + + ]
272 : : {
273 [ + - ]: 54 : EntityHandle start = p->first;
274 [ + - ][ + + ]: 108 : while( start <= p->second )
275 : : {
276 [ + - ][ - + ]: 72 : rval = get_array( seqman, NULL, start, array, avail );MB_CHK_ERR( rval );
[ # # ][ # # ]
277 : :
278 [ + - ][ + - ]: 54 : const size_t count = std::min< size_t >( p->second - start + 1, avail );
279 [ + - ]: 54 : if( array )
280 : : {
281 [ + + ]: 252 : for( EntityHandle end = start + count; start != end; ++start )
282 : : {
283 : 198 : *pointers = array;
284 [ + - ]: 198 : array += get_size();
285 : 198 : ++pointers;
286 : : }
287 : : }
288 [ # # ][ # # ]: 0 : else if( const void* val = get_default_value() )
289 : : {
290 [ # # ]: 0 : SysUtil::setmem( pointers, &val, sizeof( void* ), count );
291 : 0 : pointers += count;
292 : 0 : start += count;
293 : : }
294 : : else
295 : : {
296 [ # # ]: 0 : return not_found( get_name(), start );
297 : : }
298 : : }
299 : : }
300 : :
301 : 18 : return MB_SUCCESS;
302 : : }
303 : :
304 : 901037 : ErrorCode DenseTag::set_data( SequenceManager* seqman, Error* /* error */, const EntityHandle* entities,
305 : : size_t num_entities, const void* data )
306 : : {
307 : : ErrorCode rval;
308 : 901037 : const unsigned char* ptr = reinterpret_cast< const unsigned char* >( data );
309 : 901037 : const EntityHandle* const end = entities + num_entities;
310 : 901037 : unsigned char* array = NULL;
311 : 901037 : size_t junk = 0;
312 : :
313 [ + - ][ + + ]: 1891799 : for( const EntityHandle* i = entities; i != end; ++i, ptr += get_size() )
314 : : {
315 [ + - ][ + + ]: 990764 : rval = get_array_private( seqman, NULL, *i, array, junk, true );MB_CHK_ERR( rval );
[ - + ][ + - ]
316 : :
317 [ + - ]: 990762 : memcpy( array, ptr, get_size() );
318 : : }
319 : :
320 : 901037 : return MB_SUCCESS;
321 : : }
322 : :
323 : 3194 : ErrorCode DenseTag::set_data( SequenceManager* seqman, Error* /* error */, const Range& entities, const void* values )
324 : : {
325 : : ErrorCode rval;
326 : 3194 : const char* data = reinterpret_cast< const char* >( values );
327 : 3194 : unsigned char* array = NULL;
328 : 3194 : size_t avail = 0;
329 : :
330 [ + - ][ + - ]: 27026 : for( Range::const_pair_iterator p = entities.const_pair_begin(); p != entities.const_pair_end(); ++p )
[ + - ][ + - ]
[ + + ]
331 : : {
332 [ + - ]: 23834 : EntityHandle start = p->first;
333 [ + - ][ + + ]: 47677 : while( start <= p->second )
334 : : {
335 [ + - ][ + + ]: 23845 : rval = get_array_private( seqman, NULL, start, array, avail, true );MB_CHK_ERR( rval );
[ - + ][ + - ]
336 : :
337 [ + - ][ + - ]: 23843 : const size_t count = std::min< size_t >( p->second - start + 1, avail );
338 [ + - ]: 23843 : memcpy( array, data, get_size() * count );
339 [ + - ]: 23843 : data += get_size() * count;
340 : 23843 : start += count;
341 : : }
342 : : }
343 : :
344 : 3194 : return MB_SUCCESS;
345 : : }
346 : :
347 : 10 : ErrorCode DenseTag::set_data( SequenceManager* seqman, Error* /* error */, const EntityHandle* entities,
348 : : size_t num_entities, void const* const* pointers, const int* data_lengths )
349 : : {
350 [ + - ][ - + ]: 10 : ErrorCode rval = validate_lengths( NULL, data_lengths, num_entities );MB_CHK_ERR( rval );
[ # # ][ # # ]
351 : :
352 : 10 : const EntityHandle* const end = entities + num_entities;
353 : 10 : unsigned char* array = NULL;
354 : 10 : size_t junk = 0;
355 : :
356 [ + + ]: 18 : for( const EntityHandle* i = entities; i != end; ++i, ++pointers )
357 : : {
358 [ + - ][ + + ]: 10 : rval = get_array_private( seqman, NULL, *i, array, junk, true );MB_CHK_ERR( rval );
[ - + ][ + - ]
359 : :
360 [ + - ]: 8 : memcpy( array, *pointers, get_size() );
361 : : }
362 : :
363 : 10 : return MB_SUCCESS;
364 : : }
365 : :
366 : 6 : ErrorCode DenseTag::set_data( SequenceManager* seqman, Error* /* error */, const Range& entities,
367 : : void const* const* pointers, const int* /* data_lengths */ )
368 : : {
369 : : ErrorCode rval;
370 : 6 : unsigned char* array = NULL;
371 : 6 : size_t avail = 0;
372 : :
373 [ + - ][ + - ]: 18 : for( Range::const_pair_iterator p = entities.const_pair_begin(); p != entities.const_pair_end(); ++p )
[ + - ][ + - ]
[ + + ]
374 : : {
375 [ + - ]: 14 : EntityHandle start = p->first;
376 [ + - ][ + + ]: 26 : while( start <= p->second )
377 : : {
378 [ + - ][ + + ]: 14 : rval = get_array_private( seqman, NULL, start, array, avail, true );MB_CHK_ERR( rval );
[ - + ][ + - ]
379 : :
380 [ + - ][ + - ]: 12 : const EntityHandle end = std::min< EntityHandle >( p->second + 1, start + avail );
381 [ + + ]: 52 : while( start != end )
382 : : {
383 [ + - ]: 40 : memcpy( array, *pointers, get_size() );
384 : 40 : ++start;
385 : 40 : ++pointers;
386 [ + - ]: 40 : array += get_size();
387 : : }
388 : : }
389 : : }
390 : :
391 : 6 : return MB_SUCCESS;
392 : : }
393 : :
394 : 1317 : ErrorCode DenseTag::clear_data( bool allocate, SequenceManager* seqman, Error* /* error */,
395 : : const EntityHandle* entities, size_t num_entities, const void* value_ptr )
396 : : {
397 : : ErrorCode rval;
398 : 1317 : const EntityHandle* const end = entities + num_entities;
399 : 1317 : unsigned char* array = NULL;
400 : 1317 : size_t junk = 0;
401 : :
402 [ + + ]: 101710 : for( const EntityHandle* i = entities; i != end; ++i )
403 : : {
404 [ + - ][ - + ]: 100393 : rval = get_array_private( seqman, NULL, *i, array, junk, allocate );MB_CHK_ERR( rval );
[ # # ][ # # ]
405 : :
406 [ + + ]: 100393 : if( array ) // Array should never be null if allocate == true
407 [ + - ]: 53089 : memcpy( array, value_ptr, get_size() );
408 : : }
409 : :
410 : 1317 : return MB_SUCCESS;
411 : : }
412 : :
413 : 163 : ErrorCode DenseTag::clear_data( bool allocate, SequenceManager* seqman, Error* /* error */, const Range& entities,
414 : : const void* value_ptr )
415 : : {
416 : : ErrorCode rval;
417 : 163 : unsigned char* array = NULL;
418 : 163 : size_t avail = 0;
419 : :
420 [ + - ][ + - ]: 30674 : for( Range::const_pair_iterator p = entities.const_pair_begin(); p != entities.const_pair_end(); ++p )
[ + - ][ + - ]
[ + + ]
421 : : {
422 [ + - ]: 30511 : EntityHandle start = p->first;
423 [ + - ][ + + ]: 61029 : while( start <= p->second )
424 : : {
425 [ + - ][ - + ]: 30518 : rval = get_array_private( seqman, NULL, start, array, avail, allocate );MB_CHK_ERR( rval );
[ # # ][ # # ]
426 : :
427 [ + - ][ + - ]: 30518 : const size_t count = std::min< size_t >( p->second - start + 1, avail );
428 [ + + ]: 30518 : if( array ) // Array should never be null if allocate == true
429 [ + - ][ + - ]: 6052 : SysUtil::setmem( array, value_ptr, get_size(), count );
430 : 30518 : start += count;
431 : : }
432 : : }
433 : :
434 : 163 : return MB_SUCCESS;
435 : : }
436 : :
437 : 4 : ErrorCode DenseTag::clear_data( SequenceManager* seqman, Error* /* error */, const EntityHandle* entities,
438 : : size_t num_entities, const void* value_ptr, int value_len )
439 : : {
440 [ - + ][ # # ]: 4 : if( value_len && value_len != get_size() ) return MB_INVALID_SIZE;
[ - + ]
441 : :
442 : 4 : return clear_data( true, seqman, NULL, entities, num_entities, value_ptr );
443 : : }
444 : :
445 : 3 : ErrorCode DenseTag::clear_data( SequenceManager* seqman, Error* /* error */, const Range& entities,
446 : : const void* value_ptr, int value_len )
447 : : {
448 [ - + ][ # # ]: 3 : if( value_len && value_len != get_size() ) return MB_INVALID_SIZE;
[ - + ]
449 : :
450 : 3 : return clear_data( true, seqman, NULL, entities, value_ptr );
451 : : }
452 : :
453 : 1313 : ErrorCode DenseTag::remove_data( SequenceManager* seqman, Error* /* error */, const EntityHandle* entities,
454 : : size_t num_entities )
455 : : {
456 [ + - ]: 1313 : std::vector< unsigned char > zeros;
457 [ + - ]: 1313 : const void* value = get_default_value();
458 [ + + ]: 1313 : if( !value )
459 : : {
460 [ + - ][ + - ]: 389 : zeros.resize( get_size(), 0 );
461 [ + - ]: 389 : value = &zeros[0];
462 : : }
463 : :
464 [ + - ]: 1313 : return clear_data( false, seqman, NULL, entities, num_entities, value );
465 : : }
466 : :
467 : 160 : ErrorCode DenseTag::remove_data( SequenceManager* seqman, Error* /* error */, const Range& entities )
468 : : {
469 [ + - ]: 160 : std::vector< unsigned char > zeros;
470 [ + - ]: 160 : const void* value = get_default_value();
471 [ + + ]: 160 : if( !value )
472 : : {
473 [ + - ][ + - ]: 40 : zeros.resize( get_size(), 0 );
474 [ + - ]: 40 : value = &zeros[0];
475 : : }
476 : :
477 [ + - ]: 160 : return clear_data( false, seqman, NULL, entities, value );
478 : : }
479 : :
480 : 75 : ErrorCode DenseTag::tag_iterate( SequenceManager* seqman, Error* /* error */, Range::iterator& iter,
481 : : const Range::iterator& end, void*& data_ptr, bool allocate )
482 : : {
483 : : // If asked for nothing, successfully return nothing.
484 [ + - ][ - + ]: 75 : if( iter == end ) return MB_SUCCESS;
485 : :
486 : 75 : unsigned char* array = NULL;
487 : 75 : size_t avail = 0;
488 [ + - ][ + - ]: 75 : ErrorCode rval = get_array_private( seqman, NULL, *iter, array, avail, allocate );MB_CHK_ERR( rval );
[ + + ][ - + ]
[ + - ]
489 : 73 : data_ptr = array;
490 : :
491 [ + - ][ + - ]: 73 : size_t count = std::min< size_t >( avail, *( iter.end_of_block() ) - *iter + 1 );
[ + - ][ + - ]
492 [ + - ][ + + ]: 73 : if( 0 != *end && *end <= *( iter.end_of_block() ) )
[ + - ][ + - ]
[ + - ][ - + ]
[ + + ]
[ - + # # ]
493 : 0 : iter = end;
494 : : else
495 [ + - ]: 73 : iter += count;
496 : :
497 : 75 : return MB_SUCCESS;
498 : : }
499 : :
500 : 209 : ErrorCode DenseTag::get_tagged_entities( const SequenceManager* seqman, Range& entities_in, EntityType type,
501 : : const Range* intersect_list ) const
502 : : {
503 [ + - ]: 209 : Range tmp;
504 [ + + ]: 209 : Range* entities = intersect_list ? &tmp : &entities_in;
505 [ + - ]: 209 : Range::iterator hint = entities->begin();
506 [ + - ]: 209 : std::pair< EntityType, EntityType > range = type_range( type );
507 [ + - ]: 209 : TypeSequenceManager::const_iterator i;
508 [ + - ][ + + ]: 1386 : for( EntityType t = range.first; t != range.second; ++t )
509 : : {
510 [ + - ]: 1177 : const TypeSequenceManager& map = seqman->entity_map( t );
511 [ + - ][ + - ]: 3878 : for( i = map.begin(); i != map.end(); ++i )
[ + - ][ + - ]
[ + + ]
512 [ + - ][ + - ]: 2701 : if( ( *i )->data()->get_tag_data( mySequenceArray ) )
[ + - ][ + + ]
513 [ + - ][ + - ]: 237 : hint = entities->insert( hint, ( *i )->start_handle(), ( *i )->end_handle() );
[ + - ][ + - ]
[ + - ]
514 : : }
515 : :
516 [ + + ][ + - ]: 209 : if( intersect_list ) entities_in = intersect( *entities, *intersect_list );
[ + - ]
517 : :
518 : 209 : return MB_SUCCESS;
519 : : }
520 : :
521 : 8 : ErrorCode DenseTag::num_tagged_entities( const SequenceManager* seqman, size_t& output_count, EntityType type,
522 : : const Range* intersect ) const
523 : : {
524 [ + - ]: 8 : Range tmp;
525 [ + - ]: 8 : ErrorCode rval = get_tagged_entities( seqman, tmp, type, intersect );
526 [ + - ]: 8 : output_count += tmp.size();
527 : :
528 : 8 : return rval;
529 : : }
530 : :
531 : 121 : ErrorCode DenseTag::find_entities_with_value( const SequenceManager* seqman, Error* /* error */, Range& output_entities,
532 : : const void* value, int value_bytes, EntityType type,
533 : : const Range* intersect_entities ) const
534 : : {
535 [ - + ][ # # ]: 121 : if( value_bytes && value_bytes != get_size() )
[ - + ]
536 : : {
537 [ # # ][ # # ]: 0 : MB_SET_ERR( MB_INVALID_SIZE,
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ][ # # ]
[ # # ]
538 : : "Cannot compare data of size " << value_bytes << " with tag of size " << get_size() );
539 : : }
540 : :
541 [ - + ]: 121 : if( !intersect_entities )
542 : : {
543 [ # # ]: 0 : std::pair< EntityType, EntityType > range = type_range( type );
544 [ # # ]: 0 : TypeSequenceManager::const_iterator i;
545 [ # # ][ # # ]: 0 : for( EntityType t = range.first; t != range.second; ++t )
546 : : {
547 [ # # ]: 0 : const TypeSequenceManager& map = seqman->entity_map( t );
548 [ # # ][ # # ]: 0 : for( i = map.begin(); i != map.end(); ++i )
[ # # ][ # # ]
[ # # ]
549 : : {
550 [ # # ][ # # ]: 0 : const void* data = ( *i )->data()->get_tag_data( mySequenceArray );
[ # # ]
551 [ # # ]: 0 : if( data )
552 : : {
553 [ # # ][ # # ]: 0 : ByteArrayIterator start( ( *i )->data()->start_handle(), data, *this );
[ # # ][ # # ]
554 [ # # ][ # # ]: 0 : ByteArrayIterator end( ( *i )->end_handle() + 1, 0, 0 );
[ # # ]
555 [ # # ][ # # ]: 0 : start += ( *i )->start_handle() - ( *i )->data()->start_handle();
[ # # ][ # # ]
[ # # ][ # # ]
556 [ # # ][ # # ]: 0 : find_tag_values_equal( *this, value, get_size(), start, end, output_entities );
557 : : }
558 : : }
559 : : }
560 : : }
561 : : else
562 : : {
563 : 121 : const unsigned char* array = NULL; // Initialize to get rid of warning
564 : : size_t count;
565 : : ErrorCode rval;
566 : :
567 [ + - ][ + - ]: 121 : Range::const_pair_iterator p = intersect_entities->begin();
568 [ + + ]: 121 : if( type != MBMAXTYPE )
569 : : {
570 [ + - ][ + - ]: 105 : p = intersect_entities->lower_bound( type );
571 [ + - ][ + - ]: 105 : assert( TYPE_FROM_HANDLE( p->first ) == type );
[ - + ]
572 : : }
573 [ + - ][ + + ]: 840 : for( ;
574 [ + - ][ + - ]: 560 : p != intersect_entities->const_pair_end() && ( MBMAXTYPE == type || TYPE_FROM_HANDLE( p->first ) == type );
[ + + ][ + + ]
[ + - ][ + - ]
[ + - ][ - + ]
[ # # ]
575 : : ++p )
576 : : {
577 [ + - ]: 159 : EntityHandle start = p->first;
578 [ + - ][ + + ]: 341 : while( start <= p->second )
579 : : {
580 [ + - ][ - + ]: 182 : rval = get_array( seqman, NULL, start, array, count );MB_CHK_ERR( rval );
[ # # ][ # # ]
581 : :
582 [ + - ][ + + ]: 182 : if( p->second - start < count - 1 ) count = p->second - start + 1;
[ + - ]
583 : :
584 [ + + ]: 182 : if( array )
585 : : {
586 [ + - ]: 175 : ByteArrayIterator istart( start, array, *this );
587 [ + - ]: 175 : ByteArrayIterator iend( start + count, 0, 0 );
588 [ + - ][ + - ]: 175 : find_tag_values_equal( *this, value, get_size(), istart, iend, output_entities );
589 : : }
590 : 182 : start += count;
591 : : }
592 : : }
593 : : }
594 : :
595 : 121 : return MB_SUCCESS;
596 : : }
597 : :
598 : 397 : bool DenseTag::is_tagged( const SequenceManager* seqman, EntityHandle h ) const
599 : : {
600 : 397 : const unsigned char* ptr = NULL; // Initialize to get rid of warning
601 : : size_t count;
602 [ + - ][ + - ]: 397 : return ( MB_SUCCESS == get_array( seqman, 0, h, ptr, count ) ) && ( NULL != ptr );
[ + + ]
603 : : }
604 : :
605 : 8 : ErrorCode DenseTag::get_memory_use( const SequenceManager* seqman, unsigned long& total,
606 : : unsigned long& per_entity ) const
607 : : {
608 : 8 : per_entity = get_size();
609 : 8 : total = TagInfo::get_memory_use() + sizeof( *this );
610 [ + - ][ + + ]: 104 : for( EntityType t = MBVERTEX; t <= MBENTITYSET; ++t )
611 : : {
612 [ + - ]: 96 : const TypeSequenceManager& map = seqman->entity_map( t );
613 : 96 : const SequenceData* prev_data = 0;
614 [ + - ][ + - ]: 110 : for( TypeSequenceManager::const_iterator i = map.begin(); i != map.end(); ++i )
[ + - ][ + - ]
[ + + ]
615 : : {
616 [ + - ][ + - ]: 14 : if( ( *i )->data() != prev_data && ( *i )->data()->get_tag_data( mySequenceArray ) )
[ + - ][ + - ]
[ + - ][ + - ]
[ - + ][ - + ]
617 : : {
618 [ # # ][ # # ]: 0 : prev_data = ( *i )->data();
619 [ # # ][ # # ]: 0 : total += get_size() * ( *i )->data()->size();
[ # # ][ # # ]
620 : : }
621 : : }
622 : : }
623 : :
624 : 8 : return MB_SUCCESS;
625 : : }
626 : :
627 : : } // namespace moab
|
