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 "neml2/misc/utils.h"
 
#include <map>
#include <sstream>
#include <string>
#include <typeinfo>
#include <vector>
#include <memory>
 
namespace neml2
{
// Forward decl
class OptionSet;
class LabeledAxisAccessor;
 
namespace details
{
template <typename P>
void _print_helper(std::ostream & os, const P *);
template <typename P>
void _print_helper(std::ostream & os, const std::vector<P> *);
template <>
void _print_helper(std::ostream & os, const std::vector<bool> *);
template <typename P>
void _print_helper(std::ostream & os, const std::vector<std::vector<P>> *);
template <>
void _print_helper(std::ostream & os, const char *);
template <>
void _print_helper(std::ostream & os, const unsigned char *);
}
 
bool options_compatible(const OptionSet & opts, const OptionSet & additional_opts);
 
// Streaming operators
std::ostream & operator<<(std::ostream & os, FType);
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();
 
  void print(std::ostream & os = std::cout) const;
 
  class OptionBase
  {
  public:
    OptionBase() = default;
 
    OptionBase(OptionBase &&) = delete;
    OptionBase(const OptionBase &) = delete;
    OptionBase & operator=(const OptionBase &) = delete;
    OptionBase & operator=(OptionBase &&) = delete;
    virtual ~OptionBase() = default;
 
    virtual bool operator==(const OptionBase & other) const = 0;
 
    virtual bool operator!=(const OptionBase & other) const = 0;
 
    const std::string & name() const { return _metadata.name; }
 
    const std::string & type() const { return _metadata.type; }
 
    const FType & ftype() const { return _metadata.ftype; }
 
    FType & ftype() { return _metadata.ftype; }
 
    const std::string & doc() const { return _metadata.doc; }
 
    std::string & doc() { return _metadata.doc; }
 
    const bool & suppressed() const { return _metadata.suppressed; }
 
    bool & suppressed() { return _metadata.suppressed; }
 
    const bool & user_specified() const { return _metadata.user_specified; }
 
    bool & user_specified() { return _metadata.user_specified; }
 
    virtual void print(std::ostream &) const = 0;
 
    virtual std::unique_ptr<OptionBase> clone() const = 0;
 
  protected:
    struct Metadata
    {
      std::string name = "";
      std::string type = "";
      FType ftype = FType::NONE;
      std::string doc = "";
      bool suppressed = false;
      bool user_specified = false;
 
      bool operator==(const Metadata & other) const
      {
        return name == other.name && type == other.type && ftype == other.ftype &&
               doc == other.doc && suppressed == other.suppressed &&
               user_specified == other.user_specified;
      }
 
      bool operator!=(const Metadata & other) const { return !(*this == other); }
 
    } _metadata;
  };
 
  template <typename T>
  class Option : public OptionBase
  {
  public:
    Option(const std::string & name)
      : _value()
    {
      _metadata.name = name;
      _metadata.type = utils::demangle(typeid(T).name());
    }
 
    bool operator==(const OptionBase & other) const override;
 
    bool operator!=(const OptionBase & other) const override;
 
    const T & get() const { return _value; }
 
    T & set() { return _value; }
 
    void print(std::ostream &) const override;
 
    std::unique_ptr<OptionBase> clone() const override;
 
  private:
    T _value;
  };
 
  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;
 
  map_type _values;
};
 
template <typename T>
bool
OptionSet::Option<T>::operator==(const OptionBase & other) const
{
  const auto other_ptr = dynamic_cast<const Option<T> *>(&other);
  if (!other_ptr)
    return false;
 
  return (_metadata == other_ptr->_metadata) && (other_ptr->get() == this->get());
}
 
template <typename T>
bool
OptionSet::Option<T>::operator!=(const OptionBase & other) const
{
  return !(*this == other);
}
 
// LCOV_EXCL_START
template <typename T>
void
OptionSet::Option<T>::print(std::ostream & os) const
{
  details::_print_helper(os, static_cast<const T *>(&_value));
}
// LCOV_EXCL_STOP
 
template <typename T>
std::unique_ptr<OptionSet::OptionBase>
OptionSet::Option<T>::clone() const
{
  auto copy = std::make_unique<Option<T>>(this->name());
  copy->_value = this->_value;
  copy->_metadata = this->_metadata;
  return copy;
}
 
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;
}
 
template <typename T>
const T &
OptionSet::get(const std::string & name) const
{
  neml_assert(this->contains<T>(name),
              "ERROR: no option named \"",
              name,
              "\" found.\n\nKnown options:\n",
              *this);
 
  auto ptr = dynamic_cast<Option<T> *>(_values.at(name).get());
  return ptr->get();
}
 
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();
}
 
template <typename T>
T &
OptionSet::set_parameter(const std::string & name)
{
  return set<T, FType::PARAMETER>(name);
}
 
template <typename T>
T &
OptionSet::set_buffer(const std::string & name)
{
  return set<T, FType::BUFFER>(name);
}
 
namespace details
{
// LCOV_EXCL_START
template <typename P>
void
_print_helper(std::ostream & os, const P * option)
{
  os << *option;
}
 
template <>
inline void
_print_helper(std::ostream & os, const char * option)
{
  os << static_cast<int>(*option);
}
 
template <>
inline void
_print_helper(std::ostream & os, const unsigned char * option)
{
  os << static_cast<int>(*option);
}
 
template <typename P>
void
_print_helper(std::ostream & os, const std::vector<P> * option)
{
  for (const auto & p : *option)
    os << p << " ";
}
 
template <>
inline void
_print_helper(std::ostream & os, const std::vector<bool> * option)
{
  for (const auto p : *option)
    os << static_cast<bool>(p) << " ";
}
 
template <typename P>
void
_print_helper(std::ostream & os, const std::vector<std::vector<P>> * option)
{
  for (const auto & pv : *option)
    _print_helper(os, &pv);
}
} // namespace details
// LCOV_EXCL_STOP
} // namespace neml2