MooseArray.h

Go to the documentation of this file.

//* This file is part of the MOOSE framework
//* https://mooseframework.inl.gov
//*
//* All rights reserved, see COPYRIGHT for full restrictions
//* https://github.com/idaholab/moose/blob/master/COPYRIGHT
//*
//* Licensed under LGPL 2.1, please see LICENSE for details
//* https://www.gnu.org/licenses/lgpl-2.1.html

#pragma once

#include <vector>
#include <memory>
#include "MooseError.h"

template <typename T>
class MooseArray
{
public:
  typedef T value_type;

  MooseArray() : _data(nullptr), _size(0), _allocated_size(0) {}

  explicit MooseArray(const unsigned int size) : _data(nullptr), _size(0), _allocated_size(0)
  {
    resize(size);
  }

  explicit MooseArray(const unsigned int size, const T & default_value)
    : _data(nullptr), _size(0), _allocated_size(0)
  {
    resize(size);

    setAllValues(default_value);
  }

  explicit MooseArray(const MooseArray & rhs) : _data(nullptr), _size(0), _allocated_size(0)
  {
    resize(rhs._size);

    for (unsigned int i = 0; i < _size; i++)
      _data[i] = rhs._data[i];
  }

  ~MooseArray() = default;

  void setAllValues(const T & value);

  void release()
  {
    if (_data_ptr)
    {
      _data_ptr.reset();
      _data = nullptr;
      _allocated_size = _size = 0;
    }
  }

  void clear();

  template <bool value_initialize = false>
  void resize(unsigned int size);

  void resize(unsigned int size, const T & default_value);

  unsigned int size() const;

  T & operator[](const unsigned int i);

  const T & operator[](const unsigned int i) const;

  void swap(MooseArray & rhs);

  void shallowCopy(const MooseArray & rhs);

  void shallowCopy(std::vector<T> & rhs);

  MooseArray<T> & operator=(const std::vector<T> & rhs);

  MooseArray<T> & operator=(const MooseArray<T> & rhs);

  std::vector<T> stdVector() const;


  const T * data() const { return _data; }
  T * data() { return _data; }

private:
  std::unique_ptr<T[]> _data_ptr;

  // Actual data pointer (from inside of the smart pointer).
  T * _data;

  unsigned int _size;

  unsigned int _allocated_size;
};

template <typename T>
inline void
MooseArray<T>::setAllValues(const T & value)
{
  for (unsigned int i = 0; i < _size; i++)
    _data[i] = value;
}

template <typename T>
inline void
MooseArray<T>::clear()
{
  _size = 0;
}

template <typename T>
template <bool value_initialize>
inline void
MooseArray<T>::resize(unsigned int size)
{
  if (size > _allocated_size)
  {
    if constexpr (value_initialize)
      _data_ptr.reset(new T[size]());
    else
      _data_ptr = std::make_unique<T[]>(size);
    mooseAssert(_data_ptr, "Failed to allocate MooseArray memory!");

    _data = _data_ptr.get();
    _allocated_size = size;
  }

  _size = size;
}

template <typename T>
inline void
MooseArray<T>::resize(unsigned int size, const T & default_value)
{
  if (size > _allocated_size)
  {
    auto new_pointer = std::make_unique<T[]>(size);
    mooseAssert(new_pointer, "Failed to allocate MooseArray memory!");

    if (_data)
      for (unsigned int i = 0; i < _size; i++)
        new_pointer[i] = _data[i];

    _data_ptr = std::move(new_pointer);
    _data = _data_ptr.get();
    _allocated_size = size;
  }

  for (unsigned int i = _size; i < size; i++)
    _data[i] = default_value;

  _size = size;
}

template <typename T>
inline unsigned int
MooseArray<T>::size() const
{
  return _size;
}

template <typename T>
inline T &
MooseArray<T>::operator[](const unsigned int i)
{
  mooseAssert(i < _size,
              "Access out of bounds in MooseArray (i: " << i << " size: " << _size << ")");

  return _data[i];
}

template <typename T>
inline const T &
MooseArray<T>::operator[](const unsigned int i) const
{
  mooseAssert(i < _size,
              "Access out of bounds in MooseArray (i: " << i << " size: " << _size << ")");

  return _data[i];
}

template <typename T>
inline void
MooseArray<T>::swap(MooseArray & rhs)
{
  _data_ptr.swap(rhs._data_ptr);
  std::swap(_data, rhs._data);
  std::swap(_size, rhs._size);
  std::swap(_allocated_size, rhs._allocated_size);
}

template <typename T>
inline void
MooseArray<T>::shallowCopy(const MooseArray & rhs)
{
  _data_ptr.reset();
  _data = rhs._data;
  _size = rhs._size;
  _allocated_size = rhs._allocated_size;
}

template <typename T>
inline void
MooseArray<T>::shallowCopy(std::vector<T> & rhs)
{
  _data_ptr.reset();
  _data = &rhs[0];
  _size = rhs.size();
  _allocated_size = rhs.size();
}

template <typename T>
inline MooseArray<T> &
MooseArray<T>::operator=(const std::vector<T> & rhs)
{
  unsigned int rhs_size = rhs.size();

  resize(rhs_size);

  for (unsigned int i = 0; i < rhs_size; i++)
    _data[i] = rhs[i];

  return *this;
}

template <typename T>
inline MooseArray<T> &
MooseArray<T>::operator=(const MooseArray<T> & rhs)
{
  //  mooseError("Shouldn't be doing this!");
  resize(rhs._size);
  //  memcpy(_data,rhs._data,sizeof(T)*_size);

  for (unsigned int i = 0; i < _size; i++)
    _data[i] = rhs._data[i];

  return *this;
}

template <class T>
std::vector<T>
MooseArray<T>::stdVector() const
{
  return std::vector<T>(_data, _data + _size);
}

template <class T>
void
freeDoubleMooseArray(MooseArray<MooseArray<T>> & a)
{
  for (unsigned int i = 0; i < a.size(); i++)
    a[i].release();
  a.release();
}