SmartPointerVector.h

Go to the documentation of this file.

// This file is part of the Peano project. For conditions of distribution and
// use, please see the copyright notice at www.peano-framework.org
#pragma once
 
#include "tarch/la/la.h"
#include "tarch/Assertions.h"
#include "tarch/accelerator/accelerator.h"
#include "tarch/compiler/CompilerSpecificSettings.h"
 
#include <memory>
#include <string>
#include <bitset>
#include <sstream>
#include <initializer_list>
 
namespace tarch {
  namespace la {
    template <int Size, typename Scalar>
    struct SmartPointerVector;
 
    template <int Size, typename Scalar>
    struct Vector;
 
    template <typename NewScalarType, int Size, typename Scalar>
    tarch::la::SmartPointerVector<Size,NewScalarType> convertScalar(const tarch::la::SmartPointerVector<Size,Scalar>&  SmartPointerVector);
  }
}
 
template<int Size, typename Scalar>
std::string toString( const tarch::la::SmartPointerVector<Size,Scalar>&  smartPointerVector );
 
template <int Size, typename Scalar>
struct tarch::la::SmartPointerVector {
  private:
    Scalar* _values;
 
    std::shared_ptr< Scalar[] > _dataSmartPointer;
 
  public:
    SmartPointerVector() InlineMethod;
 
    SmartPointerVector( const Scalar* values ) InlineMethod;
 
    SmartPointerVector( std::initializer_list<Scalar> values );
 
    SmartPointerVector( const std::bitset<Size>& values ) InlineMethod;
 
    SmartPointerVector(const Scalar& initialValue);
 
    SmartPointerVector(const SmartPointerVector<Size,Scalar>&  toCopy);
 
    SmartPointerVector(const Vector<Size,Scalar>&  toCopy);
 
    inline SmartPointerVector<Size,Scalar>& operator= (const SmartPointerVector<Size,Scalar>& toAssign) InlineMethod;
 
    inline SmartPointerVector<Size,Scalar>& operator=( const Vector<Size,Scalar>& vector );
 
    inline SmartPointerVector<Size,Scalar>& operator=( const Scalar& vector );
 
    int size() const;
 
    inline const Scalar& operator[] (int index) const InlineMethod {
#if defined(GPUOffloadingOff)
          assertion3 ( index >= 0, index, Size, ::toString(*this) );
          assertion4 ( index < Size, index, Size, ::toString(*this), "you may not take the indexth entry from a SmartPointerVector with only Size components" );
#endif
        return _values[index];
    }
 
    inline Scalar& operator[] (int index) InlineMethod {
#if defined(GPUOffloadingOff)
          assertion3 ( index >= 0, index, Size, ::toString(*this) );
          assertion3 ( index < Size, index, Size, ::toString(*this) );
#endif
        return _values[index];
    }
 
    inline const Scalar& operator() (int index) const InlineMethod {
#if defined(GPUOffloadingOff)
          assertion3 ( index >= 0, index, Size, ::toString(*this) );
          assertion3 ( index < Size, index, Size, ::toString(*this) );
#endif
        return _values[index];
    }
 
    inline Scalar& operator() (int index) InlineMethod {
#if defined(GPUOffloadingOff)
        assertion3 ( index >= 0, index, Size, ::toString(*this) );
        assertion3 ( index < Size, index, Size, ::toString(*this) );
#endif
       return _values[index];
     }
 
    Scalar* data() {
      return _values;
    }
 
    const Scalar * data() const {
      return _values;
    }
 
    Vector<Size,Scalar> toVector() const;
};
 
#include "tarch/la/SmartPointerVector.cpph"