itkVariableLengthVector.h

Go to the documentation of this file.

/*=========================================================================
 *
 *  Copyright Insight Software Consortium
 *
 *  Licensed under the Apache License, Version 2.0 (the "License");
 *  you may not use this file except in compliance with the License.
 *  You may obtain a copy of the License at
 *
 *         http://www.apache.org/licenses/LICENSE-2.0.txt
 *
 *  Unless required by applicable law or agreed to in writing, software
 *  distributed under the License is distributed on an "AS IS" BASIS,
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *  See the License for the specific language governing permissions and
 *  limitations under the License.
 *
 *=========================================================================*/
#ifndef __itkVariableLengthVector_h
#define __itkVariableLengthVector_h

#include "itkNumericTraits.h"

namespace itk
{
template< typename TValueType >
class VariableLengthVector
{
public:

  typedef TValueType                                    ValueType;
  typedef TValueType                                    ComponentType;
  typedef typename NumericTraits< ValueType >::RealType RealValueType;
  typedef VariableLengthVector                          Self;

  typedef unsigned int ElementIdentifier;

  VariableLengthVector();

  VariableLengthVector(unsigned int dimension);

  VariableLengthVector(ValueType *data, unsigned int sz,
                       bool LetArrayManageMemory = false);

  VariableLengthVector(const ValueType *data, unsigned int sz,
                       bool LetArrayManageMemory = false);

  template< class T >
  VariableLengthVector(const VariableLengthVector< T > & v)
  {
    m_NumElements = v.Size();
    m_Data = this->AllocateElements(m_NumElements);
    m_LetArrayManageMemory = true;
    for ( ElementIdentifier i = 0; i < v.Size(); i++ )
      {
      this->m_Data[i] = static_cast< ValueType >( v[i] );
      }
  }

  VariableLengthVector(const VariableLengthVector< TValueType > & v);

  void Fill(TValueType const & v);

  template< class T >
  const VariableLengthVector< TValueType > & operator=
    (const VariableLengthVector< T > & v)
  {
    if ( m_Data == static_cast< void * >( const_cast< T * >
                                          ( ( const_cast< VariableLengthVector< T > & >( v ) ).GetDataPointer() ) ) )
      {
      return *this;
      }
    this->SetSize( v.Size() );
    for ( ElementIdentifier i = 0; i < v.Size(); i++ )
      {
      this->m_Data[i] = static_cast< ValueType >( v[i] );
      }
    return *this;
  }

  const Self & operator=(const Self & v);

  const Self & operator=(TValueType const & v);

  inline unsigned int Size(void) const { return m_NumElements; }
  inline unsigned int GetNumberOfElements(void) const { return m_NumElements; }

  TValueType       & operator[](unsigned int i) { return this->m_Data[i]; }

  TValueType const & operator[](unsigned int i) const { return this->m_Data[i]; }

  inline const TValueType & GetElement(unsigned int i) const { return m_Data[i]; }

  void SetElement(unsigned int i, const TValueType & value) { m_Data[i] = value; }

  void SetSize(unsigned int sz, bool destroyExistingData = true);

  void DestroyExistingData();

  inline unsigned int GetSize(void) const { return m_NumElements; }

  void SetData(TValueType *data, bool LetArrayManageMemory = false);

  void SetData(TValueType *data, unsigned int sz, bool LetArrayManageMemory = false);

  ~VariableLengthVector();

  void Reserve(ElementIdentifier);

  TValueType * AllocateElements(ElementIdentifier size) const;

  const TValueType * GetDataPointer() const { return m_Data; }

  template< class T >
  inline Self operator+(const VariableLengthVector< T > & v) const
  {
    // if( m_NumElements != v.GetSize() )
    //   {
    //   itkGenericExceptionMacro( << "Cannot add VariableLengthVector of length
    // "
    //                             << m_NumElements " and " << v.GetSize() );
    //   }
    const ElementIdentifier length = v.Size();
    Self                    result(length);

    for ( ElementIdentifier i = 0; i < length; i++ )
      {
      result[i] = ( *this )[i] + static_cast< ValueType >( v[i] );
      }
    return result;
  }

  template< class T >
  inline Self operator-(const VariableLengthVector< T > & v) const
  {
    // if( m_NumElements != v.GetSize() )
    //   {
    //   itkGenericExceptionMacro( << "Cannot add VariableLengthVector of length
    // "
    //                             << m_NumElements " and " << v.GetSize() );
    //   }
    const ElementIdentifier length = v.Size();
    Self                    result(length);

    for ( ElementIdentifier i = 0; i < length; i++ )
      {
      result[i] = ( *this )[i] - static_cast< ValueType >( v[i] );
      }
    return result;
  }

  template< class T >
  inline Self operator*(T s) const
  {
    Self result(m_NumElements);

    for ( ElementIdentifier i = 0; i < m_NumElements; i++ )
      {
      result[i] = m_Data[i] * static_cast< ValueType >( s );
      }
    return result;
  }

  template< class T >
  inline Self operator/(T s) const
  {
    Self result(m_NumElements);

    for ( ElementIdentifier i = 0; i < m_NumElements; i++ )
      {
      result[i] = static_cast< ValueType >(
        static_cast< RealValueType >( m_Data[i] )
        / static_cast< RealValueType >( s ) );
      }
    return result;
  }

  inline Self operator+(TValueType s) const
  {
    Self result(m_NumElements);

    for ( ElementIdentifier i = 0; i < m_NumElements; i++ )
      {
      result[i] = m_Data[i] + s;
      }
    return result;
  }

  inline Self operator-(TValueType s) const
  {
    Self result(m_NumElements);

    for ( ElementIdentifier i = 0; i < m_NumElements; i++ )
      {
      result[i] = m_Data[i] - s;
      }
    return result;
  }

  inline Self & operator--()
  {
    for ( ElementIdentifier i = 0; i < m_NumElements; i++ )
      {
      this->m_Data[i] -= static_cast< ValueType >( 1.0 );
      }
    return *this;
  }

  inline Self & operator++() // prefix operator ++v;
  {
    for ( ElementIdentifier i = 0; i < m_NumElements; i++ )
      {
      this->m_Data[i] += static_cast< ValueType >( 1.0 );
      }
    return *this;
  }

  inline Self operator--(int) // postfix operator v--;
  {
    Self tmp(*this);

    --tmp;
    return tmp;
  }

  inline Self operator++(int) // postfix operator v++;
  {
    Self tmp(*this);

    ++tmp;
    return tmp;
  }

  template< class T >
  inline Self & operator-=
    (const VariableLengthVector< T > & v)
  {
    for ( ElementIdentifier i = 0; i < m_NumElements; i++ )
      {
      m_Data[i] -= static_cast< ValueType >( v[i] );
      }
    return *this;
  }

  inline Self & operator-=(TValueType s)
  {
    for ( ElementIdentifier i = 0; i < m_NumElements; i++ )
      {
      m_Data[i] -= s;
      }
    return *this;
  }

  template< class T >
  inline Self & operator+=
    (const VariableLengthVector< T > & v)
  {
    for ( ElementIdentifier i = 0; i < m_NumElements; i++ )
      {
      m_Data[i] += static_cast< ValueType >( v[i] );
      }
    return *this;
  }

  inline Self & operator+=(TValueType s)
  {
    for ( ElementIdentifier i = 0; i < m_NumElements; i++ )
      {
      m_Data[i] += s;
      }
    return *this;
  }

  template< class T >
  inline Self & operator*=(T s)
  {
    for ( ElementIdentifier i = 0; i < m_NumElements; i++ )
      {
      m_Data[i] *= ( static_cast< ValueType >( s ) );
      }
    return *this;
  }

  template< class T >
  inline Self & operator/=(T s)
  {
    for ( ElementIdentifier i = 0; i < m_NumElements; i++ )
      {
      m_Data[i] = static_cast< ValueType >(
        static_cast< RealValueType >( m_Data[i] )
        / static_cast< RealValueType >( s ) );
      }
    return *this;
  }

  Self & operator-();  // negation operator

  bool operator==(const Self & v) const;

  bool operator!=(const Self & v) const;

  RealValueType GetNorm() const;

  RealValueType GetSquaredNorm() const;

private:

  bool              m_LetArrayManageMemory; // if true, the array is responsible
                                            // for memory of data
  TValueType *      m_Data;                 // Array to hold data
  ElementIdentifier m_NumElements;
};

template< class TValueType, class T >
inline
VariableLengthVector< TValueType >
operator*(const T & scalar, const VariableLengthVector< TValueType > & v)
{
  return v * scalar;
}

template< typename TValueType >
std::ostream & operator<<(std::ostream & os, const VariableLengthVector< TValueType > & arr)
{
  const unsigned int length = arr.Size();
  const signed int   last   = (unsigned int)length - 1;

  os << "[";
  for ( signed int i = 0; i < last; ++i )
    {
    os << arr[i] << ", ";
    }
  if ( length >= 1 )
    {
    os << arr[last];
    }
  os << "]";
  return os;
}
} // namespace itk

#include "itkNumericTraitsVariableLengthVectorPixel.h"

// Define instantiation macro for this template.
#define ITK_TEMPLATE_VariableLengthVector(_, EXPORT, TypeX, TypeY)                    \
  namespace itk                                                                       \
  {                                                                                   \
  _( 1 ( class EXPORT VariableLengthVector< ITK_TEMPLATE_1 TypeX > ) )                \
  namespace Templates                                                                 \
  {                                                                                   \
  typedef VariableLengthVector< ITK_TEMPLATE_1 TypeX > VariableLengthVector##TypeY; \
  }                                                                                   \
  }

#if ITK_TEMPLATE_EXPLICIT
#include "Templates/itkVariableLengthVector+-.h"
#endif

#if ITK_TEMPLATE_TXX
#include "itkVariableLengthVector.hxx"
#endif

#endif