Storage.h

// Copyright 2023, UChicago Argonne, LLC
// All Rights Reserved
// Software Name: NEML2 -- the New Engineering material Model Library, version 2
// By: Argonne National Laboratory
// OPEN SOURCE LICENSE (MIT)
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
 
#pragma once
 
#include <memory>
#include <vector>
#include <utility>
 
#include "neml2/misc/error.h"
 
namespace neml2
{
template <typename I, typename T>
class Storage
{
public:
  Storage() = default;
  Storage(Storage &&) = default;
  Storage(const Storage &) = delete;
  Storage & operator=(const Storage &) = delete;
 
  template <class BaseIterator>
  struct DereferenceIterator : public BaseIterator
  {
    DereferenceIterator(const BaseIterator & it)
      : BaseIterator(it)
    {
    }
 
    using key_type = typename BaseIterator::value_type::first_type;
    using value_type = typename BaseIterator::value_type::second_type::element_type;
 
    std::pair<key_type, value_type &> operator*() const
    {
      auto & [key, val] = BaseIterator::operator*();
      neml_assert_dbg(val.get(),
                      "Trying to dereference a null object. Make sure the storage was properly "
                      "initialized using set_pointer().");
      return {key, *val};
    }
    std::pair<key_type, value_type *> operator->() const
    {
      auto & [key, val] = BaseIterator::operator*();
      neml_assert_dbg(val.get(),
                      "Trying to dereference a null object. Make sure the storage was properly "
                      "initialized using set_pointer().");
      return {key, val.get()};
    }
  };
 
  using values_type = typename std::map<I, 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()); }
 
  T & operator[](const I & i) const
  {
    neml_assert_dbg(has_key(i),
                    "Trying to access a null object. Make sure the storage was properly "
                    "initialized using set_pointer().");
    return *pointer_value(i);
  }
  T & operator[](const I & i) { return std::as_const(*this)[i]; }
 
  std::size_t size() const { return _values.size(); }
 
  bool empty() const { return _values.empty(); }
 
  bool has_key(const I & i) const { return _values.count(i); }
 
  const T * query_value(const I & i) const { return has_key(i) ? pointer_value(i).get() : nullptr; }
  T * query_value(const I & i)
  {
    return has_key(i) ? const_cast<T *>(std::as_const(*this).query_value(i)) : nullptr;
  }
 
  T * set_pointer(const I & i, std::unique_ptr<T> && ptr)
  {
    _values[i] = std::move(ptr);
    return _values[i].get();
  }
 
private:
  const std::unique_ptr<T> & pointer_value(const I & i) const { return _values.at(i); }
 
  values_type _values;
};
} // namespace neml2