ITK  5.0.0
Insight Segmentation and Registration Toolkit
Classes | Public Types | Public Member Functions | Private Attributes | Related Functions | List of all members
itk::VariableLengthVector< TValue > Class Template Reference
Data Representation Objects | Module ITKCommon

#include <itkConstantBoundaryCondition.h>

Detailed Description

template<typename TValue>
class itk::VariableLengthVector< TValue >

Represents an array whose length can be defined at run-time.

This class is templated over the data type. This data-type is meant to be a scalar, such as float, double etc...

Note
ITK itself provides several classes that can serve as Arrays.
  • FixedArray - Compile time fixed length arrays that's intended to represent an enumerated collection of n entities.
  • Array - Run time resizeable array that is intended to hold a collection of n entities
  • Vector - Compile time fixed length array that is intended to hold a collection of n data types. A vector usually has a mathematical meaning. It should only be used when mathematical operations such as addition, multiplication by a scalar, product etc make sense.
  • VariableLengthVector - Run time array that is intended to hold a collection of scalar data types. Again, it should be used only when mathematical operations on it are relevant. If not, use an Array.
  • Point - Represents the spatial coordinates of a spatial location. Operators on Point reflect geometrical concepts.
For the reasons listed above, you cannot instantiate
VariableLengthVector< bool >
.
Design Considerations: We do not derive from vnl_vector to avoid being limited by the explicit template instantiations of vnl_vector and other hacks that vnl folks have been forced to use.
Note
This work is part of the National Alliance for Medical Image Computing (NAMIC), funded by the National Institutes of Health through the NIH Roadmap for Medical Research, Grant U54 EB005149.
See Also
CovariantVector
SymmetricSecondRankTensor
RGBPixel
DiffusionTensor3D
Wiki Examples:
Invariant
If m_LetArrayManageMemory is true, m_Data is deletable (whether it's null or pointing to something with no elements. i.e. m_NumElements may be 0 and yet m_Data may be not null.)
Examples:
WikiExamples/ImageProcessing/UnaryFunctorImageFilter.cxx, WikiExamples/SimpleOperations/VariableLengthVector.cxx, WikiExamples/VectorImages/VectorImage.cxx, WikiExamples/VectorImages/VectorImageToImageAdaptor.cxx, and WikiExamples/VectorImages/VectorIndexSelectionCastImageFilter.cxx.

Definition at line 27 of file itkConstantBoundaryCondition.h.

Classes

struct  AllocateRootPolicy
 
struct  AlwaysReallocate
 
struct  DontShrinkToFit
 
struct  DumpOldValues
 
struct  KeepOldValues
 
struct  KeepValuesRootPolicy
 
struct  NeverReallocate
 
struct  ShrinkToFit
 

Public Types

using ComponentType = TValue
 
using ElementIdentifier = unsigned int
 
using RealValueType = typename NumericTraits< ValueType >::RealType
 
using Self = VariableLengthVector
 
using ValueType = TValue
 

Public Member Functions

TValue * AllocateElements (ElementIdentifier size) const
 
void DestroyExistingData ()
 
Self & FastAssign (const Self &v)
 
void Fill (TValue const &v)
 
const TValue * GetDataPointer () const
 
const TValue & GetElement (unsigned int i) const
 
RealValueType GetNorm () const
 
RealValueType GetSquaredNorm () const
 
bool IsAProxy () const
 
bool operator!= (const Self &v) const
 
Self & operator- ()
 
Self & operator= (Self &&v) noexcept
 
template<typename TExpr1 , typename TExpr2 , typename TBinaryOp >
Self & operator= (VariableLengthVectorExpression< TExpr1, TExpr2, TBinaryOp > const &rhs)
 
Self & operator= (const Self &v)
 
Self & operator= (TValue const &v)
 
bool operator== (const Self &v) const
 
TValue & operator[] (unsigned int i)
 
TValue const & operator[] (unsigned int i) const
 
void SetData (TValue *data, bool LetArrayManageMemory=false)
 
void SetData (TValue *data, unsigned int sz, bool LetArrayManageMemory=false)
 
void SetElement (unsigned int i, const TValue &value)
 
template<typename TReallocatePolicy , typename TKeepValuesPolicy >
void SetSize (unsigned int sz, TReallocatePolicy reallocatePolicy, TKeepValuesPolicy keepValues)
 
 VariableLengthVector ()
 
 VariableLengthVector (unsigned int dimension)
 
 VariableLengthVector (ValueType *data, unsigned int sz, bool LetArrayManageMemory=false)
 
 VariableLengthVector (const ValueType *data, unsigned int sz, bool LetArrayManageMemory=false)
 
 VariableLengthVector (const VariableLengthVector< TValue > &v)
 
 VariableLengthVector (Self &&v) noexcept
 
template<typename TExpr1 , typename TExpr2 , typename TBinaryOp >
 VariableLengthVector (VariableLengthVectorExpression< TExpr1, TExpr2, TBinaryOp > const &rhs)
 
 ~VariableLengthVector ()
 
template<typename T >
 VariableLengthVector (const VariableLengthVector< T > &v)
 
void Swap (Self &v) noexcept
 
template<typename T >
Self & operator= (const VariableLengthVector< T > &v)
 
unsigned int Size () const
 
unsigned int GetSize () const
 
unsigned int GetNumberOfElements () const
 
void SetSize (unsigned int sz, bool destroyExistingData=true)
 
void Reserve (ElementIdentifier size)
 
Self & operator-- ()
 
Self & operator++ ()
 
Self operator-- (int)
 
Self operator++ (int)
 
template<typename T >
Self & operator-= (const VariableLengthVector< T > &v)
 
Self & operator-= (TValue s)
 
template<typename T >
Self & operator+= (const VariableLengthVector< T > &v)
 
Self & operator+= (TValue s)
 
template<typename TExpr1 , typename TExpr2 , typename TBinaryOp >
Self & operator+= (VariableLengthVectorExpression< TExpr1, TExpr2, TBinaryOp > const &rhs)
 
template<typename TExpr1 , typename TExpr2 , typename TBinaryOp >
Self & operator-= (VariableLengthVectorExpression< TExpr1, TExpr2, TBinaryOp > const &rhs)
 
template<typename T >
Self & operator*= (T s)
 
Self & operator*= (TValue s)
 
template<typename T >
Self & operator/= (T s)
 

Private Attributes

TValue * m_Data
 
bool m_LetArrayManageMemory {true}
 
ElementIdentifier m_NumElements {0}
 

Related Functions

(Note that these are not member functions.)

template<typename TExpr1 , typename TExpr2 >
mpl::EnableIf
< Details::op::CanBeMultiplied
< TExpr1, TExpr2 >
, VariableLengthVectorExpression
< TExpr1, TExpr2,
Details::op::Mult > >::Type 		operator* (TExpr1 const &lhs, TExpr2 const &rhs)
 
template<typename TExpr1 , typename TExpr2 >
mpl::EnableIf
< Details::op::CanBeAddedOrSubtracted
< TExpr1, TExpr2 >
, VariableLengthVectorExpression
< TExpr1, TExpr2,
Details::op::Plus > >::Type 		operator+ (TExpr1 const &lhs, TExpr2 const &rhs)
 
template<typename TExpr1 , typename TExpr2 >
mpl::EnableIf
< Details::op::CanBeAddedOrSubtracted
< TExpr1, TExpr2 >
, VariableLengthVectorExpression
< TExpr1, TExpr2,
Details::op::Sub > >::Type 		operator- (TExpr1 const &lhs, TExpr2 const &rhs)
 
template<typename TExpr1 , typename TExpr2 >
mpl::EnableIf
< Details::op::CanBeDivided
< TExpr1, TExpr2 >
, VariableLengthVectorExpression
< TExpr1, TExpr2,
Details::op::Div > >::Type 		operator/ (TExpr1 const &lhs, TExpr2 const &rhs)
 
Serialization
template<typename TValue >
std::ostream & operator<< (std::ostream &os, const VariableLengthVector< TValue > &arr)
 
Standard compliance functions
template<typename T >
void swap (VariableLengthVector< T > &l_, VariableLengthVector< T > &r_) noexcept
 

Member Typedef Documentation

template<typename TValue>
using itk::VariableLengthVector< TValue >::ComponentType = TValue

Definition at line 310 of file itkVariableLengthVector.h.

template<typename TValue>
using itk::VariableLengthVector< TValue >::ElementIdentifier = unsigned int

Typedef used to indicate the number of elements in the vector

Definition at line 315 of file itkVariableLengthVector.h.

template<typename TValue>
using itk::VariableLengthVector< TValue >::RealValueType = typename NumericTraits< ValueType >::RealType

Definition at line 311 of file itkVariableLengthVector.h.

template<typename TValue>
using itk::VariableLengthVector< TValue >::Self = VariableLengthVector

Definition at line 312 of file itkVariableLengthVector.h.

template<typename TValue>
using itk::VariableLengthVector< TValue >::ValueType = TValue

The element type stored at each location in the Array.

Definition at line 309 of file itkVariableLengthVector.h.

Constructor & Destructor Documentation

template<typename TValue>
itk::VariableLengthVector< TValue >::VariableLengthVector ( )

Default constructor. It is created with an empty array it has to be allocated later by assignment, SetSize() or Reserve().

Postcondition
m_Data is null
m_NumElements is 0
m_LetArrayManageMemory is true
template<typename TValue>
itk::VariableLengthVector< TValue >::VariableLengthVector ( unsigned int  dimension)
explicit

Constructor with size. Size can only be changed by assignment, SetSize() or Reserve().

Postcondition
m_Data is not null and points to an array of m_NumElements, even if m_NumElements is 0
values are left uninitialized.
m_NumElements is dimension
m_LetArrayManageMemory is true
template<typename TValue>
itk::VariableLengthVector< TValue >::VariableLengthVector ( ValueType *  data,
unsigned int  sz,
bool  LetArrayManageMemory = false 
)

Constructor that initializes array with contents from a user supplied buffer. The pointer to the buffer and the length is specified. By default, the array does not manage the memory of the buffer. It merely points to that location and it is the user's responsibility to delete it. If LetArrayManageMemory is true, then this class will free the memory when this object is destroyed.

Postcondition
m_Data == data
values are left unmodified
m_NumElements == sz
m_LetArrayManageMemory == LetArrayManageMemory
template<typename TValue>
itk::VariableLengthVector< TValue >::VariableLengthVector ( const ValueType *  data,
unsigned int  sz,
bool  LetArrayManageMemory = false 
)

Constructor that initializes array with contents from a user supplied buffer. The pointer to the buffer and the length is specified. By default, the array does not manage the memory of the buffer. It merely points to that location and it is the user's responsibility to delete it. If LetArrayManageMemory is true, then this class will free the memory when this object is destroyed.

Warning
This overload receives a non-modiable array, and yet it will let the end-user try to modify it through VariableLengthVector interface. Use this constructor with care as this may lead to undefined behaviour. Prefer using VariableLengthVector<const TValue> instead of VariableLengthVector<TValue> in case we which to use this constructor.
Postcondition
m_Data == data
values are left unmodified
m_NumElements == sz
m_LetArrayManageMemory == LetArrayManageMemory
template<typename TValue>
template<typename T >
itk::VariableLengthVector< TValue >::VariableLengthVector ( const VariableLengthVector< T > &  v)
inline

Copy constructor. The reason why the copy constructor and the assignment operator are templated is that it will allow implicit casts to be performed. For instance:

VariableLengthVector< int > vI;
VariableLengthVector< float > vF( vI );
or for instance vF = static_cast< VariableLengthVector< float > >( vI );
Note
However that static casting in this way will imply the allocation of a temporary VariableLengthVector. Prefer to directly use the assignment converting operator in code where uses of static_cast<> would be required.
Postcondition
m_Data is not null and points to an array of m_NumElements, if m_NumElements is 0, otherwise it's null.
values are left uninitialized.
m_NumElements is v.GetSize()
m_LetArrayManageMemory is true

Definition at line 393 of file itkVariableLengthVector.h.

References itk::VariableLengthVector< TValue >::Size().

template<typename TValue>
itk::VariableLengthVector< TValue >::VariableLengthVector ( const VariableLengthVector< TValue > &  v)

Copy constructor. Overrides the default non-templated copy constructor that the compiler provides.

Postcondition
m_Data is not null and points to an array of m_NumElements, if m_NumElements is 0, otherwise it's null.
values are left uninitialized.
m_NumElements is v.GetSize()
m_LetArrayManageMemory is true
template<typename TValue>
itk::VariableLengthVector< TValue >::VariableLengthVector ( Self &&  v)
noexcept

C++11 Move Constructor.

Postcondition
v is destructible and assignable.
m_NumElements == 0
m_LetArrayManageMemory == true
m_Data == nullptr
Built object contains old v data.
template<typename TValue>
template<typename TExpr1 , typename TExpr2 , typename TBinaryOp >
itk::VariableLengthVector< TValue >::VariableLengthVector ( VariableLengthVectorExpression< TExpr1, TExpr2, TBinaryOp > const &  rhs)

Constructor from an Expression Template vector.

Template Parameters
TExpr1Type of the left sub-expression
TExpr2Type of the right sub-expression
TBinaryOpBinary Operation to apply to both sub-expressions.
Parameters
[in]rhsNon evaluated Expression Template.

Builds the new VariableLengthVector with an expression template. The code loops over all components from the template expression, and evaluates them on the fly to fill the content of the new vector.

Postcondition
m_Data is not null and points to an array of m_NumElements, even if m_NumElements is 0
*this == rhs
m_NumElements is rhs.GetSize()
m_LetArrayManageMemory is true
template<typename TValue>
itk::VariableLengthVector< TValue >::~VariableLengthVector ( )

This destructor is not virtual for performance reasons. However, this means that subclasses cannot allocate memory.

Member Function Documentation

template<typename TValue>
TValue* itk::VariableLengthVector< TValue >::AllocateElements ( ElementIdentifier  size) const

Allocate memory of certain size and return it.

Returns
a non-null pointer to an array of size elements (0 is a valid parameter).
template<typename TValue>
void itk::VariableLengthVector< TValue >::DestroyExistingData ( )

Destroy data that is allocated internally, if LetArrayManageMemory is true.

template<typename TValue>
Self& itk::VariableLengthVector< TValue >::FastAssign ( const Self &  v)

Fast Assignment.

Precondition
m_LetArrayManageMemory is true: the VariableLengthVector is not a proxy, checked with an assertion. Call SetSize(GetSize(), NeverReallocate(), DumpOldValues()) to ensure a vector is not a proxy anymore.
current size is identical to the one from the right hand side operand, checked with an assertion.
Doesn't not support empty vectors.
template<typename TValue>
void itk::VariableLengthVector< TValue >::Fill ( TValue const &  v)

Set the all the elements of the array to the specified value.

Precondition
This function may be called on empty vectors, it's a no-op.

Referenced by itk::MaskImageFilter< TInputImage, TMaskImage, TOutputImage >::CheckOutsideValue(), itk::LinearInterpolateImageFunction< TInputImage, TCoordRep >::MakeZeroInitializer(), itk::NumericTraits< VariableLengthVector< T > >::max(), itk::NumericTraits< VariableLengthVector< T > >::min(), itk::NumericTraits< VariableLengthVector< T > >::NonpositiveMin(), itk::NumericTraits< VariableLengthVector< T > >::OneValue(), itk::NumericTraits< VariableLengthVector< T > >::SetLength(), and itk::NumericTraits< VariableLengthVector< T > >::ZeroValue().

template<typename TValue>
const TValue* itk::VariableLengthVector< TValue >::GetDataPointer ( ) const
inline

Definition at line 724 of file itkVariableLengthVector.h.

Referenced by itk::MetaArrayWriter::SetInput().

template<typename TValue>
const TValue& itk::VariableLengthVector< TValue >::GetElement ( unsigned int  i) const
inline

Get one element

Definition at line 586 of file itkVariableLengthVector.h.

template<typename TValue>
RealValueType itk::VariableLengthVector< TValue >::GetNorm ( ) const

Returns vector's Euclidean Norm

Referenced by itk::DefaultConvertPixelTraits< VariableLengthVector< VComponent > >::GetScalarValue().

template<typename TValue>
unsigned int itk::VariableLengthVector< TValue >::GetNumberOfElements ( ) const
inline

Return the number of elements in the Array

Definition at line 576 of file itkVariableLengthVector.h.

template<typename TValue>
unsigned int itk::VariableLengthVector< TValue >::GetSize ( ) const
inline

Return the number of elements in the Array

Definition at line 575 of file itkVariableLengthVector.h.

Referenced by itk::MaskImageFilter< TInputImage, TMaskImage, TOutputImage >::CheckOutsideValue(), itk::NumericTraits< VariableLengthVector< T > >::GetLength(), itk::RecursiveSeparableImageFilter< TInputImage, TOutputImage >::MathEMAMAMAM(), and itk::RecursiveSeparableImageFilter< TInputImage, TOutputImage >::MathSMAMAMAM().

template<typename TValue>
RealValueType itk::VariableLengthVector< TValue >::GetSquaredNorm ( ) const

Returns vector's squared Euclidean Norm

template<typename TValue>
bool itk::VariableLengthVector< TValue >::IsAProxy ( ) const
inline

letArrayManageMemory getter.

Definition at line 943 of file itkVariableLengthVector.h.

template<typename TValue>
bool itk::VariableLengthVector< TValue >::operator!= ( const Self &  v) const
template<typename TValue>
template<typename T >
Self& itk::VariableLengthVector< TValue >::operator*= ( T  s)
inline

Multiply each element of the vector by a scalar 's'. The scalar value is cast to the current vector element type prior to multiplication.

Exceptions
None

Definition at line 882 of file itkVariableLengthVector.h.

template<typename TValue>
Self& itk::VariableLengthVector< TValue >::operator*= ( TValue  s)
inline

Multiply each element of the vector by a scalar 's'.

Exceptions
None

Definition at line 896 of file itkVariableLengthVector.h.

template<typename TValue>
Self& itk::VariableLengthVector< TValue >::operator++ ( )
inline

Prefix operator that adds 1 to each element of the vector.

Definition at line 739 of file itkVariableLengthVector.h.

template<typename TValue>
Self itk::VariableLengthVector< TValue >::operator++ ( int  )
inline

Postfix operator that adds 1 to each element of the vector.

Definition at line 761 of file itkVariableLengthVector.h.

template<typename TValue>
template<typename T >
Self& itk::VariableLengthVector< TValue >::operator+= ( const VariableLengthVector< T > &  v)
inline

Element-wise addition of vector 'v' to the current vector. The vectors do not have to have the same element type. The input vector elements are cast to the current vector element type before the addition is performed.

Exceptions
None
Note
For efficiency, the length of the vectors is not checked; they are assumed to have the same length.

Definition at line 812 of file itkVariableLengthVector.h.

template<typename TValue>
Self& itk::VariableLengthVector< TValue >::operator+= ( TValue  s)
inline

Add scalar 's' to each element of the vector.

Definition at line 824 of file itkVariableLengthVector.h.

template<typename TValue>
template<typename TExpr1 , typename TExpr2 , typename TBinaryOp >
Self& itk::VariableLengthVector< TValue >::operator+= ( VariableLengthVectorExpression< TExpr1, TExpr2, TBinaryOp > const &  rhs)
inline

Compound addition operator with a expression template vector.

Template Parameters
TExpr1Type of the left sub-expression
TExpr2Type of the right sub-expression
TBinaryOpBinary Operation to apply to both sub-expressions.
Parameters
[in]rhsNon evaluated Expression Template.
Precondition
Size() == rhs.Size(), checked with an assertion
Note
The elements of the expression template are evaluated one by one.

Definition at line 844 of file itkVariableLengthVector.h.

template<typename TValue>
Self& itk::VariableLengthVector< TValue >::operator- ( )

Negates each vector element.

Warning
This operator has a non standard semantics. Instead of returning a new VariableLengthVector, it modifies the current object.
template<typename TValue>
Self& itk::VariableLengthVector< TValue >::operator-- ( )
inline

Prefix operator that subtracts 1 from each element of the vector.

Definition at line 728 of file itkVariableLengthVector.h.

template<typename TValue>
Self itk::VariableLengthVector< TValue >::operator-- ( int  )
inline

Postfix operator that subtracts 1 from each element of the vector.

Definition at line 751 of file itkVariableLengthVector.h.

template<typename TValue>
template<typename T >
Self& itk::VariableLengthVector< TValue >::operator-= ( const VariableLengthVector< T > &  v)
inline

Element-wise subtraction of vector 'v' from the current vector. The vectors do not have to have the same element type. The input vector elements are cast to the current vector element type before the subtraction is performed.

Exceptions
None
Note
For efficiency, the length of the vectors is not checked; they are assumed to have the same length.

Definition at line 780 of file itkVariableLengthVector.h.

template<typename TValue>
Self& itk::VariableLengthVector< TValue >::operator-= ( TValue  s)
inline

Subtract scalar 's' from each element of the current vector.

Definition at line 792 of file itkVariableLengthVector.h.

template<typename TValue>
template<typename TExpr1 , typename TExpr2 , typename TBinaryOp >
Self& itk::VariableLengthVector< TValue >::operator-= ( VariableLengthVectorExpression< TExpr1, TExpr2, TBinaryOp > const &  rhs)
inline

Compound subtraction operator with a expression template vector.

Template Parameters
TExpr1Type of the left sub-expression
TExpr2Type of the right sub-expression
TBinaryOpBinary Operation to apply to both sub-expressions.
Parameters
[in]rhsNon evaluated Expression Template.
Precondition
Size() == rhs.Size(), checked with an assertion
Note
The elements of the expression template are evaluated one by one.

Definition at line 865 of file itkVariableLengthVector.h.

template<typename TValue>
template<typename T >
Self& itk::VariableLengthVector< TValue >::operator/= ( T  s)
inline

Divide vector elements by a scalar 's'. The vector does not have to have the same element type as the scalar type. Both the scalar and vector elements are cast to the RealValueType prior to division, and the result is cast to the ValueType.

Exceptions
None

Definition at line 913 of file itkVariableLengthVector.h.

template<typename TValue>
Self& itk::VariableLengthVector< TValue >::operator= ( Self &&  v)
noexcept

C++11 Move assignement operator.

Precondition
v shall not be the same as the current object
Postcondition
v is destructible and assignable.
m_NumElements == 0
m_LetArrayManageMemory == true
m_Data == nullptr
Current object contains old v data.
template<typename TValue>
template<typename TExpr1 , typename TExpr2 , typename TBinaryOp >
Self& itk::VariableLengthVector< TValue >::operator= ( VariableLengthVectorExpression< TExpr1, TExpr2, TBinaryOp > const &  rhs)

Assignment from an Expression Template vector.

Template Parameters
TExpr1Type of the left sub-expression
TExpr2Type of the right sub-expression
TBinaryOpBinary Operation to apply to both sub-expressions.
Parameters
[in]rhsNon evaluated Expression Template.

Resets the new VariableLengthVector with an expression template. The code loops over all components from the template expression, and evaluates them on the fly to fill the content of the current vector.

Postcondition
if called on a VariableLengthVector proxy, the referenced values are left unchanged.
m_Data is not null and points to an array of m_NumElements, if m_NumElements is not 0. m_Data may be null otherwise (an empty vector is assigned into another empty vector)
m_LetArrayManageMemory is true
GetSize() == rhs.GetSize()
*this == rhs
template<typename TValue>
template<typename T >
Self& itk::VariableLengthVector< TValue >::operator= ( const VariableLengthVector< T > &  v)
inline

Converting assignment operator.

Note
Ensures a String Exception Guarantee: resists to self-assignment, and no changes are made if memory cannot be allocated to hold the new elements. This presumes TValue assignment is a noexcept operation.
Postcondition
if called on a VariableLengthVector proxy, the referenced values are left unchanged.
m_LetArrayManageMemory is true
GetSize() == v.GetSize(), modulo precision
*this == v

Definition at line 518 of file itkVariableLengthVector.h.

References itk::VariableLengthVector< TValue >::Size().

template<typename TValue>
Self& itk::VariableLengthVector< TValue >::operator= ( const Self &  v)

Copy-Assignment operator.

Note
Ensures a String Exception Guarantee: resists to self-assignment, and no changes are made if memory cannot be allocated to hold the new elements. This is expecting TValue assignment is a noexcept operation.
Postcondition
if called on a VariableLengthVector proxy, the referenced values are left unchanged.
m_Data is not null and points to an array of m_NumElements, if m_NumElements is not 0. m_Data may be null otherwise (an empty vector is assigned into another empty vector)
m_LetArrayManageMemory is true
GetSize() == v.GetSize()
*this == v
template<typename TValue>
Self& itk::VariableLengthVector< TValue >::operator= ( TValue const &  v)

Assignment operator from a numeric value.

Precondition
This assumes m_LetArrayManageMemory is true, but it is unchecked. If this operator is called on a VariableLengthVector proxy, referenced values will be overwritten.
Postcondition
Elements in [m_Data, m_Data+GetSize()) will be equal to v, modulo precision
template<typename TValue>
bool itk::VariableLengthVector< TValue >::operator== ( const Self &  v) const
template<typename TValue>
TValue& itk::VariableLengthVector< TValue >::operator[] ( unsigned int  i)
inline

Return reference to the element at specified index. No range checking.

Definition at line 580 of file itkVariableLengthVector.h.

template<typename TValue>
TValue const& itk::VariableLengthVector< TValue >::operator[] ( unsigned int  i) const
inline

Return reference to the element at specified index. No range checking.

Definition at line 583 of file itkVariableLengthVector.h.

template<typename TValue>
void itk::VariableLengthVector< TValue >::Reserve ( ElementIdentifier  size)

Reserves memory of a certain length. 

If the array already contains data, the existing data is copied over and
new space is allocated, if necessary. If the length to reserve is less
than the current number of elements, then an appropriate number of elements
are discarded.
\post \c m_Data is not null and can hold \c size elements.
\post \c m_LetArrayManageMemory may be left unchanged if there already are
enough elements.

\note You may prefer instead
`SetSize(N, DontShrinkToFit(), KeepOldValues());` that ensures that the
array is not a proxy at the end of the operation.
template<typename TValue>
void itk::VariableLengthVector< TValue >::SetData ( TValue *  data,
bool  LetArrayManageMemory = false 
)

Set the pointer from which the data is imported. If "LetArrayManageMemory" is false, then the application retains the responsibility of freeing the memory for this data. If "LetArrayManageMemory" is true, then this class will free the memory when this object is destroyed.

Warning
The size of the new data shall match vector current size. Prefer the other overload.
Postcondition
old m_Data is deleted iff m_LetArrayManageMemory is true
m_Data == data
m_LetArrayManageMemory ==LetArrayManageMemory
Size() is left unmodified.

Referenced by itk::MetaArrayReader::GetOutput().

template<typename TValue>
void itk::VariableLengthVector< TValue >::SetData ( TValue *  data,
unsigned int  sz,
bool  LetArrayManageMemory = false 
)

Similar to the previous method. In the above method, the size must be separately set prior to using user-supplied data. This introduces an unnecessary allocation step to be performed. This method avoids it and should be used to import data wherever possible to avoid this. Set the pointer from which the data is imported. If "LetArrayManageMemory" is false, then the application retains the responsibility of freeing the memory for this data. If "LetArrayManageMemory" is true, then this class will free the memory when this object is destroyed.

Postcondition
old m_Data is deleted iff m_LetArrayManageMemory is true
m_Data == data
m_LetArrayManageMemory ==LetArrayManageMemory
m_NumElements == sz
template<typename TValue>
void itk::VariableLengthVector< TValue >::SetElement ( unsigned int  i,
const TValue &  value 
)
inline

Set one element

Definition at line 589 of file itkVariableLengthVector.h.

template<typename TValue>
template<typename TReallocatePolicy , typename TKeepValuesPolicy >
void itk::VariableLengthVector< TValue >::SetSize ( unsigned int  sz,
TReallocatePolicy  reallocatePolicy,
TKeepValuesPolicy  keepValues 
)

Resizes the vector.

Template Parameters
TReallocatePolicyPolicy that determines precisely the conditions under which the internal buffer shall be reallocated. It shall inherit from AllocateRootPolicy.
TKeepValuesPolicyPolicy that determines whether old elements shall be kept. It shall inherit from KeepValuesRootPolicy.
Examples:
WikiExamples/SimpleOperations/VariableLengthVector.cxx, WikiExamples/VectorImages/VectorImage.cxx, WikiExamples/VectorImages/VectorImageToImageAdaptor.cxx, and WikiExamples/VectorImages/VectorIndexSelectionCastImageFilter.cxx.

Referenced by itk::LinearInterpolateImageFunction< TInputImage, TCoordRep >::MakeZeroInitializer(), itk::RecursiveSeparableImageFilter< TInputImage, TOutputImage >::MathEMAMAMAM(), itk::RecursiveSeparableImageFilter< TInputImage, TOutputImage >::MathSMAMAMAM(), and itk::NumericTraits< VariableLengthVector< T > >::SetLength().

template<typename TValue>
void itk::VariableLengthVector< TValue >::SetSize ( unsigned int  sz,
bool  destroyExistingData = true 
)
inline

Set the size to that given. 

If \c destroyExistingData is \c false:
If the array already contains data, the existing data is copied over and
new space is allocated, if necessary. If the length to reserve is less
than the current number of elements, then an appropriate number of elements
are discarded.
   If \c true, the size is set destructively to the length given. If the
length is different from the current length, existing data will be lost.
The default is \c true.

Definition at line 639 of file itkVariableLengthVector.h.

template<typename TValue>
unsigned int itk::VariableLengthVector< TValue >::Size ( ) const
inline

Return the number of elements in the Array

Definition at line 574 of file itkVariableLengthVector.h.

Referenced by itk::Statistics::MeasurementVectorTraits::Assert(), itk::DefaultConvertPixelTraits< VariableLengthVector< VComponent > >::GetNumberOfComponents(), itk::NumericTraits< VariableLengthVector< T > >::max(), itk::NumericTraits< VariableLengthVector< T > >::min(), itk::NumericTraits< VariableLengthVector< T > >::NonpositiveMin(), itk::NumericTraits< VariableLengthVector< T > >::OneValue(), itk::VariableLengthVector< TValue >::operator=(), itk::MetaArrayWriter::SetInput(), itk::MeshIOBase::SetPixelType(), itk::VariableLengthVector< TValue >::VariableLengthVector(), and itk::NumericTraits< VariableLengthVector< T > >::ZeroValue().

template<typename TValue>
void itk::VariableLengthVector< TValue >::Swap ( Self &  v)
inlinenoexcept

Swaps two VariableLengthVector 's.

Precondition
Expects either none of the VariableLengthVector to act as a proxy, or both, checked with an assertion.
Postcondition
*this and old contents are swapped.
Parameters
[in,out]vother VariableLengthVector to be swapped with.
Exceptions
None
See Also
itk::swap()

Definition at line 431 of file itkVariableLengthVector.h.

References itk::swap().

Friends And Related Function Documentation

template<typename TExpr1 , typename TExpr2 >
mpl::EnableIf< Details::op::CanBeMultiplied< TExpr1, TExpr2 >, VariableLengthVectorExpression< TExpr1, TExpr2, Details::op::Mult > >::Type operator* ( TExpr1 const &  lhs,
TExpr2 const &  rhs 
)
related

Multiplication between a VariableLengthVector and a scalar. This operation is generic and takes one array and one number (on either side).

Returns
an expression template proxy object.
Exceptions
NoneAs no allocation will be performed.
See Also
mpl::IsArray<> to know the exact array types recognized as array by this traits

Definition at line 1253 of file itkVariableLengthVector.h.

template<typename TExpr1 , typename TExpr2 >
mpl::EnableIf< Details::op::CanBeAddedOrSubtracted< TExpr1, TExpr2 >, VariableLengthVectorExpression< TExpr1, TExpr2, Details::op::Plus > >::Type operator+ ( TExpr1 const &  lhs,
TExpr2 const &  rhs 
)
related

Addition involving a VariableLengthVector. This operation is generic and takes:

  • two arrays,
  • or one array and one number (on either side)
    Returns
    an expression template proxy object.
    Exceptions
    NoneAs no allocation will be performed.
    See Also
    mpl::IsArray<> to know the exact array types recognized as array by this traits

Definition at line 1224 of file itkVariableLengthVector.h.

template<typename TExpr1 , typename TExpr2 >
mpl::EnableIf< Details::op::CanBeAddedOrSubtracted< TExpr1, TExpr2 >, VariableLengthVectorExpression< TExpr1, TExpr2, Details::op::Sub > >::Type operator- ( TExpr1 const &  lhs,
TExpr2 const &  rhs 
)
related

Subtraction involving a VariableLengthVector. This operation is generic and takes:

  • two arrays,
  • or one array and one number (on either side)
    Returns
    an expression template proxy object.
    Exceptions
    NoneAs no allocation will be performed.
    See Also
    mpl::IsArray<> to know the exact array types recognized as array by this traits

Definition at line 1239 of file itkVariableLengthVector.h.

template<typename TExpr1 , typename TExpr2 >
mpl::EnableIf< Details::op::CanBeDivided< TExpr1, TExpr2 >, VariableLengthVectorExpression< TExpr1, TExpr2, Details::op::Div > >::Type operator/ ( TExpr1 const &  lhs,
TExpr2 const &  rhs 
)
related

Division of a VariableLengthVector by a scalar. This operation is generic and takes one array and one number.

Returns
an expression template proxy object.
Exceptions
NoneAs no allocation will be performed.
See Also
mpl::IsArray<> to know the exact array types recognized as array by this traits

Definition at line 1266 of file itkVariableLengthVector.h.

template<typename TValue >
std::ostream & operator<< ( std::ostream &  os,
const VariableLengthVector< TValue > &  arr 
)
related

Serialization of VariableLengthVector

Definition at line 1330 of file itkVariableLengthVector.h.

template<typename T >
void swap ( VariableLengthVector< T > &  l_,
VariableLengthVector< T > &  r_ 
)
related

swap() overload for VariableLengthVector

Exceptions
None

Definition at line 1372 of file itkVariableLengthVector.h.

Member Data Documentation

template<typename TValue>
TValue* itk::VariableLengthVector< TValue >::m_Data
private

Definition at line 948 of file itkVariableLengthVector.h.

template<typename TValue>
bool itk::VariableLengthVector< TValue >::m_LetArrayManageMemory {true}
private

Definition at line 946 of file itkVariableLengthVector.h.

template<typename TValue>
ElementIdentifier itk::VariableLengthVector< TValue >::m_NumElements {0}
private

Definition at line 949 of file itkVariableLengthVector.h.

The documentation for this class was generated from the following files:
Tarballs of the nightly generated Doxygen documentation are available for the html, xml, and tag file.
Generated on Sun Mar 24 2019 04:12:10 for ITK by   doxygen 1.8.5