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