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 : : /**\file MeshSetSequence.cpp
17 : : *\author Jason Kraftcheck ([email protected])
18 : : *\date 2007-04-30
19 : : */
20 : :
21 : : #include "MeshSetSequence.hpp"
22 : : #include "SequenceManager.hpp"
23 : :
24 : : namespace moab
25 : : {
26 : :
27 : 23 : MeshSetSequence::MeshSetSequence( EntityHandle start, EntityID count, const unsigned* flags, SequenceData* dat )
28 : 23 : : EntitySequence( start, count, dat )
29 : : {
30 [ + - ]: 23 : initialize( flags );
31 : 23 : }
32 : :
33 : 0 : MeshSetSequence::MeshSetSequence( EntityHandle start, EntityID count, unsigned flags, SequenceData* dat )
34 : 0 : : EntitySequence( start, count, dat )
35 : : {
36 [ # # ]: 0 : std::vector< unsigned > vect( count, flags );
37 [ # # ][ # # ]: 0 : initialize( &vect[0] );
38 : 0 : }
39 : :
40 : 44 : MeshSetSequence::MeshSetSequence( EntityHandle start, EntityID count, const unsigned* flags, EntityID data_size )
41 [ + - ]: 44 : : EntitySequence( start, count, new SequenceData( 1, start, start + data_size - 1 ) )
42 : : {
43 [ + - ]: 44 : initialize( flags );
44 : 44 : }
45 : :
46 : 286 : MeshSetSequence::MeshSetSequence( EntityHandle start, EntityID count, unsigned flags, EntityID data_size )
47 [ + - ]: 286 : : EntitySequence( start, count, new SequenceData( 1, start, start + data_size - 1 ) )
48 : : {
49 [ + - ]: 286 : std::vector< unsigned > vect( count, flags );
50 [ + - ][ + - ]: 286 : initialize( &vect[0] );
51 : 286 : }
52 : :
53 : 353 : void MeshSetSequence::initialize( const unsigned* flags )
54 : : {
55 [ + + ]: 353 : if( !data()->get_sequence_data( 0 ) ) data()->create_sequence_data( 0, SET_SIZE );
56 : :
57 : 353 : EntityID offset = start_handle() - data()->start_handle();
58 [ + + ]: 2060 : for( EntityID i = 0; i < size(); ++i )
59 : 1707 : allocate_set( flags[i], i + offset );
60 : 353 : }
61 : :
62 : 21585 : MeshSetSequence::~MeshSetSequence()
63 : : {
64 : 7195 : EntityID offset = start_handle() - data()->start_handle();
65 : 7195 : EntityID count = size();
66 [ + + ]: 16888 : for( EntityID i = 0; i < count; ++i )
67 : 9693 : deallocate_set( i + offset );
68 [ - + ]: 14390 : }
69 : :
70 : 6846 : EntitySequence* MeshSetSequence::split( EntityHandle here )
71 : : {
72 [ + - ]: 6846 : return new MeshSetSequence( *this, here );
73 : : }
74 : :
75 : 3900 : ErrorCode MeshSetSequence::pop_back( EntityID count )
76 : : {
77 : 3900 : EntityID offset = end_handle() + 1 - count - data()->start_handle();
78 : 3900 : ErrorCode rval = EntitySequence::pop_back( count );
79 [ + - ]: 3900 : if( MB_SUCCESS == rval )
80 [ + + ]: 7804 : for( EntityID i = 0; i < count; ++i )
81 : 3904 : deallocate_set( i + offset );
82 : 3900 : return rval;
83 : : }
84 : :
85 : 18814 : ErrorCode MeshSetSequence::pop_front( EntityID count )
86 : : {
87 : 18814 : EntityID offset = start_handle() - data()->start_handle();
88 : 18814 : ErrorCode rval = EntitySequence::pop_front( count );
89 [ + - ]: 18814 : if( MB_SUCCESS == rval )
90 [ + + ]: 37628 : for( EntityID i = 0; i < count; ++i )
91 : 18814 : deallocate_set( i + offset );
92 : 18814 : return rval;
93 : : }
94 : :
95 : 30890 : ErrorCode MeshSetSequence::push_back( EntityID count, const unsigned* flags )
96 : : {
97 : 30890 : EntityID offset = end_handle() + 1 - data()->start_handle();
98 : 30890 : ErrorCode rval = EntitySequence::append_entities( count );
99 [ + - ]: 30890 : if( MB_SUCCESS == rval )
100 [ + + ]: 61780 : for( EntityID i = 0; i < count; ++i )
101 : 30890 : allocate_set( flags[i], i + offset );
102 : 30890 : return rval;
103 : : }
104 : :
105 : 0 : ErrorCode MeshSetSequence::push_front( EntityID count, const unsigned* flags )
106 : : {
107 : 0 : EntityID offset = start_handle() - data()->start_handle() - count;
108 : 0 : ErrorCode rval = EntitySequence::prepend_entities( count );
109 [ # # ]: 0 : if( MB_SUCCESS == rval )
110 [ # # ]: 0 : for( EntityID i = 0; i < count; ++i )
111 : 0 : allocate_set( flags[i], i + offset );
112 : 0 : return rval;
113 : : }
114 : :
115 : 0 : void MeshSetSequence::get_const_memory_use( unsigned long& per_ent, unsigned long& seq_size ) const
116 : : {
117 : 0 : per_ent = SET_SIZE;
118 : 0 : seq_size = sizeof( *this );
119 : 0 : }
120 : :
121 : 0 : unsigned long MeshSetSequence::get_per_entity_memory_use( EntityHandle first, EntityHandle last ) const
122 : : {
123 [ # # ]: 0 : if( first < start_handle() ) first = start_handle();
124 [ # # ]: 0 : if( last > end_handle() ) last = end_handle();
125 : :
126 : 0 : unsigned long sum = 0;
127 [ # # ]: 0 : for( EntityHandle h = first; h <= last; ++h )
128 : 0 : sum += get_set( h )->get_memory_use();
129 : 0 : return sum;
130 : : }
131 : :
132 : 15453 : ErrorCode MeshSetSequence::get_entities( const SequenceManager* seqman, EntityHandle handle, Range& entities,
133 : : bool recursive ) const
134 : : {
135 [ + + ]: 15453 : if( !recursive )
136 : : {
137 : 11210 : get_set( handle )->get_entities( entities );
138 : 11210 : return MB_SUCCESS;
139 : : }
140 : : else
141 : : {
142 [ + - ]: 4243 : std::vector< const MeshSet* > list;
143 [ + - ]: 4243 : ErrorCode rval = recursive_get_sets( handle, seqman, &list );
144 [ + - ][ + - ]: 8591 : for( std::vector< const MeshSet* >::iterator i = list.begin(); i != list.end(); ++i )
[ + + ]
145 [ + - ][ + - ]: 4348 : ( *i )->get_non_set_entities( entities );
146 : 15453 : return rval;
147 : : }
148 : : }
149 : :
150 : 3984 : ErrorCode MeshSetSequence::get_entities( EntityHandle handle, std::vector< EntityHandle >& entities ) const
151 : : {
152 : 3984 : get_set( handle )->get_entities( entities );
153 : 3984 : return MB_SUCCESS;
154 : : }
155 : :
156 : 66 : ErrorCode MeshSetSequence::get_dimension( const SequenceManager* seqman, EntityHandle handle, int dimension,
157 : : std::vector< EntityHandle >& entities, bool recursive ) const
158 : : {
159 [ + - ]: 66 : if( !recursive )
160 : : {
161 : 66 : get_set( handle )->get_entities_by_dimension( dimension, entities );
162 : 66 : return MB_SUCCESS;
163 : : }
164 : : else
165 : : {
166 [ # # ]: 0 : std::vector< const MeshSet* > list;
167 [ # # ]: 0 : ErrorCode rval = recursive_get_sets( handle, seqman, &list );
168 [ # # ][ # # ]: 0 : for( std::vector< const MeshSet* >::iterator i = list.begin(); i != list.end(); ++i )
[ # # ]
169 [ # # ][ # # ]: 0 : ( *i )->get_entities_by_dimension( dimension, entities );
170 : 66 : return rval;
171 : : }
172 : : }
173 : :
174 : 17574 : ErrorCode MeshSetSequence::get_dimension( const SequenceManager* seqman, EntityHandle handle, int dimension,
175 : : Range& entities, bool recursive ) const
176 : : {
177 [ + + ]: 17574 : if( !recursive )
178 : : {
179 : 15046 : get_set( handle )->get_entities_by_dimension( dimension, entities );
180 : 15046 : return MB_SUCCESS;
181 : : }
182 : : else
183 : : {
184 [ + - ]: 2528 : std::vector< const MeshSet* > list;
185 [ + - ]: 2528 : ErrorCode rval = recursive_get_sets( handle, seqman, &list );
186 [ + - ][ + - ]: 7464 : for( std::vector< const MeshSet* >::iterator i = list.begin(); i != list.end(); ++i )
[ + + ]
187 [ + - ][ + - ]: 4936 : ( *i )->get_entities_by_dimension( dimension, entities );
188 : 17574 : return rval;
189 : : }
190 : : }
191 : :
192 : 324 : ErrorCode MeshSetSequence::get_type( const SequenceManager* seqman, EntityHandle handle, EntityType tp,
193 : : std::vector< EntityHandle >& entities, bool recursive ) const
194 : : {
195 [ + + ]: 324 : if( !recursive )
196 : : {
197 : 323 : get_set( handle )->get_entities_by_type( tp, entities );
198 : 323 : return MB_SUCCESS;
199 : : }
200 [ - + ]: 1 : else if( tp == MBENTITYSET )
201 : : {
202 : 0 : return recursive_get_sets( handle, seqman, 0, 0, &entities );
203 : : }
204 [ + - ]: 1 : else if( tp == MBMAXTYPE )
205 : : {
206 [ + - ]: 1 : Range tmp;
207 [ + - ]: 1 : ErrorCode rval = get_entities( seqman, handle, tmp, recursive );
208 [ + - ]: 1 : if( MB_SUCCESS == rval )
209 : : {
210 : : #ifdef MOAB_NO_VECTOR_TEMPLATE_INSERT
211 : : std::copy( tmp.begin(), tmp.end(), std::back_inserter( entities ) );
212 : : #else
213 [ + - ][ + - ]: 1 : entities.insert( entities.end(), tmp.begin(), tmp.end() );
[ + - ]
214 : : #endif
215 : : }
216 : 1 : return rval;
217 : : }
218 : : else
219 : : {
220 [ # # ]: 0 : std::vector< const MeshSet* > list;
221 [ # # ]: 0 : ErrorCode rval = recursive_get_sets( handle, seqman, &list );
222 [ # # ][ # # ]: 0 : for( std::vector< const MeshSet* >::iterator i = list.begin(); i != list.end(); ++i )
[ # # ]
223 [ # # ][ # # ]: 0 : ( *i )->get_entities_by_type( tp, entities );
224 : 324 : return rval;
225 : : }
226 : : }
227 : :
228 : 22198 : ErrorCode MeshSetSequence::get_type( const SequenceManager* seqman, EntityHandle handle, EntityType tp, Range& entities,
229 : : bool recursive ) const
230 : : {
231 [ + + ]: 22198 : if( !recursive )
232 : : {
233 : 22088 : get_set( handle )->get_entities_by_type( tp, entities );
234 : 22088 : return MB_SUCCESS;
235 : : }
236 [ - + ]: 110 : else if( tp == MBENTITYSET )
237 : : {
238 : 0 : return recursive_get_sets( handle, seqman, 0, &entities );
239 : : }
240 [ + + ]: 110 : else if( tp == MBMAXTYPE )
241 : : {
242 [ + - ]: 12 : std::vector< const MeshSet* > list;
243 [ + - ]: 12 : ErrorCode rval = recursive_get_sets( handle, seqman, &list );
244 [ + - ][ + - ]: 36 : for( std::vector< const MeshSet* >::iterator i = list.begin(); i != list.end(); ++i )
[ + + ]
245 [ + - ][ + - ]: 24 : ( *i )->get_non_set_entities( entities );
246 : 12 : return rval;
247 : : }
248 : : else
249 : : {
250 [ + - ]: 98 : std::vector< const MeshSet* > list;
251 [ + - ]: 98 : ErrorCode rval = recursive_get_sets( handle, seqman, &list );
252 [ + - ][ + - ]: 691 : for( std::vector< const MeshSet* >::iterator i = list.begin(); i != list.end(); ++i )
[ + + ]
253 [ + - ][ + - ]: 593 : ( *i )->get_entities_by_type( tp, entities );
254 : 22198 : return rval;
255 : : }
256 : : }
257 : :
258 : 7963 : ErrorCode MeshSetSequence::num_entities( const SequenceManager* seqman, EntityHandle handle, int& number,
259 : : bool recursive ) const
260 : : {
261 [ + + ]: 7963 : if( !recursive )
262 : : {
263 : 7962 : number = get_set( handle )->num_entities();
264 : 7962 : return MB_SUCCESS;
265 : : }
266 : : else
267 : : {
268 [ + - ]: 1 : Range range;
269 [ + - ]: 1 : ErrorCode result = get_entities( seqman, handle, range, true );
270 [ + - ]: 1 : number = range.size();
271 : 7963 : return result;
272 : : }
273 : : }
274 : :
275 : 78 : ErrorCode MeshSetSequence::num_dimension( const SequenceManager* seqman, EntityHandle handle, int dimension,
276 : : int& number, bool recursive ) const
277 : : {
278 [ + + ]: 78 : if( !recursive )
279 : : {
280 : 72 : number = get_set( handle )->num_entities_by_dimension( dimension );
281 : 72 : return MB_SUCCESS;
282 : : }
283 : : else
284 : : {
285 [ + - ]: 6 : Range range;
286 [ + - ]: 6 : ErrorCode result = get_dimension( seqman, handle, dimension, range, true );
287 [ + - ]: 6 : number = range.size();
288 : 78 : return result;
289 : : }
290 : : }
291 : :
292 : 91 : ErrorCode MeshSetSequence::num_type( const SequenceManager* seqman, EntityHandle handle, EntityType tp, int& number,
293 : : bool recursive ) const
294 : : {
295 [ + + ]: 91 : if( !recursive )
296 : : {
297 : 70 : number = get_set( handle )->num_entities_by_type( tp );
298 : 70 : return MB_SUCCESS;
299 : : }
300 : : else
301 : : {
302 [ + - ]: 21 : Range range;
303 [ + - ]: 21 : ErrorCode result = get_type( seqman, handle, tp, range, true );
304 [ + - ]: 21 : number = range.size();
305 : 91 : return result;
306 : : }
307 : : }
308 : :
309 : 6881 : ErrorCode MeshSetSequence::recursive_get_sets( EntityHandle start_set, const SequenceManager* seq_sets,
310 : : std::vector< const MeshSet* >* sets, Range* set_handles,
311 : : std::vector< EntityHandle >* set_vector )
312 : : {
313 [ + - ]: 6881 : std::set< EntityHandle > visited;
314 [ + - ]: 13762 : std::vector< EntityHandle > stack;
315 [ + - ]: 6881 : stack.push_back( start_set );
316 : 6881 : bool remove_start_set = true;
317 [ + + ]: 16803 : while( !stack.empty() )
318 : : {
319 [ + - ]: 9922 : EntityHandle handle = stack.back();
320 [ + - ]: 9922 : stack.pop_back();
321 : :
322 [ + - ][ + + ]: 9922 : if( !visited.insert( handle ).second )
323 : : {
324 [ + + ]: 21 : if( handle == start_set ) remove_start_set = false;
325 : 21 : continue;
326 : : }
327 : :
328 : : const EntitySequence* seq;
329 [ + - ]: 9901 : ErrorCode rval = seq_sets->find( handle, seq );
330 [ - + ]: 9901 : if( MB_SUCCESS != rval ) return rval;
331 : :
332 : 9901 : const MeshSetSequence* mseq = reinterpret_cast< const MeshSetSequence* >( seq );
333 [ + - ]: 9901 : const MeshSet* ms_ptr = mseq->get_set( handle );
334 [ + - ][ + - ]: 9901 : if( sets ) sets->push_back( ms_ptr );
335 : :
336 [ + - ]: 9901 : Range tmp_range;
337 [ + - ]: 9901 : ms_ptr->get_entities_by_type( MBENTITYSET, tmp_range );
338 [ + - ][ + - ]: 9901 : std::copy( tmp_range.begin(), tmp_range.end(), std::back_inserter( stack ) );
[ + - ][ + - ]
339 : 9901 : }
340 : :
341 [ - + ]: 6881 : if( set_handles )
342 : : {
343 [ # # ][ # # ]: 0 : if( remove_start_set ) visited.erase( start_set );
344 [ # # ]: 0 : Range::iterator hint = set_handles->begin();
345 [ # # ]: 0 : std::set< EntityHandle >::iterator it;
346 [ # # ][ # # ]: 0 : for( it = visited.begin(); it != visited.end(); ++it )
[ # # ]
347 [ # # ][ # # ]: 0 : hint = set_handles->insert( hint, *it, *it );
[ # # ]
348 : : }
349 : :
350 [ - + ]: 6881 : if( set_vector )
351 : : {
352 [ # # ][ # # ]: 0 : if( remove_start_set ) visited.erase( start_set );
353 [ # # ][ # # ]: 0 : std::copy( visited.begin(), visited.end(), std::back_inserter( *set_vector ) );
354 : : }
355 : :
356 : 13762 : return MB_SUCCESS;
357 : : }
358 : :
359 : 0 : ErrorCode MeshSetSequence::recursive_get_sets( EntityHandle start_set, SequenceManager* seq_sets,
360 : : std::vector< MeshSet* >& sets )
361 : : {
362 [ # # ]: 0 : std::set< EntityHandle > visited;
363 [ # # ]: 0 : std::vector< EntityHandle > stack;
364 [ # # ]: 0 : stack.push_back( start_set );
365 [ # # ]: 0 : while( !stack.empty() )
366 : : {
367 [ # # ]: 0 : EntityHandle handle = stack.back();
368 [ # # ]: 0 : stack.pop_back();
369 : :
370 [ # # ][ # # ]: 0 : if( !visited.insert( handle ).second ) continue;
371 : :
372 : : EntitySequence* seq;
373 [ # # ]: 0 : ErrorCode rval = seq_sets->find( handle, seq );
374 [ # # ]: 0 : if( MB_SUCCESS != rval ) return rval;
375 : :
376 : 0 : MeshSetSequence* mseq = reinterpret_cast< MeshSetSequence* >( seq );
377 [ # # ]: 0 : MeshSet* ms_ptr = mseq->get_set( handle );
378 [ # # ]: 0 : sets.push_back( ms_ptr );
379 : :
380 [ # # ]: 0 : Range tmp_range;
381 [ # # ]: 0 : ms_ptr->get_entities_by_type( MBENTITYSET, tmp_range );
382 [ # # ][ # # ]: 0 : std::copy( tmp_range.begin(), tmp_range.end(), std::back_inserter( stack ) );
[ # # ][ # # ]
383 : 0 : }
384 : :
385 : 0 : return MB_SUCCESS;
386 : : }
387 : :
388 : 353 : ErrorCode MeshSetSequence::get_parent_child_meshsets( EntityHandle meshset, const SequenceManager* seq_sets,
389 : : std::vector< EntityHandle >& results, int num_hops,
390 : : SearchType link_type ) const
391 : : {
392 : 353 : ErrorCode result = MB_SUCCESS;
393 : 353 : std::vector< EntityHandle >::iterator i;
394 : 353 : const EntityHandle *tmp_array = 0, *end;
395 : : EntityHandle s, e;
396 : 353 : int count = 0;
397 : : size_t n;
398 : :
399 : : // Skip any meshsets already in input vector (yes, don't
400 : : // get their children either even if num_hops would indicate
401 : : // that we should.) There is an exception to that if the
402 : : // input meshset is in the list, which is handled by the order
403 : : // of checks in the main loop below.
404 [ + - ]: 353 : std::set< EntityHandle > visited;
405 [ + - ][ + - ]: 364 : for( i = results.begin(); i != results.end(); ++i )
[ + + # # ]
406 [ + - ][ + - ]: 11 : visited.insert( *i );
407 : :
408 : : // Two lists for breadth-first search
409 [ + - ][ + + ]: 2118 : std::vector< EntityHandle > lists[2];
[ + + ]
[ # # # # ]
410 : 353 : int index = 0; // which list to read from (write to lists[1-index])
411 [ + - ]: 353 : lists[index].push_back( meshset ); // begin with input set
412 : : // loop for num_hops (or until no more sets)
413 [ + + ][ + + ]: 1090 : for( ; num_hops && !lists[index].empty(); --num_hops )
[ + + ]
414 : : {
415 : : // for each set at the current num_hops
416 [ + - ][ + - ]: 23100 : for( i = lists[index].begin(); i != lists[index].end(); ++i )
[ + + ]
417 : : {
418 : : // get meshset from handle
419 : : const EntitySequence* seq;
420 [ + - ][ + - ]: 22363 : ErrorCode rval = seq_sets->find( *i, seq );
421 [ + + ]: 22363 : if( MB_SUCCESS != rval ) return rval;
422 [ + - ][ + - ]: 22345 : const MeshSet* ms_ptr = reinterpret_cast< const MeshSetSequence* >( seq )->get_set( *i );
423 : :
424 [ - + + - ]: 22345 : switch( link_type )
425 : : {
426 : : case CONTAINED:
427 [ # # ]: 0 : tmp_array = ms_ptr->get_contents( n );
428 : 0 : end = tmp_array + n;
429 [ # # ][ # # ]: 0 : if( ms_ptr->vector_based() )
430 : : {
431 [ # # ]: 0 : for( ; tmp_array != end; ++tmp_array )
432 [ # # ][ # # ]: 0 : if( MBENTITYSET == TYPE_FROM_HANDLE( *tmp_array ) && visited.insert( *tmp_array ).second )
[ # # ][ # # ]
[ # # ]
433 [ # # ]: 0 : lists[1 - index].push_back( *tmp_array );
434 : : }
435 : : else
436 : : {
437 [ # # ]: 0 : assert( n % 2 == 0 );
438 [ # # ][ # # ]: 0 : tmp_array = std::lower_bound( tmp_array, tmp_array + n, FIRST_HANDLE( MBENTITYSET ) );
439 : : // only part of first block is of type
440 [ # # ]: 0 : if( ( end - tmp_array ) % 2 )
441 : : {
442 : 0 : ++tmp_array;
443 [ # # ]: 0 : s = FIRST_HANDLE( MBENTITYSET );
444 : 0 : e = *tmp_array;
445 [ # # ]: 0 : for( ; s <= e; ++s )
446 [ # # ][ # # ]: 0 : if( visited.insert( s ).second ) lists[1 - index].push_back( s );
[ # # ]
447 : : }
448 [ # # ]: 0 : while( tmp_array < end )
449 : : {
450 : 0 : s = *tmp_array++;
451 : 0 : e = *tmp_array++;
452 [ # # ]: 0 : for( ; s <= e; ++s )
453 [ # # ][ # # ]: 0 : if( visited.insert( s ).second ) lists[1 - index].push_back( s );
[ # # ]
454 : : }
455 : : }
456 : 0 : continue;
457 : : case PARENTS:
458 [ + - ]: 195 : tmp_array = ms_ptr->get_parents( count );
459 : 195 : break;
460 : : case CHILDREN:
461 [ + - ]: 22150 : tmp_array = ms_ptr->get_children( count );
462 : 22150 : break;
463 : : }
464 : :
465 : : // copy any parents/children we haven't visited yet into list
466 [ + + ]: 44596 : for( end = tmp_array + count; tmp_array != end; ++tmp_array )
467 [ + - ][ + + ]: 22251 : if( visited.insert( *tmp_array ).second ) lists[1 - index].push_back( *tmp_array );
[ + - ]
468 : : }
469 : :
470 : : // iterate
471 : 737 : lists[index].clear();
472 : 737 : index = 1 - index;
473 : : // append each level of sets to the output list.
474 : : // note: to make a more useful search (e.g. get entities 3 hops away,
475 : : // rather than entities up to and including 3 hops) move this outside
476 : : // the loop, but then need to handle the get all (num_hops < 0) case
477 : : // specially.
478 [ + - ][ + - ]: 737 : std::copy( lists[index].begin(), lists[index].end(), std::back_inserter( results ) );
479 : : }
480 : :
481 : 688 : return result;
482 : : }
483 : :
484 : 466 : ErrorCode MeshSetSequence::get_parents( const SequenceManager* seqman, EntityHandle handle,
485 : : std::vector< EntityHandle >& parents, int num_hops ) const
486 : : {
487 [ + + ]: 466 : if( num_hops == 1 )
488 : : {
489 : : int count;
490 [ + - ][ + - ]: 377 : const EntityHandle* tmp_array = get_set( handle )->get_parents( count );
491 [ + + ]: 377 : if( parents.empty() )
492 : : {
493 [ + - ]: 373 : parents.resize( count );
494 [ + - ]: 373 : std::copy( tmp_array, tmp_array + count, parents.begin() );
495 : 373 : return MB_SUCCESS;
496 : : }
497 [ - + ]: 4 : else if( !count )
498 : : {
499 : 4 : return MB_SUCCESS;
500 : : }
501 : : }
502 : :
503 [ + + ]: 93 : if( num_hops > 0 )
504 : 34 : return get_parent_child_meshsets( handle, seqman, parents, num_hops, PARENTS );
505 : : else
506 : 466 : return get_parent_child_meshsets( handle, seqman, parents, -1, PARENTS );
507 : : }
508 : :
509 : 195629 : ErrorCode MeshSetSequence::get_children( const SequenceManager* seqman, EntityHandle handle,
510 : : std::vector< EntityHandle >& children, int num_hops ) const
511 : : {
512 [ + + ]: 195629 : if( num_hops == 1 )
513 : : {
514 : : int count;
515 [ + - ][ + - ]: 195369 : const EntityHandle* tmp_array = get_set( handle )->get_children( count );
516 [ + - ]: 195369 : if( children.empty() )
517 : : {
518 [ + - ]: 195369 : children.resize( count );
519 [ + - ]: 195369 : std::copy( tmp_array, tmp_array + count, children.begin() );
520 : 195369 : return MB_SUCCESS;
521 : : }
522 [ # # ]: 0 : else if( !count )
523 : : {
524 : 0 : return MB_SUCCESS;
525 : : }
526 : : }
527 : :
528 [ + + ]: 260 : if( num_hops > 0 )
529 : 12 : return get_parent_child_meshsets( handle, seqman, children, num_hops, CHILDREN );
530 : : else
531 : 195629 : return get_parent_child_meshsets( handle, seqman, children, -1, CHILDREN );
532 : : }
533 : :
534 : 2 : ErrorCode MeshSetSequence::get_contained_sets( const SequenceManager* seqman, EntityHandle handle,
535 : : std::vector< EntityHandle >& contained, int num_hops ) const
536 : : {
537 [ + - ][ + - ]: 2 : if( num_hops == 1 && contained.empty() )
[ + - ]
538 : 2 : { return get_set( handle )->get_entities_by_type( MBENTITYSET, contained ); }
539 : :
540 [ # # ]: 0 : if( num_hops > 0 )
541 : 0 : return get_parent_child_meshsets( handle, seqman, contained, num_hops, CONTAINED );
542 : : else
543 : 0 : return get_parent_child_meshsets( handle, seqman, contained, -1, CONTAINED );
544 : : }
545 : :
546 : 976 : ErrorCode MeshSetSequence::num_parents( const SequenceManager* seqman, EntityHandle handle, int& number,
547 : : int num_hops ) const
548 : : {
549 [ + + ]: 976 : if( num_hops == 1 )
550 : : {
551 [ + - ][ + - ]: 972 : number = get_set( handle )->num_parents();
552 : 972 : return MB_SUCCESS;
553 : : }
554 : :
555 [ + - ]: 4 : std::vector< EntityHandle > parents;
556 [ + - ]: 4 : ErrorCode result = get_parents( seqman, handle, parents, num_hops );
557 : 4 : number = parents.size();
558 : 976 : return result;
559 : : }
560 : :
561 : 1064 : ErrorCode MeshSetSequence::num_children( const SequenceManager* seqman, EntityHandle handle, int& number,
562 : : int num_hops ) const
563 : : {
564 [ + + ]: 1064 : if( num_hops == 1 )
565 : : {
566 [ + - ][ + - ]: 1060 : number = get_set( handle )->num_children();
567 : 1060 : return MB_SUCCESS;
568 : : }
569 : :
570 [ + - ]: 4 : std::vector< EntityHandle > children;
571 [ + - ]: 4 : ErrorCode result = get_children( seqman, handle, children, num_hops );
572 : 4 : number = children.size();
573 : 1064 : return result;
574 : : }
575 : :
576 : 3 : ErrorCode MeshSetSequence::num_contained_sets( const SequenceManager* seqman, EntityHandle handle, int& number,
577 : : int num_hops ) const
578 : : {
579 [ + - ]: 3 : if( num_hops == 1 )
580 : : {
581 [ + - ][ + - ]: 3 : number = get_set( handle )->num_entities_by_type( MBENTITYSET );
582 : 3 : return MB_SUCCESS;
583 : : }
584 : :
585 [ # # ]: 0 : std::vector< EntityHandle > contained;
586 [ # # ]: 0 : ErrorCode result = get_contained_sets( seqman, handle, contained, num_hops );
587 : 0 : number = contained.size();
588 : 3 : return result;
589 : : }
590 : :
591 [ + - ][ + - ]: 228 : } // namespace moab
|
