UniqueStorage.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 <memory>
#include <vector>
#include <utility>
#include <iostream>
 
template <class T>
class UniqueStorage;
template <typename T>
void storeHelper(std::ostream & stream, UniqueStorage<T> &, void *);
template <typename T>
void loadHelper(std::istream & stream, UniqueStorage<T> &, void *);
 
template <class T>
class UniqueStorage
{
public:
  UniqueStorage() = default;
  UniqueStorage(UniqueStorage &&) = default;
  UniqueStorage(const UniqueStorage & mp) = delete;
  UniqueStorage & operator=(const UniqueStorage &) = delete;
 
  template <class BaseIterator>
  struct DereferenceIterator : public BaseIterator
  {
    DereferenceIterator(const BaseIterator & it) : BaseIterator(it) {}
 
    using value_type = typename BaseIterator::value_type::element_type;
    using pointer = value_type *;
    using reference = value_type &;
 
    reference operator*() const
    {
      auto & val = BaseIterator::operator*();
      mooseAssert(val, "Null object");
      return *val;
    }
    pointer operator->() const { return BaseIterator::operator*().get(); }
    reference operator[](size_t n) const
    {
      auto & val = BaseIterator::operator[](n);
      mooseAssert(val, "Null object");
      return *val;
    }
  };
 
  using values_type = typename std::vector<std::unique_ptr<T>>;
  using iterator = DereferenceIterator<typename values_type::iterator>;
  using const_iterator = DereferenceIterator<typename values_type::const_iterator>;
 
  iterator begin() { return iterator(_values.begin()); }
  iterator end() { return iterator(_values.end()); }
  const_iterator begin() const { return const_iterator(_values.begin()); }
  const_iterator end() const { return const_iterator(_values.end()); }
 
  const T & operator[](const std::size_t i) const
  {
    mooseAssert(hasValue(i), "Null object");
    return *pointerValue(i);
  }
  T & operator[](const std::size_t i) { return const_cast<T &>(std::as_const(*this)[i]); }
 
  std::size_t size() const { return _values.size(); }
  bool empty() const { return _values.empty(); }
 
  bool hasValue(const std::size_t i) const { return pointerValue(i) != nullptr; }
 
  const T * queryValue(const std::size_t i) const { return pointerValue(i).get(); }
  T * queryValue(const std::size_t i)
  {
    return const_cast<T *>(std::as_const(*this).queryValue(i));
  }
 
protected:
  void setPointer(const std::size_t i, std::unique_ptr<T> && ptr)
  {
    mooseAssert(size() > i, "Invalid size");
    _values[i] = std::move(ptr);
  }
 
  T & addPointer(std::unique_ptr<T> && ptr)
  {
    mooseAssert(ptr, "Null object");
    return *_values.emplace_back(std::move(ptr));
  }
 
  void resize(const std::size_t size) { _values.resize(size); }
 
  void clear() { _values.clear(); }
 
private:
  const std::unique_ptr<T> & pointerValue(const std::size_t i) const
  {
    mooseAssert(size() > i, "Invalid size");
    return _values[i];
  }
  std::unique_ptr<T> & pointerValue(const std::size_t i)
  {
    return const_cast<std::unique_ptr<T> &>(std::as_const(*this).pointerValue(i));
  }
 
  friend void storeHelper<>(std::ostream & stream, UniqueStorage<T> &, void *);
  friend void loadHelper<>(std::istream & stream, UniqueStorage<T> &, void *);
 
  values_type _values;
};