#include <Range.hpp>

Collaboration diagram for moab::Range:

Classes
class	const_iterator
	a const iterator which iterates over an Range More...
class	const_pair_iterator
class	const_reverse_iterator
	a const reverse iterator which iterates over an Range More...
class	pair_iterator
	used to iterate over sub-ranges of a range More...
struct	PairNode
Public Types
typedef const_iterator	iterator
typedef const_reverse_iterator	reverse_iterator
typedef EntityHandle	value_type
Public Member Functions
Range &	operator-= (const Range &rhs)
	just like subtract, but as an operator
	Range ()
	default constructor
	Range (const Range &copy)
	copy constructor
	Range (EntityHandle val1, EntityHandle val2)
	another constructor that takes an initial range
Range &	operator= (const Range &copy)
	operator=
	~Range ()
	destructor
const_iterator	begin () const
	return the beginning const iterator of this range
const_reverse_iterator	rbegin () const
	return the beginning const reverse iterator of this range
const_iterator	end () const
	return the ending const iterator for this range
const_reverse_iterator	rend () const
	return the ending const reverse iterator for this range
size_t	size () const
	return the number of values this Ranges represents
size_t	psize () const
	return the number of range pairs in the list
bool	empty () const
iterator	insert (iterator hint, EntityHandle val)
iterator	insert (EntityHandle val)
	insert an item into the list and return the iterator for the inserted item
iterator	insert (iterator hint, EntityHandle first, EntityHandle last)
iterator	insert (EntityHandle val1, EntityHandle val2)
template<typename T >
iterator	insert_list (T begin_iter, T end_iter)
template<class T >
iterator	insert (typename T::const_iterator begin_iter, typename T::const_iterator end_iter)
template<typename T >
iterator	insert (const T begin_iter, const T end_iter)
iterator	erase (iterator iter)
	remove an item from this list and return an iterator to the next item
iterator	erase (iterator iter1, iterator iter2)
	remove a range of items from the list
iterator	erase (EntityHandle val)
	erases a value from this container
const EntityHandle &	front () const
	get first entity in range
const EntityHandle &	back () const
	get last entity in range
EntityHandle	pop_front ()
	remove first entity from range
EntityHandle	pop_back ()
	remove last entity from range
const_iterator	find (EntityHandle val) const
	find an item int the list and return an iterator at that value
const_iterator	lower_bound (EntityHandle val) const
const_iterator	upper_bound (EntityHandle val) const
const_iterator	lower_bound (EntityType type) const
const_iterator	upper_bound (EntityType type) const
std::pair< const_iterator, const_iterator >	equal_range (EntityType type) const
const_iterator	lower_bound (EntityType type, const_iterator first) const
const_iterator	upper_bound (EntityType type, const_iterator first) const
bool	all_of_type (EntityType type) const
bool	all_of_dimension (int dimension) const
unsigned	num_of_type (EntityType type) const
unsigned	num_of_dimension (int dim) const
void	clear ()
	clears the contents of the list
const std::string	str_rep (const char *indent_prefix=NULL) const
	for debugging
void	print (const char *indent_prefix=NULL) const
void	print (std::ostream &s, const char *indent_prefix=NULL) const
unsigned long	get_memory_use () const
double	compactness () const
void	insert (Range::const_iterator begin, Range::const_iterator end)
void	merge (const Range &range)
	merges this Range with another range
void	merge (Range::const_iterator beginr, Range::const_iterator endr)
	merge a subset of some other range
void	swap (Range &range)
	swap the contents of this range with another one
void	sanity_check () const
	check for internal consistency
bool	contains (const Range &other) const
	Check if this range is a non-strict superset of some other range.
Range	subset_by_type (EntityType t) const
	return a subset of this range, by type
Range	subset_by_dimension (int dim) const
	return a subset of this range, by dimension
EntityHandle	operator[] (EntityID index) const
int	index (EntityHandle handle) const
pair_iterator	pair_begin ()
pair_iterator	pair_end ()
const_pair_iterator	const_pair_begin () const
const_pair_iterator	const_pair_end () const
const_pair_iterator	pair_begin () const
const_pair_iterator	pair_end () const
template<typename Iterator >
Range::iterator	insert_list (Iterator begin_iter, Iterator end_iter)
Static Public Member Functions
static const_iterator	lower_bound (const_iterator first, const_iterator last, EntityHandle val)
	return an iterator to the first value >= val
static const_iterator	upper_bound (const_iterator first, const_iterator last, EntityHandle val)
Protected Member Functions
void	delete_pair_node (PairNode *dead_node)
	if dead_node is not mHead, remove it from the list and free it's memory.
Protected Attributes
PairNode	mHead
Friends
Range	intersect (const Range &, const Range &)
	intersect two ranges, placing the results in the return range
Range	subtract (const Range &, const Range &)
	subtract range2 from this, placing the results in the return range

Detailed Description

the class Range

Examples:: addPCdata.cpp, ComputeTriDual.cpp, copyPartition.cpp, DeformMeshRemap.cpp, DirectAccessNoHoles.cpp, DirectAccessWithHoles.cpp, ExtractLand.cpp, ExtrudePoly.cpp, GenLargeMesh.cpp, GetEntities.cpp, HelloMOAB.cpp, HelloParMOAB.cpp, LaplacianSmoother.cpp, LloydRelaxation.cpp, LoadPartial.cpp, QuadTriConv.cpp, ReadPartFile.cpp, ReduceExchangeTags.cpp, SetsNTags.cpp, StructuredMeshSimple.cpp, TestErrorHandling.cpp, TestExodusII.cpp, and VisTags.cpp.

Definition at line 191 of file Range.hpp.

Member Typedef Documentation

typedef const_iterator moab::Range::iterator

Definition at line 196 of file Range.hpp.

typedef const_reverse_iterator moab::Range::reverse_iterator

Definition at line 198 of file Range.hpp.

typedef EntityHandle moab::Range::value_type

for short hand notation, lets typedef the container class that holds the ranges

Definition at line 208 of file Range.hpp.

Constructor & Destructor Documentation

moab::Range::Range ( ) [inline]

default constructor

Definition at line 846 of file Range.hpp.

References mHead, moab::Range::PairNode::mNext, and moab::Range::PairNode::mPrev.

{
    // set the head node to point to itself
    mHead.mNext = mHead.mPrev = &mHead;
    mHead.first = mHead.second = 0;
}

moab::Range::Range ( const Range & copy )

copy constructor

Definition at line 179 of file Range.cpp.

References alloc_pair(), mHead, moab::Range::PairNode::mNext, and moab::Range::PairNode::mPrev.

{
    // set the head node to point to itself
    mHead.mNext = mHead.mPrev = &mHead;
    mHead.first = mHead.second = 0;

    const PairNode* copy_node = copy.mHead.mNext;
    PairNode* new_node        = &mHead;
    for( ; copy_node != &( copy.mHead ); copy_node = copy_node->mNext )
    {
        PairNode* tmp_node     = alloc_pair( new_node->mNext, new_node, copy_node->first, copy_node->second );
        new_node->mNext->mPrev = tmp_node;
        new_node->mNext        = tmp_node;
        new_node               = tmp_node;
    }
}

moab::Range::Range	(	EntityHandle	val1,
		EntityHandle	val2
	)

another constructor that takes an initial range

Definition at line 172 of file Range.cpp.

References alloc_pair(), mHead, moab::Range::PairNode::mNext, and moab::Range::PairNode::mPrev.

{
    mHead.mNext = mHead.mPrev = alloc_pair( &mHead, &mHead, val1, val2 );
    mHead.first = mHead.second = 0;
}

moab::Range::~Range ( ) [inline]

destructor

Definition at line 854 of file Range.hpp.

References clear().

{
    clear();
}

Member Function Documentation

bool moab::Range::all_of_dimension ( int dimension ) const

True if all entities in range are of passed dimension (also true if range is empty)

Definition at line 884 of file Range.cpp.

References back(), moab::CN::Dimension(), empty(), front(), and moab::TYPE_FROM_HANDLE().

Referenced by moab::OrientedBoxTreeTool::build(), check_parallel_read(), moab::Skinner::find_skin(), moab::Skinner::find_skin_vertices(), moab::Skinner::find_skin_vertices_1D(), moab::Skinner::find_skin_vertices_2D(), moab::Skinner::find_skin_vertices_3D(), moab::Core::get_vertices(), and mb_mesh_sets_test().

{
    return empty() || ( CN::Dimension( TYPE_FROM_HANDLE( front() ) ) == dimension &&
                        CN::Dimension( TYPE_FROM_HANDLE( back() ) ) == dimension );
}

bool moab::Range::all_of_type ( EntityType type ) const

True if all entities in range are of passed type (also true if range is empty)

Definition at line 879 of file Range.cpp.

References back(), empty(), front(), and moab::TYPE_FROM_HANDLE().

Referenced by check_ho_elements(), moab::WriteNCDF::gather_mesh_information(), generate_random_points(), moab::ReorderTool::handle_order_from_sets_and_adj(), iMOAB_GetBlockInfo(), moab::ReorderTool::int_order_from_sets_and_adj(), moab::OrientedBoxTreeTool::join_trees(), main(), mb_mesh_sets_test(), mb_skin_surface_test_common(), moab::GeomQueryTool::measure_area(), moab::GeomQueryTool::measure_volume(), read_sets(), recursive_check_tree(), test_read_set_contents(), test_read_sets_common(), and moab::WriteNCDF::write_elementblocks().

{
    return empty() || ( TYPE_FROM_HANDLE( front() ) == type && TYPE_FROM_HANDLE( back() ) == type );
}

const EntityHandle & moab::Range::back ( ) const [inline]

get last entity in range

Definition at line 912 of file Range.hpp.

References mHead, and moab::Range::PairNode::mPrev.

Referenced by all_of_dimension(), all_of_type(), check_parallel_read(), erase_test(), moab::WriteNCDF::gather_mesh_information(), moab::WriteUtil::gather_nodes_from_elements(), moab::ReadHDF5::get_partition(), make_mesh(), mb_skin_curve_test_common(), mb_skin_poly_test(), mb_skin_surface_test_common(), mb_type_is_maxtype_test(), mb_vertex_coordinate_test(), moab::AdaptiveKDTree::merge_leaf(), moab::BSPTree::merge_leaf(), pop_back(), moab::ReadHDF5::read_elems(), moab::ReadHDF5::read_sparse_tag_indices(), moab::GeomTopoTool::resize_rootSets(), subset_by_dimension_test(), test_get_by_tag_value_dense(), test_get_ents_with_default_value(), test_list_set_with_stale_handles(), test_pack_elements(), test_pack_higher_order(), test_pack_sets_of_sets(), test_ranged_set_with_stale_handles(), test_read_adjacencies(), test_read_material_on_nodes(), and test_read_two_sets_elems().

{
    return mHead.mPrev->second;
}

Range::const_iterator moab::Range::begin ( ) const [inline]

return the beginning const iterator of this range

Examples:: addPCdata.cpp, ComputeTriDual.cpp, copyPartition.cpp, DirectAccessNoHoles.cpp, DirectAccessWithHoles.cpp, ExtractLand.cpp, GetEntities.cpp, LaplacianSmoother.cpp, LloydRelaxation.cpp, QuadTriConv.cpp, ReadPartFile.cpp, SetsNTags.cpp, StructuredMeshSimple.cpp, TestErrorHandling.cpp, TestExodusII.cpp, and VisTags.cpp.

Definition at line 860 of file Range.hpp.

References mHead, and moab::Range::PairNode::mNext.

{
    return const_iterator( mHead.mNext, mHead.mNext->first );
}

void moab::Range::clear ( )

clears the contents of the list

Examples:: ComputeTriDual.cpp, DeformMeshRemap.cpp, HelloParMOAB.cpp, SetsNTags.cpp, and TestExodusII.cpp.

Definition at line 197 of file Range.cpp.

References free_pair(), mHead, moab::Range::PairNode::mNext, and moab::Range::PairNode::mPrev.

Referenced by adj_perf(), ahf_test(), MetisPartitioner::assemble_graph(), ZoltanPartitioner::assemble_graph(), MetisPartitioner::assemble_taggedents_graph(), moab::ReadUtil::assign_ids(), moab::OrientedBoxTreeTool::build_sets(), check_children(), check_identical_mesh(), check_num_verts(), check_tree(), check_valid_connectivity(), moab::Skinner::classify_2d_boundary(), moab::TempestRemapper::clear(), moab::OrientedBoxTreeTool::closest_to_location(), coincident_counts(), compare(), moab::MeshTopoUtil::construct_aentities(), moab::DualTool::construct_hp_parent_child(), moab::GeomTopoTool::construct_vertex_ranges(), contains_test(), moab::TempestRemapper::convert_mesh_to_tempest_private(), moab::TempestRemapper::convert_overlap_mesh_sorted_by_source(), moab::TempestRemapper::convert_tempest_mesh_private(), moab::WriteHDF5::count_set_size(), moab::ReadGmsh::create_geometric_topology(), moab::ParallelComm::create_iface_pc_links(), moab::ReadABAQUS::create_instance_of_part(), create_int_ents(), moab::AEntityFactory::create_vert_elem_adjacencies(), moab::Core::create_vertices(), vtkMoabReader::CreateSubBlocks(), delete_existing_tree(), do_file(), do_kdtree_test(), do_test_mode(), dot_get_sets(), erase_test(), moab::WriteHDF5Parallel::exchange_file_ids(), FBiGeom_getArrAdj(), FBiGeom_getEnt2ndAdj(), moab::ParallelComm::filter_pstatus(), moab::AdaptiveKDTree::find_close_triangle(), moab::MergeMesh::find_merged_to(), moab::ReadHDF5::find_sets_containing(), moab::DualTool::fs_get_quads(), moab::DualTool::fsr_get_fourth_quad(), moab::WriteHDF5Parallel::gather_interface_meshes(), moab::WriteVtk::gather_mesh(), moab::WriteHDF5::gather_mesh_info(), moab::ReadUtil::gather_related_ents(), get_adjacent_elems(), moab::MeshTopoUtil::get_bridge_adjacencies(), get_by_all_types_and_tag(), get_children_by_dimension(), EntityCount::get_counts(), moab::GeomTopoTool::get_ct_children_by_dimension(), get_entities(), get_expected_ghosts(), moab::DualTool::get_graphics_points(), moab::Coupler::get_matching_entities(), get_max_volume(), moab::DualTool::get_opposite_verts(), moab::ParallelComm::get_sent_ents(), moab::ReadABAQUS::get_set_elements(), moab::ReadABAQUS::get_set_nodes(), moab::WriteCCMIO::get_sets(), moab::ParallelComm::get_shared_entities(), moab::SharedSetData::get_shared_sets(), moab::WriteHDF5::get_sparse_tagged_entities(), moab::WriteHDF5::get_tag_data_length(), moab::FBEngine::get_vert_edges(), moab::WriteHDF5::get_write_entities(), moab::FBEngine::getAdjacentEntities(), moab::FBEngine::getEgVtxSense(), moab::FBEngine::getEntities(), moab::TempestRemapper::GetOverlapAugmentedEntities(), heappermute(), iMOAB_UpdateMeshInfo(), ZoltanPartitioner::include_closure(), moab::SmoothFace::init_gradient(), moab::ReorderTool::int_order_from_sets_and_adj(), moab::AdaptiveKDTree::intersect_children_with_elems(), moab::Intx2Mesh::intersect_meshes(), moab::Intx2Mesh::intersect_meshes_kdtree(), intersect_test(), moab::ReadCGNS::load_file(), moab::ReadGmsh::load_file(), moab::ReadParallel::load_file(), moab::ReadSms::load_file_impl(), moab::ReadHDF5::load_file_impl(), moab::WriteGMV::local_write_mesh(), main(), make_mesh(), make_tris_from_quads(), mb_memory_use_test(), mb_mesh_set_flag_test(), mb_mesh_set_list_replace_test(), mb_mesh_set_set_replace_test(), mb_mesh_sets_test(), mb_poly_adjacency_test(), mb_poly_adjacency_test2(), mb_range_seq_intersect_test(), mb_skin_curve_test_common(), mb_skin_higher_order_faces_common(), mb_skin_higher_order_regions_common(), mb_skin_poly_test(), mb_skin_subset_common(), mb_skin_verts_common(), mb_split_test(), mb_topo_util_test(), mb_type_is_maxtype_test(), mb_write_mesh_test(), moab::GeomQueryTool::measure_area(), moab::GeomQueryTool::measure_volume(), merge_2D_elem(), merge_3D_elem(), moab::MergeMesh::merge_higher_dimensions(), moab::AdaptiveKDTree::merge_leaf(), moab::BSPTree::merge_leaf(), merge_test(), merge_with_tag_test(), moab::DualTool::next_loop_vertex(), operator=(), moab::ParallelComm::pack_entities(), pack_unpack_noremoteh(), parallel_create_mesh(), ZoltanPartitioner::partition_owned_cells(), moab::GeomQueryTool::point_in_volume_slow(), moab::ParallelMergeMesh::PopulateMySkinEnts(), moab::Core::print(), print_file_stats(), print_output(), print_partitioned_entities(), query_vert_to_elem_direct(), moab::AdaptiveKDTree::ray_intersect_triangles(), moab::OrientedBoxTreeTool::ray_intersect_triangles(), moab::ReadABAQUS::read_element_set(), DeformMeshRemap::read_file(), McnpData::read_mcnpfile(), moab::ReadABAQUS::read_node_set(), moab::ReadHDF5VarLen::read_offsets(), moab::ReadHDF5::read_set_ids_recursive(), moab::ReadHDF5::read_sparse_tag_indices(), regression_mmiller_8_2010(), regression_tag_on_nonexistent_entity(), remove_entities_from_sets(), report_nsets(), moab::ParallelComm::resolve_shared_sets(), moab::GeomTopoTool::restore_topology_from_adjacency(), moab::FBEngine::separate(), moab::ReadHDF5Dataset::set_all_file_ids(), skin_common(), moab::OrientedBoxTreeTool::sphere_intersect_triangles(), moab::split_box(), moab::MeshTopoUtil::split_entities_manifold(), moab::FBEngine::split_surface(), moab::MeshTopoUtil::star_next_entity(), subtract_test(), swap_test(), tag_depth(), tag_elements(), moab::ParallelComm::tag_iface_entities(), tag_time(), tag_vertices(), test_add_entities(), test_adjacencies(), test_bc_sets(), test_build_tree_bisect_triangles(), test_check_meshsets(), test_closest_triangle(), test_elements_on_several_procs(), test_gather_sets_ranged(), test_geometric_sets(), test_get_by_tag(), test_get_by_tag_value(), test_get_by_tag_value_dense(), test_get_ents_with_default_value(), test_ghost_elements(), test_ghost_tag_exchange(), test_pack_bit_tag_data(), test_pack_elements(), test_pack_higher_order(), test_pack_poly(), test_pack_set_contents(), test_pack_set_parent_child(), test_pack_sets_of_sets(), test_pack_sets_simple(), test_pack_tag_data_default_value(), test_pack_tag_data_dense(), test_pack_tag_data_sparse(), test_pack_tag_handle_data(), test_pack_variable_length_tag(), test_ray_intersect_triangles(), test_read_adjacencies(), test_read_bc_sets(), test_read_set_sets(), test_read_sides(), test_remove_entities(), test_restore_obb_trees(), test_set_flags(), test_shared_sets(), test_sphere_intersect_triangles(), test_var_length_big_data(), test_var_length_data_common(), test_var_length_handle_tag(), test_var_length_parallel(), test_write_unbalanced(), moab::DualTool::traverse_hyperplane(), moab::NestedRefine::update_global_ahf_1D_sub(), moab::NestedRefine::update_special_tags(), MetisPartitioner::write_aggregationtag_partition(), moab::WriteCCMIO::write_cells_and_faces(), moab::WriteTemplate::write_file(), moab::WriteSLAC::write_file(), moab::WriteNCDF::write_file(), moab::WriteHDF5::write_finished(), MetisPartitioner::write_partition(), ZoltanPartitioner::write_partition(), write_tree_blocks(), and ~Range().

{
    PairNode* tmp_node = mHead.mNext;
    while( tmp_node != &mHead )
    {
        PairNode* to_delete = tmp_node;
        tmp_node            = tmp_node->mNext;
        free_pair( to_delete );
    }
    mHead.mNext = &mHead;
    mHead.mPrev = &mHead;
}

double moab::Range::compactness ( ) const [inline]

Definition at line 952 of file Range.hpp.

References get_memory_use(), and size().

Referenced by moab::TempestRemapper::convert_mesh_to_tempest_private(), moab::TempestRemapper::convert_overlap_mesh_sorted_by_source(), moab::ParallelComm::exchange_ghost_cells(), moab::ParallelComm::exchange_owned_mesh(), and moab::ParallelComm::send_entities().

{
    unsigned int num_ents = size();
    return ( num_ents ? ( (double)get_memory_use() / (double)( num_ents * sizeof( EntityHandle ) ) ) : -1 );
}

const_pair_iterator moab::Range::const_pair_begin ( ) const [inline]

Definition at line 748 of file Range.hpp.

Referenced by moab::WriteHDF5::assign_ids(), moab::RangeSetIterator::build_pair_vec(), moab::SequenceManager::check_valid_entities(), moab::BitTag::clear_data(), moab::DenseTag::clear_data(), const_pair_iterator_test(), moab::HigherOrderFactory::convert(), moab::convert_to_ranged_ids(), moab::SequenceManager::delete_entities(), moab::ReadHDF5::delete_non_side_elements(), moab::Core::get_coords(), moab::BitTag::get_data(), moab::DenseTag::get_data(), moab::VarLenDenseTag::get_data(), moab::SequenceManager::get_memory_use(), index(), moab::MeshSet::insert_entity_ranges(), insert_hint_test(), moab::ReadHDF5::insert_in_id_map(), moab::intersect(), moab::DebugOutput::list_ints_real(), moab::DebugOutput::list_range_real(), moab::merge_ranged_ids(), num_of_dimension(), num_of_type(), operator-=(), moab::operator==(), moab::PACK_RANGE(), moab::ParallelComm::pack_range_map(), psize(), moab::WriteHDF5::range_to_blocked_list(), moab::WriteHDF5::range_to_id_list(), moab::ReadHDF5VarLen::read_offsets(), moab::ReadHDF5::read_set_data(), moab::BitTag::remove_data(), moab::VarLenDenseTag::remove_data(), moab::MeshSet::remove_entity_ranges(), moab::BitTag::set_data(), moab::DenseTag::set_data(), moab::VarLenDenseTag::set_data(), str_rep(), moab::subtract(), test_get_set(), test_get_set_variable_length(), and moab::IODebugTrack::~IODebugTrack().

    {
        return const_pair_iterator( mHead.mNext );
    }

const_pair_iterator moab::Range::const_pair_end ( ) const [inline]

Definition at line 752 of file Range.hpp.

Referenced by moab::WriteHDF5::assign_ids(), moab::RangeSetIterator::build_pair_vec(), moab::SequenceManager::check_valid_entities(), moab::BitTag::clear_data(), moab::DenseTag::clear_data(), moab::HigherOrderFactory::convert(), moab::convert_to_ranged_ids(), moab::SequenceManager::delete_entities(), moab::DenseTag::find_entities_with_value(), moab::VarLenDenseTag::find_entities_with_value(), moab::Core::get_coords(), moab::BitTag::get_data(), moab::DenseTag::get_data(), moab::VarLenDenseTag::get_data(), moab::SequenceManager::get_memory_use(), index(), moab::MeshSet::insert_entity_ranges(), insert_hint_test(), moab::ReadHDF5::insert_in_id_map(), moab::DebugOutput::list_ints_real(), moab::DebugOutput::list_range_real(), moab::merge_ranged_ids(), num_of_dimension(), num_of_type(), moab::operator==(), moab::PACK_RANGE(), moab::ParallelComm::pack_range_map(), psize(), moab::WriteHDF5::range_to_blocked_list(), moab::WriteHDF5::range_to_id_list(), moab::ReadHDF5VarLen::read_offsets(), moab::ReadHDF5::read_set_data(), moab::BitTag::remove_data(), moab::VarLenDenseTag::remove_data(), moab::MeshSet::remove_entity_ranges(), moab::BitTag::set_data(), moab::DenseTag::set_data(), moab::VarLenDenseTag::set_data(), str_rep(), test_get_set(), test_get_set_variable_length(), and moab::IODebugTrack::~IODebugTrack().

    {
        return const_pair_iterator( &mHead );
    }

bool moab::Range::contains ( const Range & other ) const

Check if this range is a non-strict superset of some other range.

Definition at line 1005 of file Range.cpp.

References empty(), mHead, and moab::Range::PairNode::mNext.

Referenced by moab::WriteHDF5::check_dense_format_tag(), contains_test(), and moab::Skinner::find_skin_scd().

{
    if( othr.empty() ) return true;
    if( empty() ) return false;

    // neither range is empty, so both have valid pair nodes
    // other than dummy mHead
    const PairNode* this_node = mHead.mNext;
    const PairNode* othr_node = othr.mHead.mNext;
    for( ;; )
    {
        // Loop while the node in this list is entirely before
        // the node in the other list.
        while( this_node->second < othr_node->first )
        {
            this_node = this_node->mNext;
            if( this_node == &mHead ) return false;
        }
        // If other node is not entirely contained in this node
        // then other list is not contained in this list
        if( this_node->first > othr_node->first ) break;
        // Loop while other node is entirely contained in this node.
        while( othr_node->second <= this_node->second )
        {
            othr_node = othr_node->mNext;
            if( othr_node == &othr.mHead ) return true;
        }
        // If other node overlapped end of this node
        if( othr_node->first <= this_node->second ) break;
    }

    // should be unreachable
    return false;
}

void moab::Range::delete_pair_node ( PairNode * dead_node ) [protected]

if dead_node is not mHead, remove it from the list and free it's memory.

Definition at line 471 of file Range.cpp.

References free_pair(), mHead, moab::Range::PairNode::mNext, and moab::Range::PairNode::mPrev.

Referenced by erase(), operator-=(), pop_back(), pop_front(), and moab::subtract().

{
    if( node != &mHead )
    {  // pop_front() and pop_back() rely on this check
        node->mPrev->mNext = node->mNext;
        node->mNext->mPrev = node->mPrev;
        free_pair( node );
    }
}

bool moab::Range::empty ( ) const [inline]

return whether empty or not always use "if(!Ranges::empty())" instead of "if(Ranges::size())"

Examples:: DeformMeshRemap.cpp, DirectAccessNoHoles.cpp, LaplacianSmoother.cpp, and LloydRelaxation.cpp.

Definition at line 885 of file Range.hpp.

References mHead, and moab::Range::PairNode::mNext.

{
    return ( mHead.mNext == &mHead );
}

Range::const_iterator moab::Range::end ( ) const [inline]

return the ending const iterator for this range

Examples:: addPCdata.cpp, ComputeTriDual.cpp, copyPartition.cpp, DeformMeshRemap.cpp, DirectAccessNoHoles.cpp, DirectAccessWithHoles.cpp, ExtractLand.cpp, GetEntities.cpp, LaplacianSmoother.cpp, LloydRelaxation.cpp, QuadTriConv.cpp, ReadPartFile.cpp, SetsNTags.cpp, TestErrorHandling.cpp, TestExodusII.cpp, and VisTags.cpp.

Definition at line 872 of file Range.hpp.

References mHead.

{
    return const_iterator( &mHead, mHead.first );
}

std::pair< Range::const_iterator, Range::const_iterator > moab::Range::equal_range ( EntityType type ) const

Definition at line 867 of file Range.cpp.

References begin(), moab::CREATE_HANDLE(), end(), and lower_bound().

Referenced by moab::ParallelComm::add_verts(), moab::VarLenSparseTag::find_entities_with_value(), moab::SparseTag::find_entities_with_value(), moab::ReadUtil::gather_related_ents(), generate_random_points(), moab::BitTag::get_entities_with_bits(), moab::BitTag::get_tagged(), moab::get_tagged(), moab::WriteHDF5::initialize_mesh(), subset_by_type(), and test_ghost_elements().

{
    std::pair< Range::const_iterator, Range::const_iterator > result;
    int err;
    EntityHandle handle = CREATE_HANDLE( type, 0, err );
    result.first        = err ? end() : lower_bound( begin(), end(), handle );
    // if (type+1) overflows, err will be true and we return end().
    handle        = CREATE_HANDLE( type + 1, 0, err );
    result.second = err ? end() : lower_bound( result.first, end(), handle );
    return result;
}

Range::iterator moab::Range::erase ( iterator iter )

remove an item from this list and return an iterator to the next item

erases an item from this list and returns an iterator to the next item

Examples:: LaplacianSmoother.cpp.

Definition at line 364 of file Range.cpp.

References alloc_pair(), end(), free_pair(), moab::Range::PairNode::mNext, moab::Range::const_iterator::mNode, moab::Range::PairNode::mPrev, and moab::Range::const_iterator::mValue.

Referenced by MetisPartitioner::assemble_taggedsets_graph(), check_children(), moab::ParallelComm::check_clean_iface(), moab::DualTool::check_dual_equiv_edges(), check_identical_mesh(), moab::ParallelComm::check_my_shared_handles(), moab::Skinner::classify_2d_boundary(), contains_test(), moab::ReadCCMIO::create_cell_from_faces(), moab::ReadHDF5::delete_non_side_elements(), moab::GeomTopoTool::delete_obb_tree(), moab::ParallelComm::destroy_part(), moab::MeshTopoUtil::equivalent_entities(), erase(), erase_test(), moab::Skinner::find_skin_noadj(), moab::Skinner::find_skin_vertices_3D(), moab::DualTool::foc_delete_dual(), moab::DualTool::foc_get_addl_ents(), moab::DualTool::foc_get_ents(), moab::DualTool::fsr_get_fourth_quad(), moab::WriteVtk::gather_mesh(), generate_random_points(), moab::GeomTopoTool::geometrize_surface_set(), moab::get_adjacencies_intersection(), moab::MeshTopoUtil::get_bridge_adjacencies(), moab::ParallelComm::get_interface_sets(), moab::WriteTemplate::get_neuset_elems(), moab::WriteSLAC::get_neuset_elems(), moab::WriteCCMIO::get_neuset_elems(), moab::ReorderTool::get_new_handles(), moab::ReadHDF5::get_partition(), moab::WriteNCDF::get_sideset_elems(), moab::Core::get_vertices(), moab::ReorderTool::handle_order_from_int_tag(), hcFilter(), identify_set(), moab::Intx2Mesh::intersect_meshes(), laplacianFilter(), mb_range_seq_intersect_test(), mb_topo_util_test(), merge_duplicate_vertices(), moab::MergeMesh::merge_higher_dimensions(), min_edge_length(), moab::DualTool::next_loop_vertex(), operator-=(), moab::DualTool::order_chord(), print_stats(), moab::ReadHDF5::read_set_ids_recursive(), moab::ReorderTool::reorder_tag_data(), moab::ParallelComm::resolve_shared_ents(), moab::ParallelComm::resolve_shared_sets(), moab::DualTool::rev_face_shrink(), moab::Core::serial_load_file(), moab::MeshTopoUtil::star_entities(), moab::MeshTopoUtil::star_entities_nonmanifold(), moab::MeshTopoUtil::star_next_entity(), moab::subtract(), moab::ParallelMergeMesh::TagSharedElements(), test_coords_connect_iterate(), test_get_by_tag_value_dense(), test_get_set(), test_get_set_variable_length(), test_ghost_elements(), test_ghost_tag_exchange(), test_read_nodes_common(), test_read_set_sets(), test_read_two_sets_elems(), test_tag_iterate_common(), moab::ReadNCDF::update(), and TreeValidator::visit().

{
    // one of a few things could happen
    // 1. shrink a range
    // 2. split a range
    // 3. remove a range

    if( iter == end() ) return end();

    // the iterator most likely to be returned
    iterator new_iter = iter;
    ++new_iter;

    PairNode* kter = iter.mNode;

    // just remove the range
    if( kter->first == kter->second )
    {
        kter->mNext->mPrev = kter->mPrev;
        kter->mPrev->mNext = kter->mNext;
        free_pair( kter );
        return new_iter;
    }
    // shrink it
    else if( kter->first == iter.mValue )
    {
        kter->first++;
        return new_iter;
    }
    // shrink it the other way
    else if( kter->second == iter.mValue )
    {
        kter->second--;
        return new_iter;
    }
    // split the range
    else
    {
        PairNode* new_node     = alloc_pair( iter.mNode->mNext, iter.mNode, iter.mValue + 1, kter->second );
        new_node->mPrev->mNext = new_node->mNext->mPrev = new_node;
        iter.mNode->second                              = iter.mValue - 1;
        new_iter                                        = const_iterator( new_node, new_node->first );
        return new_iter;
    }
}

Range::iterator moab::Range::erase	(	iterator	iter1,
		iterator	iter2
	)

remove a range of items from the list

Definition at line 411 of file Range.cpp.

References alloc_pair(), delete_pair_node(), mHead, moab::Range::PairNode::mNext, moab::Range::const_iterator::mNode, moab::Range::PairNode::mPrev, and moab::Range::const_iterator::mValue.

{
    iterator result;

    if( iter1.mNode == iter2.mNode )
    {
        if( iter2.mValue <= iter1.mValue )
        {
            // empty range OK, otherwise invalid input
            return iter2;
        }

        // If both iterators reference the same pair node, then
        // we're either removing values from the front of the
        // node or splitting the node.  We can never be removing
        // the last value in the node in this case because iter2
        // points *after* the last entry to be removed.

        PairNode* node = iter1.mNode;
        if( iter1.mValue == node->first )
        {
            node->first = iter2.mValue;
            result      = iter2;
        }
        else
        {
            PairNode* new_node     = alloc_pair( node->mNext, node, iter2.mValue, node->second );
            new_node->mNext->mPrev = new_node;
            new_node->mPrev->mNext = new_node;
            node->second           = iter1.mValue - 1;
            result                 = iterator( new_node, new_node->first );
        }
    }
    else
    {
        if( iter1.mNode == &mHead ) return iter1;
        PairNode* dn = iter1.mNode;
        if( iter1.mValue > dn->first )
        {
            dn->second = iter1.mValue - 1;
            dn         = dn->mNext;
        }
        if( iter2.mNode != &mHead ) iter2.mNode->first = iter2.mValue;
        while( dn != iter2.mNode )
        {
            PairNode* dead = dn;
            dn             = dn->mNext;

            dead->mPrev->mNext = dead->mNext;
            dead->mNext->mPrev = dead->mPrev;
            // dead->mPrev = dead->mNext = 0;
            delete_pair_node( dead );
        }

        result = iter2;
    }

    return result;
}

Range::iterator moab::Range::erase ( EntityHandle val ) [inline]

erases a value from this container

Definition at line 891 of file Range.hpp.

References erase(), and find().

{
    return erase( find( val ) );
}

Range::const_iterator moab::Range::find ( EntityHandle val ) const

find an item int the list and return an iterator at that value

finds a value in the list. this method is preferred over other algorithms because it can be found faster this way.

Definition at line 510 of file Range.cpp.

References end(), mHead, and moab::Range::PairNode::mNext.

Referenced by moab::Core::check_adjacencies(), check_children(), moab::DualTool::check_dual_adjs(), moab::AEntityFactory::check_equiv_entities(), moab::Skinner::classify_2d_boundary(), moab::FBEngine::compute_intersection_points(), smoab::CellSet::contains(), moab::GeomTopoTool::duplicate_model(), erase(), FBiGeom_getEnt2ndAdj(), moab::Skinner::find_skin_noadj(), moab::ReadUtil::gather_related_ents(), moab::GeomTopoTool::geometrize_surface_set(), moab::FBEngine::getAdjacentEntities(), moab::FBEngine::getEntType(), ZoltanPartitioner::include_closure(), moab::Intx2Mesh::intersect_meshes(), moab::GeomTopoTool::is_owned_set(), moab::FBEngine::isEntAdj(), merge_duplicate_vertices(), moab::HiReconstruction::obtain_nring_ngbvs(), moab::ParallelComm::pack_entities(), moab::WriteHDF5Parallel::remove_remote_entities(), moab::WriteHDF5Parallel::remove_remote_sets(), moab::FBEngine::separate(), moab::ParallelComm::settle_intersection_points(), moab::FBEngine::split_boundary(), moab::DualTool::split_pair_nonmanifold(), subtract_test(), swap_test(), test_read_nodes_common(), test_read_nothing_common(), test_read_set_sets(), test_read_two_sets_elems(), moab::DualTool::traverse_hyperplane(), tri_in_set(), moab::vector_remove_range(), moab::FBEngine::weave_lateral_face_from_edges(), and moab::WriteSLAC::write_matsets().

{
    // iterator through the list
    PairNode* iter = mHead.mNext;
    for( ; iter != &mHead && ( val > iter->second ); iter = iter->mNext )
        ;
    return ( ( iter->second >= val ) && ( iter->first <= val ) ) ? const_iterator( iter, val ) : end();
}

const EntityHandle & moab::Range::front ( ) const [inline]

get first entity in range

Definition at line 907 of file Range.hpp.

References mHead, and moab::Range::PairNode::mNext.

Referenced by add_dead_elems_to_impl_compl(), all_of_dimension(), all_of_type(), moab::ReadMCNP5::average_with_existing_tally(), check_children(), check_geometric_set(), check_num_verts(), moab::MeshTag::clear_data(), moab::OrientedBoxTreeTool::closest_to_location(), moab::ReadIDEAS::create_elements(), moab::ReadHDF5::delete_non_side_elements(), moab::GeomTopoTool::entity_by_id(), erase_test(), find_sideset(), moab::Skinner::find_skin_vertices(), fix_surface_senses(), moab::WriteNCDF::gather_mesh_information(), moab::WriteUtil::gather_nodes_from_elements(), moab::MeshTag::get_data(), moab::ParallelComm::get_part_handle(), moab::ReadHDF5::get_partition(), moab::ReadHDF5::insert_in_id_map(), moab::Intx2Mesh::intersect_meshes(), main(), make_mesh(), mb_common_tag_test(), mb_merge_update_test(), mb_mesh_set_appends(), mb_mesh_set_flag_test(), mb_skin_curve_test_common(), mb_skin_poly_test(), mb_skin_reversed_common(), mb_skin_surface_test_common(), mb_type_is_maxtype_test(), mb_vertex_coordinate_test(), orient_faces_outward(), overlap_test_measure_volume(), overlap_test_point_in_volume(), overlap_test_ray_fire(), overlap_test_surface_sense(), overlap_test_tracking(), pop_front(), moab::ReadHDF5::read_elems(), moab::ReadHDF5VarLen::read_offsets(), read_sets(), smoab::DataSetConverter::readProperties(), regression_one_entity_by_var_tag(), moab::MeshTag::remove_data(), replace_faceted_cgm_surfs(), moab::GeomTopoTool::resize_rootSets(), moab::GeomTopoTool::restore_topology_from_adjacency(), moab::MeshTag::set_data(), moab::GeomTopoTool::setup_implicit_complement(), moab::OrientedBoxTreeTool::sphere_intersect_triangles(), subset_by_dimension_test(), test_bc_sets(), test_blocks(), test_closest_to_location(), test_delete_bit_data(), test_delete_obb_tree(), test_delete_tag_data(), test_delete_type_tag(), test_get_by_tag_value_dense(), test_get_ents_with_default_value(), test_iterates(), test_list_set_with_stale_handles(), test_measure_volume(), test_moab_v3_poly_format(), test_pack_elements(), test_pack_higher_order(), test_pack_poly(), test_pack_set_contents(), test_pack_sets_of_sets(), test_pack_sets_simple(), test_pack_tag_data_default_value(), test_point_in_volume(), test_ranged_set_with_stale_handles(), test_ray_fire(), test_read_adjacencies(), test_read_alternate_coord_format(), test_read_elements_common(), test_read_geom_set(), test_read_material_on_nodes(), test_read_material_set(), test_read_material_set1(), test_read_material_set2(), test_read_physical_set(), test_read_set_sets(), test_read_two_sets_elems(), test_restore_obb_trees(), test_set_flags(), test_surface_sense(), test_tree(), test_tree_readwrite(), test_var_length_big_data(), test_write_shared_sets(), and test_write_unbalanced().

{
    return mHead.mNext->first;
}

unsigned long moab::Range::get_memory_use ( ) const

Definition at line 997 of file Range.cpp.

References mHead, and moab::Range::PairNode::mNext.

Referenced by compactness().

{
    unsigned long result = 0;
    for( const PairNode* n = mHead.mNext; n != &mHead; n = n->mNext )
        result += sizeof( PairNode );
    return result;
}

int moab::Range::index ( EntityHandle handle ) const [inline]

Examples:: ExtrudePoly.cpp, and LaplacianSmoother.cpp.

Definition at line 936 of file Range.hpp.

References begin(), const_pair_begin(), const_pair_end(), and rbegin().

{
    if( handle < *begin() || handle > *rbegin() ) return -1;

    unsigned int i                 = 0;
    Range::const_pair_iterator pit = const_pair_begin();
    while( handle > ( *pit ).second && pit != const_pair_end() )
    {
        i += ( *pit ).second - ( *pit ).first + 1;
        ++pit;
    }
    if( handle < ( *pit ).first || pit == const_pair_end() ) return -1;

    return i + handle - ( *pit ).first;
}

Range::iterator moab::Range::insert	(	Range::iterator	hint,
		EntityHandle	val
	)

inserts a single value into this range

Examples:: ExtractLand.cpp, LaplacianSmoother.cpp, LloydRelaxation.cpp, and QuadTriConv.cpp.

Definition at line 229 of file Range.cpp.

References alloc_pair(), end(), free_pair(), mHead, moab::Range::PairNode::mNext, moab::Range::const_iterator::mNode, and moab::Range::PairNode::mPrev.

{
    // don't allow zero-valued handles in Range
    if( val == 0 ) return end();

    // if this is empty, just add it and return an iterator to it
    if( &mHead == mHead.mNext )
    {
        mHead.mNext = mHead.mPrev = alloc_pair( &mHead, &mHead, val, val );
        return iterator( mHead.mNext, val );
    }

    // find the location in the list where we can safely insert
    // new items and keep it ordered
    PairNode* hter = hint.mNode;
    PairNode* jter = hter->first <= val ? hter : mHead.mNext;
    for( ; ( jter != &mHead ) && ( jter->second < val ); jter = jter->mNext )
        ;
    PairNode* iter = jter;
    jter           = jter->mPrev;

    // if this val is already in the list
    if( ( iter->first <= val && iter->second >= val ) && ( iter != &mHead ) )
    {
        // return an iterator pointing to this location
        return iterator( iter, val );
    }

    // one of a few things can happen at this point
    // 1. this range needs to be backwardly extended
    // 2. the previous range needs to be forwardly extended
    // 3. a new range needs to be added

    // extend this range back a bit
    else if( ( iter->first == ( val + 1 ) ) && ( iter != &mHead ) )
    {
        iter->first = val;
        // see if we need to merge two ranges
        if( ( iter != mHead.mNext ) && ( jter->second == ( val - 1 ) ) )
        {
            jter->second       = iter->second;
            iter->mPrev->mNext = iter->mNext;
            iter->mNext->mPrev = iter->mPrev;
            free_pair( iter );
            return iterator( jter, val );
        }
        else
        {
            return iterator( iter, val );
        }
    }
    // extend the previous range forward a bit
    else if( ( jter->second == ( val - 1 ) ) && ( iter != mHead.mNext ) )
    {
        jter->second = val;
        return iterator( jter, val );
    }
    // make a new range
    else
    {
        PairNode* new_node = alloc_pair( iter, iter->mPrev, val, val );
        iter->mPrev = new_node->mPrev->mNext = new_node;
        return iterator( new_node, val );
    }
}

iterator moab::Range::insert ( EntityHandle val ) [inline]

insert an item into the list and return the iterator for the inserted item

Definition at line 250 of file Range.hpp.

    {
        return insert( begin(), val );
    }

Range::iterator moab::Range::insert	(	Range::iterator	prev,
		EntityHandle	first,
		EntityHandle	last
	)

insert a range of items into this list and return the iterator for the first inserted item

Definition at line 295 of file Range.cpp.

References alloc_pair(), end(), moab::GeomUtil::first(), free_pair(), mHead, moab::Range::PairNode::mNext, moab::Range::const_iterator::mNode, and moab::Range::PairNode::mPrev.

{
    if( val1 == 0 || val1 > val2 ) return end();

    // Empty
    if( mHead.mNext == &mHead )
    {
        assert( prev == end() );
        PairNode* new_node = alloc_pair( &mHead, &mHead, val1, val2 );
        mHead.mNext = mHead.mPrev = new_node;
        return iterator( mHead.mNext, val1 );
    }

    PairNode* iter = prev.mNode;
    // If iterator is at end, set it to last.
    // Thus if the hint was to append, we start searching
    // at the end of the list.
    if( iter == &mHead ) iter = mHead.mPrev;
    // if hint (prev) is past insert position, reset it to the beginning.
    if( iter != &mHead && iter->first > val2 + 1 ) iter = mHead.mNext;

    // If hint is bogus then search backwards
    while( iter != mHead.mNext && iter->mPrev->second >= val1 - 1 )
        iter = iter->mPrev;

    // Input range is before beginning?
    if( iter->mPrev == &mHead && val2 < iter->first - 1 )
    {
        PairNode* new_node = alloc_pair( iter, &mHead, val1, val2 );
        mHead.mNext = iter->mPrev = new_node;
        return iterator( mHead.mNext, val1 );
    }

    // Find first intersecting list entry, or the next entry
    // if none intersects.
    while( iter != &mHead && iter->second + 1 < val1 )
        iter = iter->mNext;

    // Need to insert new pair (don't intersect any existing pair)?
    if( iter == &mHead || iter->first - 1 > val2 )
    {
        PairNode* new_node = alloc_pair( iter, iter->mPrev, val1, val2 );
        iter->mPrev = iter->mPrev->mNext = new_node;
        return iterator( iter->mPrev, val1 );
    }

    // Make the first intersecting pair the union of itself with [val1,val2]
    if( iter->first > val1 ) iter->first = val1;
    if( iter->second >= val2 ) return iterator( iter, val1 );
    iter->second = val2;

    // Merge any remaining pairs that intersect [val1,val2]
    while( iter->mNext != &mHead && iter->mNext->first <= val2 + 1 )
    {
        PairNode* dead     = iter->mNext;
        iter->mNext        = dead->mNext;
        dead->mNext->mPrev = iter;

        if( dead->second > val2 ) iter->second = dead->second;
        free_pair( dead );
    }

    return iterator( iter, val1 );
}

iterator moab::Range::insert	(	EntityHandle	val1,
		EntityHandle	val2
	)		`[inline]`

insert a range of items into this list and return the iterator for the first inserted item

Definition at line 261 of file Range.hpp.

    {
        return insert( begin(), val1, val2 );
    }

template<class T >

iterator moab::Range::insert	(	typename T::const_iterator	begin_iter,
		typename T::const_iterator	end_iter
	)		`[inline]`

Definition at line 270 of file Range.hpp.

    {
        return insert_list( begin_iter, end_iter );
    }

template<typename T >

iterator moab::Range::insert	(	const T *	begin_iter,
		const T *	end_iter
	)		`[inline]`

Definition at line 276 of file Range.hpp.

    {
        return insert_list( begin_iter, end_iter );
    }

void moab::Range::insert	(	Range::const_iterator	begini,
		Range::const_iterator	endi
	)

merges another Range with this one

Definition at line 523 of file Range.cpp.

References insert(), moab::Range::PairNode::mNext, and moab::Range::const_iterator::mNode.

{
    if( begini == endi ) return;

    PairNode* node = begini.mNode;
    if( endi.mNode == node )
    {
        insert( *begini, ( *endi ) - 1 );
        return;
    }

    Range::iterator hint = insert( *begini, node->second );
    node                 = node->mNext;
    while( node != endi.mNode )
    {
        hint = insert( hint, node->first, node->second );
        node = node->mNext;
    }

    if( *endi > node->first )
    {
        if( *endi <= node->second )
            insert( hint, node->first, *(endi)-1 );
        else
            insert( hint, node->first, node->second );
    }
}

template<typename T >

iterator moab::Range::insert_list	(	T	begin_iter,
		T	end_iter
	)

Referenced by moab::GeomTopoTool::delete_obb_tree(), and test_restore_obb_trees().

template<typename Iterator >

Range::iterator moab::Range::insert_list	(	Iterator	begin_iter,
		Iterator	end_iter
	)

Definition at line 959 of file Range.hpp.

References begin(), and insert().

{
    size_t n             = std::distance( begin_iter, end_iter );
    EntityHandle* sorted = new EntityHandle[n];
    std::copy( begin_iter, end_iter, sorted );
    std::sort( sorted, sorted + n );
    iterator hint = begin();
    size_t i      = 0;
    while( i < n )
    {
        size_t j = i + 1;
        while( j < n && sorted[j] == 1 + sorted[j - 1] )
            ++j;
        hint = insert( hint, sorted[i], sorted[i] + ( ( j - i ) - 1 ) );
        i    = j;
    }
    delete[] sorted;
    return hint;
}

Range::const_iterator moab::Range::lower_bound	(	Range::const_iterator	first,
		Range::const_iterator	last,
		EntityHandle	val
	)		`[static]`

return an iterator to the first value >= val

Definition at line 809 of file Range.cpp.

References moab::Range::PairNode::mNext, and moab::Range::const_iterator::mNode.

Referenced by MetisPartitioner::assemble_taggedsets_graph(), moab::AxisBox::calculate(), moab::OrientedBox::compute_from_vertices(), moab::OrientedBox::covariance_data_from_tris(), moab::ReadHDF5::delete_non_side_elements(), equal_range(), moab::ParallelComm::estimate_ents_buffer_size(), moab::ParallelComm::estimate_sets_buffer_size(), moab::DenseTag::find_entities_with_value(), moab::VarLenDenseTag::find_entities_with_value(), moab::WriteVtk::gather_mesh(), moab::ReadHDF5::get_partition(), moab::ParallelComm::get_shared_entities(), identify_set(), iMesh_createStructuredMesh(), moab::intersect(), moab::AdaptiveKDTree::intersect_children_with_elems(), moab::ReadHDF5::load_file_partial(), moab::WriteGMV::local_write_mesh(), lower_bound(), main(), mb_range_seq_intersect_test(), min_edge_length(), moab::ParallelComm::pack_entities(), moab::ReadHDF5::read_set_ids_recursive(), moab::ReadHDF5::read_tag_values_partial(), moab::WriteHDF5Parallel::remove_remote_entities(), moab::ParallelComm::resolve_shared_ents(), moab::ParallelComm::resolve_shared_sets(), subset_by_dimension(), moab::ParallelMergeMesh::TagSharedElements(), moab::BoundBox::update(), upper_bound(), and TreeValidator::visit().

{
    // Find the first pair whose end is >= val
    PairNode* iter;
    for( iter = first.mNode; iter != last.mNode; iter = iter->mNext )
    {
        if( iter->second >= val )
        {
            // This is the correct pair.  Either 'val' is in the range, or
            // the range starts before 'val' and iter->first IS the lower_bound.
            if( iter->first > val ) return const_iterator( iter, iter->first );
            return const_iterator( iter, val );
        }
    }

    if( iter->first >= val )
        return const_iterator( iter, iter->first );
    else if( *last > val )
        return const_iterator( iter, val );
    else
        return last;
}

const_iterator moab::Range::lower_bound ( EntityHandle val ) const [inline]

Definition at line 306 of file Range.hpp.

    {
        return lower_bound( begin(), end(), val );
    }

Range::const_iterator moab::Range::lower_bound ( EntityType type ) const

Definition at line 839 of file Range.cpp.

References begin(), moab::CREATE_HANDLE(), end(), and lower_bound().

{
    int err;
    EntityHandle handle = CREATE_HANDLE( type, 0, err );
    return err ? end() : lower_bound( begin(), end(), handle );
}

Range::const_iterator moab::Range::lower_bound	(	EntityType	type,
		const_iterator	first
	)		const

Definition at line 845 of file Range.cpp.

References moab::CREATE_HANDLE(), end(), and lower_bound().

{
    int err;
    EntityHandle handle = CREATE_HANDLE( type, 0, err );
    return err ? end() : lower_bound( first, end(), handle );
}

void moab::Range::merge ( const Range & range ) [inline]

merges this Range with another range

Examples:: ComputeTriDual.cpp, DeformMeshRemap.cpp, and ReduceExchangeTags.cpp.

Definition at line 346 of file Range.hpp.

References begin(), and end().

Referenced by moab::DualTool::atomic_pillow(), moab::MeshGeneration::BrickInstance(), moab::AdaptiveKDTree::build_tree(), moab::AxisBox::calculate(), moab::ParallelComm::check_my_shared_handles(), moab::WriteHDF5Parallel::communicate_shared_set_data(), compute_dual_mesh(), moab::DualTool::construct_dual_faces(), moab::TempestRemapper::convert_tempest_mesh_private(), create_int_ents(), moab::NCHelperHOMME::create_mesh(), DeformMeshRemap::deform_master(), do_file(), dot_get_sets(), moab::WriteHDF5Parallel::exchange_file_ids(), moab::ParallelComm::exchange_owned_mesh(), DeformMeshRemap::execute(), FBiGeom_getArrAdj(), moab::Skinner::find_skin(), moab::Skinner::find_skin_scd(), moab::Skinner::find_skin_vertices_3D(), moab::DualTool::foc_delete_dual(), moab::DualTool::foc_get_addl_ents(), moab::WriteHDF5Parallel::gather_interface_meshes(), moab::WriteVtk::gather_mesh(), moab::WriteHDF5::gather_mesh_info(), moab::ReadUtil::gather_related_ents(), moab::MeshTopoUtil::get_bridge_adjacencies(), moab::Core::get_connectivity(), get_entities(), moab::Core::get_entities_by_type_and_tag(), get_ents_from_geometric_sets(), moab::ParallelComm::get_ghosted_entities(), moab::MeshTopoUtil::get_manifold(), moab::ParallelComm::get_part_entities(), moab::ParallelComm::get_sent_ents(), moab::ReadABAQUS::get_set_elements(), moab::ReadABAQUS::get_set_nodes(), moab::ParallelComm::get_shared_entities(), moab::WriteHDF5::get_sparse_tagged_entities(), moab::WriteHDF5::get_tag_data_length(), moab::WriteSTL::get_triangles(), moab::Core::get_vertices(), moab::WriteHDF5::get_write_entities(), moab::FBEngine::getEntities(), moab::TempestRemapper::GetOverlapAugmentedEntities(), identify_set(), iMesh_getEntsByTagsRec(), iMOAB_CreateElements(), iMOAB_CreateVertices(), moab::ReorderTool::int_order_from_sets_and_adj(), moab::intersect(), moab::Intx2Mesh::intersect_meshes(), moab::Intx2Mesh::intersect_meshes_kdtree(), moab::ReadHDF5::load_file_partial(), main(), mb_mesh_set_appends(), mb_skin_poly_test(), merge_duplicate_vertices(), merge_test(), obbvis_create(), pack_unpack_noremoteh(), moab::AdaptiveKDTree::print(), print_stats(), moab::Tqdcfr::read_block(), moab::ReadABAQUS::read_element_set(), DeformMeshRemap::read_file(), moab::ReadABAQUS::read_node_set(), moab::Tqdcfr::read_nodes(), moab::ReadHDF5::read_set_ids_recursive(), moab::ReadHDF5::read_sparse_tag(), moab::ReadHDF5::read_tag_values_partial(), moab::ReadCCMIO::read_vertices(), moab::ParCommGraph::receive_mesh(), regression_insert_set_1(), moab::WriteHDF5Parallel::remove_remote_entities(), report_iface_ents(), moab::GeomTopoTool::resize_rootSets(), moab::ParallelComm::resolve_shared_ents(), moab::ParallelComm::resolve_shared_sets(), moab::ParallelComm::send_entities(), moab::ParCommGraph::send_mesh_parts(), set_intersection_query(), moab::Skinner::skin_box(), skin_common(), moab::MeshTopoUtil::split_entities_manifold(), tag_time(), moab::ParallelMergeMesh::TagSharedElements(), test_boolean(), test_elements_on_several_procs(), test_ghost_elements(), test_pack_sets_simple(), test_valid_tree(), moab::WriteCCMIO::write_cells_and_faces(), moab::WriteVtk::write_elems(), moab::WriteGmsh::write_file(), moab::WriteHDF5::write_sparse_ids(), moab::WriteHDF5::write_tag_values(), moab::WriteVtk::write_tags(), and moab::WriteHDF5::write_var_len_indices().

    {
        insert( range.begin(), range.end() );
    }

void moab::Range::merge	(	Range::const_iterator	beginr,
		Range::const_iterator	endr
	)		`[inline]`

merge a subset of some other range

Definition at line 352 of file Range.hpp.

    {
        insert( beginr, endr );
    }

unsigned moab::Range::num_of_dimension ( int dim ) const

Examples:: HelloParMOAB.cpp.

Definition at line 911 of file Range.cpp.

References const_pair_begin(), const_pair_end(), moab::CREATE_HANDLE(), moab::CN::Dimension(), moab::GeomUtil::first(), MB_END_ID, moab::TYPE_FROM_HANDLE(), and moab::CN::TypeDimensionMap.

Referenced by main().

{
    const_pair_iterator iter = const_pair_begin();
    while( iter != const_pair_end() && CN::Dimension( TYPE_FROM_HANDLE( ( *iter ).second ) ) < dim )
        ++iter;

    int junk;
    unsigned count = 0;
    for( ; iter != const_pair_end(); ++iter )
    {
        int start_dim = CN::Dimension( TYPE_FROM_HANDLE( ( *iter ).first ) );
        int end_dim   = CN::Dimension( TYPE_FROM_HANDLE( ( *iter ).second ) );
        if( start_dim > dim ) break;

        EntityHandle sh = start_dim < dim ? CREATE_HANDLE( CN::TypeDimensionMap[dim].first, 1, junk ) : ( *iter ).first;
        EntityHandle eh =
            end_dim > dim ? CREATE_HANDLE( CN::TypeDimensionMap[dim].second, MB_END_ID, junk ) : ( *iter ).second;
        count += eh - sh + 1;
    }

    return count;
}

unsigned moab::Range::num_of_type ( EntityType type ) const

Definition at line 890 of file Range.cpp.

References const_pair_begin(), const_pair_end(), moab::ID_FROM_HANDLE(), MB_END_ID, and moab::TYPE_FROM_HANDLE().

Referenced by moab::ParallelComm::estimate_ents_buffer_size(), and test_pack_sets_simple().

{
    const_pair_iterator iter = const_pair_begin();
    while( iter != const_pair_end() && TYPE_FROM_HANDLE( ( *iter ).second ) < type )
        ++iter;

    unsigned count = 0;
    for( ; iter != const_pair_end(); ++iter )
    {
        EntityType start_type = TYPE_FROM_HANDLE( ( *iter ).first );
        EntityType end_type   = TYPE_FROM_HANDLE( ( *iter ).second );
        if( start_type > type ) break;

        EntityID sid = start_type < type ? 1 : ID_FROM_HANDLE( ( *iter ).first );
        EntityID eid = end_type > type ? MB_END_ID : ID_FROM_HANDLE( ( *iter ).second );
        count += eid - sid + 1;
    }

    return count;
}

Range & moab::Range::operator-= ( const Range & rhs )

just like subtract, but as an operator

Definition at line 730 of file Range.cpp.

References alloc_pair(), begin(), const_pair_begin(), delete_pair_node(), end(), erase(), moab::Range::PairNode::mNext, moab::Range::PairNode::mPrev, moab::Range::pair_iterator::node(), and pair_begin().

{
    const bool braindead = false;

    if( braindead )
    {
        // brain-dead implementation right now
        Range res( *this );
        for( Range::const_iterator rit = range2.begin(); rit != range2.end(); ++rit )
            res.erase( *rit );

        return *this;
    }
    else
    {
        Range::pair_iterator r_it0       = this->pair_begin();
        Range::const_pair_iterator r_it1 = range2.const_pair_begin();

        // terminate the while loop when at least one "start" iterator is at the
        // end of the list
        while( r_it0 != this->end() && r_it1 != range2.end() )
        {
            // case a: pair wholly within subtracted pair
            if( r_it0->first >= r_it1->first && r_it0->second <= r_it1->second )
            {
                Range::PairNode* rtmp = r_it0.node();
                ++r_it0;
                this->delete_pair_node( rtmp );
            }
            // case b: pair overlaps upper part of subtracted pair
            else if( r_it0->first <= r_it1->second && r_it0->first >= r_it1->first )
            {
                r_it0->first = r_it1->second + 1;
                ++r_it1;
            }
            // case c: pair overlaps lower part of subtracted pair
            else if( r_it0->second >= r_it1->first && r_it0->second <= r_it1->second )
            {
                r_it0->second = r_it1->first - 1;
                ++r_it0;
            }
            // case d: pair completely surrounds subtracted pair
            else if( r_it0->first < r_it1->first && r_it0->second > r_it1->second )
            {
                Range::PairNode* new_node =
                    alloc_pair( r_it0.node(), r_it0.node()->mPrev, r_it0->first, r_it1->first - 1 );
                new_node->mPrev->mNext = new_node->mNext->mPrev = new_node;
                r_it0.node()->first                             = r_it1->second + 1;
                ++r_it1;
            }
            else
            {
                while( r_it0->second < r_it1->first && r_it0 != this->end() )
                    ++r_it0;
                if( r_it0 == this->end() ) break;
                while( r_it1->second < r_it0->first && r_it1 != range2.end() )
                    ++r_it1;
            }
        }
        return *this;
    }
}

Range & moab::Range::operator= ( const Range & copy )

operator=

Definition at line 210 of file Range.cpp.

References alloc_pair(), clear(), mHead, moab::Range::PairNode::mNext, and moab::Range::PairNode::mPrev.

{
    clear();
    const PairNode* copy_node = copy.mHead.mNext;
    PairNode* new_node        = &mHead;
    for( ; copy_node != &( copy.mHead ); copy_node = copy_node->mNext )
    {
        PairNode* tmp_node     = alloc_pair( new_node->mNext, new_node, copy_node->first, copy_node->second );
        new_node->mNext->mPrev = tmp_node;
        new_node->mNext        = tmp_node;
        new_node               = tmp_node;
    }
    return *this;
}

EntityHandle moab::Range::operator[] ( EntityID index ) const [inline]

Definition at line 929 of file Range.hpp.

References begin().

{
    Range::const_iterator i = begin();
    i += indexp;
    return *i;
}

pair_iterator moab::Range::pair_begin ( ) [inline]

Definition at line 739 of file Range.hpp.

Referenced by moab::ReadUtil::assign_ids(), moab::NCHelperScrip::create_mesh(), moab::DataCoupler::DataCoupler(), moab::UcdNCWriteHelper::jik_to_kji_stride(), moab::UcdNCHelper::kji_to_jik_stride(), operator-=(), moab::NCHelperHOMME::read_ucd_variables_to_nonset(), moab::NCHelperMPAS::read_ucd_variables_to_nonset(), moab::NCHelperGCRM::read_ucd_variables_to_nonset(), moab::subtract(), moab::NCWriteGCRM::write_nonset_variables(), moab::NCWriteHOMME::write_nonset_variables(), and moab::NCWriteMPAS::write_nonset_variables().

    {
        return pair_iterator( mHead.mNext );
    }

const_pair_iterator moab::Range::pair_begin ( ) const [inline]

Definition at line 756 of file Range.hpp.

    {
        return const_pair_iterator( mHead.mNext );
    }

pair_iterator moab::Range::pair_end ( ) [inline]

Definition at line 743 of file Range.hpp.

Referenced by moab::ReadUtil::assign_ids(), moab::NCHelperScrip::create_mesh(), moab::DataCoupler::DataCoupler(), moab::UcdNCWriteHelper::jik_to_kji_stride(), moab::UcdNCHelper::kji_to_jik_stride(), moab::NCHelperHOMME::read_ucd_variables_to_nonset(), moab::NCHelperMPAS::read_ucd_variables_to_nonset(), moab::NCHelperGCRM::read_ucd_variables_to_nonset(), moab::NCWriteHOMME::write_nonset_variables(), moab::NCWriteGCRM::write_nonset_variables(), and moab::NCWriteMPAS::write_nonset_variables().

    {
        return pair_iterator( &mHead );
    }

const_pair_iterator moab::Range::pair_end ( ) const [inline]

Definition at line 760 of file Range.hpp.

    {
        return const_pair_iterator( &mHead );
    }

EntityHandle moab::Range::pop_back ( )

remove last entity from range

Definition at line 494 of file Range.cpp.

References back(), delete_pair_node(), mHead, and moab::Range::PairNode::mPrev.

Referenced by moab::DualTool::delete_dual_entities(), MetisPartitioner::write_aggregationtag_partition(), MetisPartitioner::write_partition(), and ZoltanPartitioner::write_partition().

{
    EntityHandle retval = back();
    if( mHead.mPrev->first == mHead.mPrev->second )  // need to remove pair from range
        delete_pair_node( mHead.mPrev );
    else
        --( mHead.mPrev->second );  // otherwise just adjust end value of pair

    return retval;
}

EntityHandle moab::Range::pop_front ( )

remove first entity from range

Definition at line 482 of file Range.cpp.

References delete_pair_node(), front(), mHead, and moab::Range::PairNode::mNext.

Referenced by moab::GeomTopoTool::insert_in_tree(), and test_read_nodes_common().

{
    EntityHandle retval = front();
    if( mHead.mNext->first == mHead.mNext->second )  // need to remove pair from range
        delete_pair_node( mHead.mNext );
    else
        ++( mHead.mNext->first );  // otherwise just adjust start value of pair

    return retval;
}

void moab::Range::print ( const char * indent_prefix = NULL ) const

Examples:: GetEntities.cpp, SetsNTags.cpp, and TestExodusII.cpp.

Definition at line 618 of file Range.cpp.

Referenced by moab::MeshGeneration::BrickInstance(), moab::ParallelComm::list_entities(), main(), moab::operator<<(), moab::ParallelComm::pack_tag(), moab::Core::print(), report_nsets(), and test_adjacencies().

{
    print( std::cout, indent_prefix );
}

void moab::Range::print	(	std::ostream &	s,
		const char *	indent_prefix = `NULL`
	)		const

Definition at line 612 of file Range.cpp.

References str_rep().

{
    stream << str_rep( indent_prefix );
}

size_t moab::Range::psize ( ) const [inline]

return the number of range pairs in the list

Definition at line 979 of file Range.hpp.

References const_pair_begin(), and const_pair_end().

Referenced by moab::RangeSetIterator::build_pair_vec(), moab::SpectralMeshTool::convert_to_coarse(), moab::convert_to_ranged_ids(), moab::NCHelperScrip::create_mesh(), moab::ParallelComm::gather_data(), gather_one_cell_var(), moab::ReadHDF5::load_file_partial(), moab::merge_ranged_ids(), multiple_loads_of_same_file(), moab::PACK_RANGE(), moab::ReadDamsel::process_ent_info(), moab::RANGE_SIZE(), moab::ReadHDF5::read_elems(), read_mesh_parallel(), read_one_cell_var(), moab::ScdNCHelper::read_scd_variables_to_nonset_allocate(), moab::NCHelperHOMME::read_ucd_variables_to_nonset(), moab::NCHelperGCRM::read_ucd_variables_to_nonset(), moab::NCHelperMPAS::read_ucd_variables_to_nonset(), moab::NCHelperHOMME::read_ucd_variables_to_nonset_allocate(), moab::NCHelperMPAS::read_ucd_variables_to_nonset_allocate(), moab::NCHelperGCRM::read_ucd_variables_to_nonset_allocate(), test_gather_onevar(), test_iterates(), test_read_all(), test_read_no_mixed_elements(), test_read_novars(), test_read_onevar(), test_sequences_after_ghosting(), moab::NCWriteGCRM::write_nonset_variables(), moab::NCWriteHOMME::write_nonset_variables(), and moab::NCWriteMPAS::write_nonset_variables().

{
    size_t i = 0;
    Range::const_pair_iterator pit;
    for( pit = const_pair_begin(), i = 0; pit != const_pair_end(); ++pit, i++ )
        ;

    return i;
}

Range::const_reverse_iterator moab::Range::rbegin ( ) const [inline]

return the beginning const reverse iterator of this range

Examples:: DeformMeshRemap.cpp.

Definition at line 866 of file Range.hpp.

References mHead, and moab::Range::PairNode::mPrev.

Referenced by moab::SpatialLocator::add_elems(), MetisPartitioner::assemble_taggedsets_graph(), moab::DualTool::atomic_pillow(), moab::ParallelComm::check_clean_iface(), moab::WriteHDF5Parallel::communicate_shared_set_ids(), SphereDecomp::compute_nodes(), moab::ParCommGraph::compute_partition(), moab::DualTool::construct_dual_cells(), moab::DualTool::construct_dual_edges(), moab::DualTool::construct_dual_faces(), moab::DualTool::construct_dual_vertices(), moab::ParallelComm::create_iface_pc_links(), moab::SpatialLocator::create_tree(), moab::DataCoupler::DataCoupler(), moab::Core::delete_entities(), moab::DualTool::delete_whole_dual(), DeformMeshRemap::find_other_sets(), moab::DualTool::foc_get_ents(), get_ents(), index(), moab::OrientedBoxTreeTool::join_trees(), moab::WriteGMV::local_write_mesh(), moab::SpatialLocator::locate_points(), moab::DualTool::next_loop_vertex(), moab::GeomTopoTool::other_entity(), moab::ParallelComm::pack_entities(), ZoltanPartitioner::partition_owned_cells(), moab::LloydSmoother::perform_smooth(), moab::ReadTemplate::read_elements(), DeformMeshRemap::read_file(), moab::Tqdcfr::read_nodes(), moab::ParallelComm::resolve_shared_ents(), moab::DualTool::rev_atomic_pillow(), moab::ParallelComm::set_pstatus_entities(), moab::SpatialLocator::SpatialLocator(), moab::split_box(), moab::MeshTopoUtil::split_entities_manifold(), tag_depth(), moab::ParallelMergeMesh::TagSharedElements(), test_bit_tag_big(), test_filter_pstatus(), test_root_sets_resize(), moab::ParallelComm::unpack_sets(), moab::WriteCCMIO::write_external_faces(), and moab::WriteGmsh::write_file().

{
    return const_reverse_iterator( mHead.mPrev, mHead.mPrev->second );
}

Range::const_reverse_iterator moab::Range::rend ( ) const [inline]

return the ending const reverse iterator for this range

Definition at line 878 of file Range.hpp.

References mHead.

Referenced by moab::ParallelComm::check_clean_iface(), moab::WriteHDF5Parallel::communicate_shared_set_ids(), moab::Core::delete_entities(), moab::DualTool::delete_whole_dual(), moab::OrientedBoxTreeTool::join_trees(), moab::split_box(), moab::DualTool::split_pair_nonmanifold(), tag_depth(), test_bit_tag_big(), test_root_sets_resize(), and moab::WriteGmsh::write_file().

{
    return const_reverse_iterator( &mHead, mHead.second );
}

void moab::Range::sanity_check ( ) const

check for internal consistency

Definition at line 554 of file Range.cpp.

References empty(), mHead, moab::Range::PairNode::mNext, and moab::Range::PairNode::mPrev.

{
    if( empty() ) return;

    const PairNode* node = mHead.mNext;
    std::vector< const PairNode* > seen_before;
    bool stop_it = false;

    for( ; stop_it == false; node = node->mNext )
    {
        // have we seen this node before?
        assert( std::find( seen_before.begin(), seen_before.end(), node ) == seen_before.end() );
        seen_before.push_back( node );

        // is the connection correct?
        assert( node->mNext->mPrev == node );

        // are the values right?
        assert( node->first <= node->second );
        if( node != &mHead && node->mPrev != &mHead ) assert( node->mPrev->second < node->first );

        if( node == &mHead ) stop_it = true;
    }
}

size_t moab::Range::size ( ) const

return the number of values this Ranges represents

returns the number of values this list represents

Examples:: addPCdata.cpp, ComputeTriDual.cpp, copyPartition.cpp, DeformMeshRemap.cpp, DirectAccessNoHoles.cpp, DirectAccessWithHoles.cpp, ExtractLand.cpp, ExtrudePoly.cpp, GenLargeMesh.cpp, HelloMOAB.cpp, LaplacianSmoother.cpp, LloydRelaxation.cpp, LoadPartial.cpp, QuadTriConv.cpp, ReadPartFile.cpp, ReduceExchangeTags.cpp, SetsNTags.cpp, StructuredMeshSimple.cpp, TestExodusII.cpp, and VisTags.cpp.

Definition at line 77 of file Range.cpp.

References mHead, and moab::Range::PairNode::mNext.

{
    // go through each pair and add up the number of values
    // we have.
    size_t sz = 0;
    for( PairNode* iter = mHead.mNext; iter != &mHead; iter = iter->mNext )
    {
        sz += ( ( iter->second - iter->first ) + 1 );
    }
    return sz;
}

const std::string moab::Range::str_rep ( const char * indent_prefix = NULL ) const

for debugging

Definition at line 579 of file Range.cpp.

References const_pair_begin(), const_pair_end(), empty(), moab::CN::EntityTypeName(), moab::ID_FROM_HANDLE(), and moab::TYPE_FROM_HANDLE().

Referenced by print().

{
    std::stringstream str_stream;
    std::string indent_prefix_str;
    if( NULL != indent_prefix )
    {
        indent_prefix_str += indent_prefix;
    }

    if( empty() )
    {
        str_stream << indent_prefix_str << "\tempty" << std::endl;
        return str_stream.str().c_str();
    }

    for( const_pair_iterator i = const_pair_begin(); i != const_pair_end(); ++i )
    {
        EntityType t1 = TYPE_FROM_HANDLE( i->first );
        EntityType t2 = TYPE_FROM_HANDLE( i->second );

        str_stream << indent_prefix_str << "\t" << CN::EntityTypeName( t1 ) << " " << ID_FROM_HANDLE( i->first );
        if( i->first != i->second )
        {
            str_stream << " - ";
            if( t1 != t2 ) str_stream << CN::EntityTypeName( t2 ) << " ";
            str_stream << ID_FROM_HANDLE( i->second );
        }
        str_stream << std::endl;
    }

    return str_stream.str();
}

Range moab::Range::subset_by_dimension ( int dim ) const

return a subset of this range, by dimension

return a subset of this range, by type

Examples:: DeformMeshRemap.cpp, DirectAccessNoHoles.cpp, and DirectAccessWithHoles.cpp.

Definition at line 966 of file Range.cpp.

References begin(), moab::CREATE_HANDLE(), end(), moab::GeomUtil::first(), insert(), lower_bound(), and moab::CN::TypeDimensionMap.

Referenced by moab::ParCommGraph::compute_partition(), moab::SpectralMeshTool::convert_to_coarse(), DeformMeshRemap::find_other_sets(), moab::WriteNCDF::gather_mesh_information(), moab::ParallelComm::get_ghosted_entities(), get_max_volume(), moab::ReadParallel::load_file(), main(), DeformMeshRemap::read_file(), moab::ParCommGraph::receive_mesh(), refine_entities(), subset_by_dimension_test(), and test_adjacencies().

{
    EntityHandle handle1 = CREATE_HANDLE( CN::TypeDimensionMap[d].first, 0 );
    iterator st          = lower_bound( begin(), end(), handle1 );

    iterator en;
    if( d < 4 )
    {  // dimension 4 is MBENTITYSET
        EntityHandle handle2 = CREATE_HANDLE( CN::TypeDimensionMap[d + 1].first, 0 );
        en                   = lower_bound( st, end(), handle2 );
    }
    else
    {
        en = end();
    }

    Range result;
    result.insert( st, en );
    return result;
}

Range moab::Range::subset_by_type ( EntityType t ) const

return a subset of this range, by type

Definition at line 957 of file Range.cpp.

References equal_range(), and insert().

Referenced by moab::ParallelComm::add_verts(), moab::HalfFacetRep::check_mixed_entity_type(), cube_tris_connectivity_test(), moab::ReadParallel::delete_nonlocal_entities(), moab::ParallelComm::exchange_owned_meshs(), iMOAB_DeregisterApplication(), moab::Coupler::locate_points(), main(), mb_range_seq_intersect_test(), mb_skin_higher_order_pyramids(), moab::MergeMesh::merge_all(), moab::ParallelComm::pack_entities(), moab::ParallelComm::pack_sets(), pack_unpack_noremoteh(), moab::Tqdcfr::read_nodes(), moab::ParCommGraph::receive_mesh(), and moab::WriteVtk::write_elems().

{
    Range result;
    std::pair< const_iterator, const_iterator > iters = equal_range( t );
    result.insert( iters.first, iters.second );
    return result;
}

void moab::Range::swap ( Range & range )

swap the contents of this range with another one

swap the contents of this range with another one THIS FUNCTION MUST NOT BE INLINED, THAT WILL ELIMINATE RANGE_EMPTY AND THIS_EMPTY BY SUBSTITUTION AND THE FUNCTION WON'T WORK RIGHT!

Definition at line 937 of file Range.cpp.

References mHead, moab::Range::PairNode::mNext, and moab::Range::PairNode::mPrev.

Referenced by moab::AdaptiveKDTree::best_subdivision_plane(), moab::AdaptiveKDTree::best_subdivision_snap_plane(), moab::AdaptiveKDTree::best_vertex_median_plane(), moab::AdaptiveKDTree::best_vertex_sample_plane(), moab::OrientedBoxTreeTool::build_tree(), moab::ReadParallel::delete_nonlocal_entities(), dot_nodes(), moab::MeshTopoUtil::equivalent_entities(), moab::ParallelComm::filter_pstatus(), moab::Skinner::find_skin(), moab::Core::get_entities_by_type_and_tag(), moab::ReadHDF5::get_subset_ids(), moab::Core::get_vertices(), moab::DualTool::next_loop_vertex(), print_partitioned_entities(), moab::WriteHDF5Parallel::remove_remote_entities(), moab::WriteHDF5Parallel::remove_remote_sets(), moab::ParallelComm::resolve_shared_sets(), swap_test(), test_ghost_elements(), MetisPartitioner::write_aggregationtag_partition(), MetisPartitioner::write_partition(), and ZoltanPartitioner::write_partition().

{
    // update next/prev nodes of head of both ranges
    bool range_empty = ( range.mHead.mNext == &( range.mHead ) );
    bool this_empty  = ( mHead.mNext == &mHead );

    range.mHead.mNext->mPrev = ( range_empty ? &( range.mHead ) : &mHead );
    range.mHead.mPrev->mNext = ( range_empty ? &( range.mHead ) : &mHead );
    mHead.mNext->mPrev       = ( this_empty ? &mHead : &( range.mHead ) );
    mHead.mPrev->mNext       = ( this_empty ? &mHead : &( range.mHead ) );

    // switch data in head nodes of both ranges
    PairNode *range_next = range.mHead.mNext, *range_prev = range.mHead.mPrev;
    range.mHead.mNext = ( this_empty ? &( range.mHead ) : mHead.mNext );
    range.mHead.mPrev = ( this_empty ? &( range.mHead ) : mHead.mPrev );
    mHead.mNext       = ( range_empty ? &mHead : range_next );
    mHead.mPrev       = ( range_empty ? &mHead : range_prev );
}

Range::const_iterator moab::Range::upper_bound	(	Range::const_iterator	first,
		Range::const_iterator	last,
		EntityHandle	val
	)		`[static]`

Definition at line 832 of file Range.cpp.

References lower_bound().

Referenced by MetisPartitioner::assemble_taggedsets_graph(), moab::AxisBox::calculate(), moab::ParallelComm::check_my_shared_handles(), moab::OrientedBox::compute_from_vertices(), moab::Skinner::find_skin_vertices_3D(), moab::ReadHDF5::get_partition(), moab::ParallelComm::get_shared_entities(), moab::Core::get_vertices(), identify_set(), iMesh_createStructuredMesh(), mb_mesh_set_appends(), min_edge_length(), moab::ParallelComm::resolve_shared_ents(), and moab::ParallelMergeMesh::TagSharedElements().

{
    Range::const_iterator result = lower_bound( first, last, val );
    if( result != last && *result == val ) ++result;
    return result;
}

const_iterator moab::Range::upper_bound ( EntityHandle val ) const [inline]

Definition at line 310 of file Range.hpp.

    {
        return upper_bound( begin(), end(), val );
    }

Range::const_iterator moab::Range::upper_bound ( EntityType type ) const

Definition at line 852 of file Range.cpp.

References begin(), moab::CREATE_HANDLE(), end(), and lower_bound().

{
    // if (type+1) overflows, err will be true and we return end().
    int err;
    EntityHandle handle = CREATE_HANDLE( type + 1, 0, err );
    return err ? end() : lower_bound( begin(), end(), handle );
}

Range::const_iterator moab::Range::upper_bound	(	EntityType	type,
		const_iterator	first
	)		const

Definition at line 859 of file Range.cpp.

References moab::CREATE_HANDLE(), end(), and lower_bound().

{
    // if (type+1) overflows, err will be true and we return end().
    int err;
    EntityHandle handle = CREATE_HANDLE( type + 1, 0, err );
    return err ? end() : lower_bound( first, end(), handle );
}

Friends And Related Function Documentation

Range intersect	(	const Range &	range1,
		const Range &	range2
	)		`[friend]`

intersect two ranges, placing the results in the return range

Range subtract	(	const Range &	from,
		const Range &	range2
	)		`[friend]`

subtract range2 from this, placing the results in the return range

Member Data Documentation

PairNode moab::Range::mHead [protected]

the head of the list that contains pairs that represent the ranges this list is sorted and unique at all times

Definition at line 392 of file Range.hpp.

Referenced by back(), begin(), clear(), contains(), delete_pair_node(), empty(), end(), erase(), find(), front(), get_memory_use(), insert(), operator=(), pop_back(), pop_front(), Range(), rbegin(), rend(), sanity_check(), size(), and swap().

List of all members.

The documentation for this class was generated from the following files:

Classes

Public Types

Public Member Functions

Static Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation