AXOM
Axom provides a robust, flexible software infrastructure for the development of multi-physics applications and computational tools.
axom::slam::GenericRangeSet< P, E, StridingPolicy, IndirectionPolicy, SubsettingPolicy > Class Template Reference

Models a set whose elements belong to a contiguous range \( \in [lowerIndex,upperIndex) \). More...

#include </home/docs/checkouts/readthedocs.org/user_builds/axom/checkouts/v0.5.0/src/axom/slam/RangeSet.hpp>

Inheritance diagram for axom::slam::GenericRangeSet< P, E, StridingPolicy, IndirectionPolicy, SubsettingPolicy >:

Public Types

using PositionType = P
 
using ElementType = E
 
using SizePolicyType = policies::RuntimeSize< P >
 
using OffsetPolicyType = policies::RuntimeOffset< P >
 
using StridePolicyType = StridingPolicy
 
using IndirectionPolicyType = IndirectionPolicy
 
using SubsettingPolicyType = SubsettingPolicy
 
using ModularIntType = ModularInt< policies::RuntimeSize< P > >
 
using PositionSet = OrderedSet< PositionType >
 
using const_iterator = OrderedSetIterator< ElementType, true >
 
using const_iterator_pair = std::pair< const_iterator, const_iterator >
 
using iterator = OrderedSetIterator< ElementType, false >
 
using iterator_pair = std::pair< iterator, iterator >
 

Public Member Functions

 GenericRangeSet (PositionType size=OrderedSetType::SizePolicyType::DEFAULT_VALUE)
 
 GenericRangeSet (const typename OrderedSetType::SetBuilder &builder)
 
 GenericRangeSet (PositionType lowerIndex, PositionType upperIndex)
 
iterator begin ()
 
const_iterator begin () const
 
iterator end ()
 
const_iterator end () const
 
iterator_pair range ()
 
const_iterator_pair range () const
 
IndirectionPolicy::ConstIndirectionResult operator[] (PositionType pos) const
 Given a position in the Set, return a position in the larger index space. More...
 
IndirectionPolicy::IndirectionResult operator[] (PositionType pos)
 
ElementType at (PositionType pos) const
 Random access to the entities of the set. More...
 
PositionType size () const
 Get the number of entities in the set. More...
 
P & size ()
 
bool empty () const
 Checks if there are any elements in the set – equivalent to: set.size() == 0. More...
 
bool isValid (bool verboseOutput=false) const
 Checks whether the set is valid. More...
 
bool isSubset () const
 Determines if the Set is a Subset of another set. More...
 
bool isValidIndex (PositionType pos) const
 checks whether the given position (index) is valid. More...
 
PositionSet positions () const
 returns a PositionSet over the set's positions More...
 
operator() () const
 
P & operator() ()
 
operator() () const
 
P & operator() ()
 
offset () const
 
P & offset ()
 

Static Public Attributes

OrderedSet_Size_Policies

A few default policies for the size of an OrderedSet

static const P DEFAULT_VALUE
 
OrderedSet_Offset_Policies

A few default policies for the offset of an OrderedSet

static const P DEFAULT_VALUE
 

Protected Attributes

m_sz
 

Detailed Description

template<typename P = slam::DefaultPositionType, typename E = slam::DefaultElementType, typename StridingPolicy = policies::StrideOne<P>, typename IndirectionPolicy = policies::NoIndirection<P, E>, typename SubsettingPolicy = policies::NoSubset>
class axom::slam::GenericRangeSet< P, E, StridingPolicy, IndirectionPolicy, SubsettingPolicy >

Models a set whose elements belong to a contiguous range \( \in [lowerIndex,upperIndex) \).

Note
The ElementType here needs to be computable as offsets (of PositionType) from the lowerIndex. Examples include: signed and unsigned integral types. This version of a range set still allows you to have different policies on striding, indirection and subsetting
See also
OrderedSet, PositionSet, RangeSet

Member Typedef Documentation

◆ PositionType

template<typename P = slam::DefaultPositionType, typename E = slam::DefaultElementType, typename StridingPolicy = policies::StrideOne<P>, typename IndirectionPolicy = policies::NoIndirection<P, E>, typename SubsettingPolicy = policies::NoSubset>
using axom::slam::GenericRangeSet< P, E, StridingPolicy, IndirectionPolicy, SubsettingPolicy >::PositionType = P

◆ ElementType

template<typename P = slam::DefaultPositionType, typename E = slam::DefaultElementType, typename StridingPolicy = policies::StrideOne<P>, typename IndirectionPolicy = policies::NoIndirection<P, E>, typename SubsettingPolicy = policies::NoSubset>
using axom::slam::GenericRangeSet< P, E, StridingPolicy, IndirectionPolicy, SubsettingPolicy >::ElementType = E

◆ SizePolicyType

using axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::SizePolicyType = policies::RuntimeSize< P >
inherited

◆ OffsetPolicyType

using axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::OffsetPolicyType = policies::RuntimeOffset< P >
inherited

◆ StridePolicyType

using axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::StridePolicyType = StridingPolicy
inherited

◆ IndirectionPolicyType

using axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::IndirectionPolicyType = IndirectionPolicy
inherited

◆ SubsettingPolicyType

using axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::SubsettingPolicyType = SubsettingPolicy
inherited

◆ ModularIntType

using axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::ModularIntType = ModularInt<policies::RuntimeSize< P > >
inherited

◆ PositionSet

using axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::PositionSet = OrderedSet<PositionType>
inherited

◆ const_iterator

using axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::const_iterator = OrderedSetIterator<ElementType, true>
inherited

◆ const_iterator_pair

using axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::const_iterator_pair = std::pair<const_iterator, const_iterator>
inherited

◆ iterator

using axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::iterator = OrderedSetIterator<ElementType, false>
inherited

◆ iterator_pair

using axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::iterator_pair = std::pair<iterator, iterator>
inherited

Constructor & Destructor Documentation

◆ GenericRangeSet() [1/3]

template<typename P = slam::DefaultPositionType, typename E = slam::DefaultElementType, typename StridingPolicy = policies::StrideOne<P>, typename IndirectionPolicy = policies::NoIndirection<P, E>, typename SubsettingPolicy = policies::NoSubset>
axom::slam::GenericRangeSet< P, E, StridingPolicy, IndirectionPolicy, SubsettingPolicy >::GenericRangeSet ( PositionType  size = OrderedSetType::SizePolicyType::DEFAULT_VALUE)
inline

◆ GenericRangeSet() [2/3]

template<typename P = slam::DefaultPositionType, typename E = slam::DefaultElementType, typename StridingPolicy = policies::StrideOne<P>, typename IndirectionPolicy = policies::NoIndirection<P, E>, typename SubsettingPolicy = policies::NoSubset>
axom::slam::GenericRangeSet< P, E, StridingPolicy, IndirectionPolicy, SubsettingPolicy >::GenericRangeSet ( const typename OrderedSetType::SetBuilder &  builder)
inline

◆ GenericRangeSet() [3/3]

template<typename P = slam::DefaultPositionType, typename E = slam::DefaultElementType, typename StridingPolicy = policies::StrideOne<P>, typename IndirectionPolicy = policies::NoIndirection<P, E>, typename SubsettingPolicy = policies::NoSubset>
axom::slam::GenericRangeSet< P, E, StridingPolicy, IndirectionPolicy, SubsettingPolicy >::GenericRangeSet ( PositionType  lowerIndex,
PositionType  upperIndex 
)
inline

Member Function Documentation

◆ begin() [1/2]

iterator axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::begin ( )
inlineinherited

◆ begin() [2/2]

const_iterator axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::begin ( ) const
inlineinherited

◆ end() [1/2]

iterator axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::end ( )
inlineinherited

◆ end() [2/2]

const_iterator axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::end ( ) const
inlineinherited

◆ range() [1/2]

iterator_pair axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::range ( )
inlineinherited

◆ range() [2/2]

const_iterator_pair axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::range ( ) const
inlineinherited

◆ operator[]() [1/2]

IndirectionPolicy::ConstIndirectionResult axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::operator[] ( PositionType  pos) const
inlineinherited

Given a position in the Set, return a position in the larger index space.

◆ operator[]() [2/2]

IndirectionPolicy::IndirectionResult axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::operator[] ( PositionType  pos)
inlineinherited

◆ at()

ElementType axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::at ( PositionType  pos) const
inlinevirtualinherited

Random access to the entities of the set.

Parameters
Theindex of the desired element
Returns
The value of the element at the given position
Precondition
The position must be less than the number of elements in the set ( size() )
Note
Concrete realizations of Set also support subscript operator – operator[].
How are we planning to handle indexes that are out or range (accidentally)? Are we planning to handle indexes that are intentionally out of range (e.g. to indicate a problem, or a missing element etc..)?

Implements axom::slam::Set< P, E >.

◆ size() [1/2]

PositionType axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::size ( ) const
inlinevirtualinherited

Get the number of entities in the set.

Returns
The number of entities in the set.

Implements axom::slam::Set< P, E >.

◆ size() [2/2]

P & axom::slam::policies::RuntimeSize< P >::size ( )
inlineinherited

◆ empty()

bool axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::empty ( ) const
inlinevirtualinherited

Checks if there are any elements in the set – equivalent to: set.size() == 0.

Implements axom::slam::Set< P, E >.

◆ isValid()

bool axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::isValid ( bool  verboseOutput = false) const
virtualinherited

Checks whether the set is valid.

Returns
true if the underlying indices are valid, false otherwise.

Implements axom::slam::Set< P, E >.

◆ isSubset()

bool axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::isSubset ( ) const
inlinevirtualinherited

Determines if the Set is a Subset of another set.

Returns
true if the set is a subset of another set, otherwise false.

Implements axom::slam::Set< P, E >.

◆ isValidIndex()

bool axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::isValidIndex ( PositionType  pos) const
inlineinherited

checks whether the given position (index) is valid.

An index pos is valid when \( 0 \le pos < size() \)

Returns
true if the position is valid, false otherwise

◆ positions()

PositionSet axom::slam::OrderedSet< P , E , policies::RuntimeSize< P > , policies::RuntimeOffset< P > , StridingPolicy , IndirectionPolicy, SubsettingPolicy >::positions ( ) const
inlineinherited

returns a PositionSet over the set's positions

This can be used to simplify code to loop through the elements of a set.

◆ operator()() [1/4]

P axom::slam::policies::RuntimeSize< P >::operator() ( ) const
inlineinherited

◆ operator()() [2/4]

P & axom::slam::policies::RuntimeSize< P >::operator() ( )
inlineinherited

◆ operator()() [3/4]

P axom::slam::policies::RuntimeOffset< P >::operator() ( ) const
inlineinherited

◆ operator()() [4/4]

P & axom::slam::policies::RuntimeOffset< P >::operator() ( )
inlineinherited

◆ offset() [1/2]

P axom::slam::policies::RuntimeOffset< P >::offset ( ) const
inlineinherited

◆ offset() [2/2]

P & axom::slam::policies::RuntimeOffset< P >::offset ( )
inlineinherited

Member Data Documentation

◆ DEFAULT_VALUE [1/2]

const P axom::slam::policies::RuntimeSize< P >::DEFAULT_VALUE
staticinherited

◆ DEFAULT_VALUE [2/2]

const P axom::slam::policies::RuntimeOffset< P >::DEFAULT_VALUE
staticinherited

◆ m_sz

P axom::slam::policies::RuntimeSize< P >::m_sz
protectedinherited

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