OptionSet.h

// Copyright 2024, 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 <map>
#include <string>
#include <vector>
#include <memory>
 
#include "neml2/base/Option.h"
#include "neml2/misc/errors.h"
 
namespace neml2
{
// Forward decl
class OptionSet;
class LabeledAxisAccessor;
 
bool options_compatible(const OptionSet & opts, const OptionSet & additional_opts);
 
// Streaming operators
std::ostream & operator<<(std::ostream & os, const OptionSet & p);

class OptionSet
{
public:
  OptionSet() = default;
 
  OptionSet(const OptionSet &);
  OptionSet(OptionSet &&) noexcept;
  OptionSet & operator=(const OptionSet &);
  OptionSet & operator=(OptionSet &&) noexcept;
  virtual ~OptionSet() = default;


  void operator+=(const OptionSet & source);
  void operator+=(OptionSet && source);

  const std::string & name() const { return _metadata.name; }
  std::string & name() { return _metadata.name; }
  const std::string & type() const { return _metadata.type; }
  std::string & type() { return _metadata.type; }
  const std::string & path() const { return _metadata.path; }
  std::string & path() { return _metadata.path; }
  const std::string & doc() const { return _metadata.doc; }
  std::string & doc() { return _metadata.doc; }
  const std::string & section() const { return _metadata.section; }
  std::string & section() { return _metadata.section; }

  template <typename T>
  bool contains(const std::string &) const;

  bool contains(const std::string &) const;

  std::size_t size() const { return _values.size(); }

  void clear();

  std::string to_str() const;

  template <typename T>
  const T & get(const std::string &) const;
 
  const OptionBase & get(const std::string &) const;


  template <typename T, FType f = FType::NONE>
  T & set(const std::string &);
  OptionBase & set(const std::string &);

  LabeledAxisAccessor & set_input(const std::string &);
  LabeledAxisAccessor & set_output(const std::string &);
  template <typename T>
  T & set_parameter(const std::string &);
  template <typename T>
  T & set_buffer(const std::string &);

  using map_type = std::map<std::string, std::unique_ptr<OptionBase>, std::less<>>;
  using iterator = map_type::iterator;
  using const_iterator = map_type::const_iterator;

  iterator begin();
  const_iterator begin() const;
  iterator end();
  const_iterator end() const;
 
protected:
  struct Metadata
  {
    std::string name = "";
    std::string type = "";
    std::string path = "";
    std::string doc = "";
    std::string section = "";
  } _metadata;
  struct Metadata {…};

  map_type _values;
};
class OptionSet {…};

// Implementation
 
template <typename T>
bool
OptionSet::contains(const std::string & name) const
{
  OptionSet::const_iterator it = _values.find(name);
  if (it != _values.end())
    if (dynamic_cast<const Option<T> *>(it->second.get()))
      return true;
  return false;
}
OptionSet::contains(const std::string & name) const {…}
 
template <typename T>
const T &
OptionSet::get(const std::string & name) const
{
  if (!this->contains<T>(name))
    throw NEMLException("ERROR: no option named \"" + name + "\" found.\n\nKnown options:\n" +
                        to_str());
 
  auto ptr = dynamic_cast<Option<T> *>(_values.at(name).get());
  return ptr->get();
}
OptionSet::get(const std::string & name) const {…}
 
template <typename T, FType F>
T &
OptionSet::set(const std::string & name)
{
  if (!this->contains<T>(name))
    _values[name] = std::make_unique<Option<T>>(name);
  auto ptr = dynamic_cast<Option<T> *>(_values[name].get());
  ptr->ftype() = F;
  return ptr->set();
}
OptionSet::set(const std::string & name) {…}
 
template <typename T>
T &
OptionSet::set_parameter(const std::string & name)
{
  return set<T, FType::PARAMETER>(name);
}
OptionSet::set_parameter(const std::string & name) {…}
 
template <typename T>
T &
OptionSet::set_buffer(const std::string & name)
{
  return set<T, FType::BUFFER>(name);
}
OptionSet::set_buffer(const std::string & name) {…}
} // namespace neml2