IOption.hpp

#pragma once
 
///=============================================================================
/// \file
/// \brief  Abstract option classes.
/// \author WK
/// \date   29.02.2020
///=============================================================================
 
#include <opals/fwd.hpp>
#include <opals/UsageLevel.hpp>
#include <opals/ValueSource.hpp>
#include <opals/OptionNames.hpp>
#include <type_traits>
 
namespace opals
{
  /// Contains the public interface of OPALS option types.
  namespace opts
  {
 
    /// Enumerates the main option types.
    enum struct Nodes
    {
      value,
      feed,
      group,
      vector,
      array
    };
 
    template<Names nam>
    using NameT = std::integral_constant<Names, nam>;
 
    template<Nodes nod>
    using NodeT = std::integral_constant<Nodes, nod>;
 
    /// Base class of all option types.
    struct IBase
    {
      /// The option name as enumerator.
      virtual Names      enumerator()       const = 0;
      /// The option name as string.
      virtual String     name()             const = 0;
      /// The option name as string, preceded by the names of its parents, if any, interspersed with '.'
      virtual String     path()             const = 0;
      /// One-liner that describes this option.
      virtual String     shortDescription() const = 0;
      /// Longer text that describes this option in more detail.
      virtual String     longDescription()  const = 0;
      /// For a leaf, this is its own usage level. Otherwise, this is the minimum usage level of all descendants: basic < mid < pro
      virtual UsageLevel minUsageLevel()    const = 0;
      /// The node type of this option.
      virtual Nodes      node()             const = 0;
    };
 
    /// A leaf that holds a value
    /** \tparam nam   The value name.
        \tparam cnst  If true, then the value may not be changed.
        \tparam T     The value type. */
    template<Names nam, bool cnst, class T>
    struct IValue :
      IBase
    {
      using Name = NameT<nam>;
      using Node = NodeT<Nodes::value>;
 
      /// Frequency / expected skills of users that access this leaf.
      virtual UsageLevel usageLevel()  const = 0;
      /// The context in which the value has been set.
      virtual ValueSource valueSource() const = 0;
      /// If its value has not been set, a leaf is considered empty.
      /** Accessing its value then raises an exception. */
      virtual bool empty() const = 0;
      /// Returns !empty()
      virtual explicit operator bool() const = 0;
 
      /// Get the value.
      virtual const T& get() const = 0;
      /// Get the value or default_ if empty.
      virtual T getOr(T&& default_) const = 0;
      virtual const T& getOr(const T& default_) const = 0;
 
    };
 
    /// A leaf that holds a read-write value
    /** \tparam nam  The value name.
        \tparam T    The value type. */
    template<Names nam, class T>
    struct IValue<nam, false, T> :
      IValue<nam, true, T>
    {
      /// Set the value.
      virtual void set(const T& value) = 0;
    };
 
    /// A leaf that feeds values to its targets.
    /** \tparam nam   The feed name.
        \tparam cnst  If true, then no values can actually be fed.
        \tparam T     The value type. */
    template<Names nam, bool cnst, class T>
    struct IFeed :
      IBase
    {
      using Name = NameT<nam>;
      using Node = NodeT<Nodes::feed>;
 
      virtual Vector<T> get() const = 0;
 
    };
 
    /// A leaf that actually feeds values to its targets.
    /** \tparam nam  The feed name.
        \tparam T    The value type. */
    template<Names nam, class T>
    struct IFeed<nam, false, T> :
      IFeed<nam, true, T>
    {
      /// Feed the values.
      virtual void set(const Vector<T>& values) = 0;
    };
  }
}
 
#include <opals/IAccess.hpp>
 
namespace opals
{
  namespace opts
  {
 
    /// A group of options
    /** \tparam nam   The group name.
        \tparam Opts  The group members. */
    template<Names nam, class... Opts>
    struct IGroup :
      IAcc<Opts...>
    {
      using Name = NameT<nam>;
      using Node = NodeT<Nodes::group>;
    };
 
    template<Names, bool, class...>
    struct IVector;
 
    template<Names, size_t, class...>
    struct IArray;
 
    namespace ifeed
    {
      template<class>
      struct TypeT;
 
      template<class T>
      using Type = typename TypeT<T>::Typ;
 
      template<Names nam, bool cnst, class T>
      struct TypeT<IValue<nam, cnst, T>>
      {
        using Typ = IFeed<nam, cnst, T>;
      };
 
      template<Names nam, bool cnst, class T>
      struct TypeT<IFeed<nam, cnst, T>>
      {
        using Typ = IFeed<nam, cnst, T>;
      };
 
      template<Names nam, class... Opts>
      struct TypeT<IGroup<nam, Opts...>>
      {
        using Typ = IGroup<nam, Type<Opts>...>;
      };
 
      template<Names nam, bool cnst, class... Opts>
      struct TypeT<IVector<nam, cnst, Opts...>>
      {
        using Typ = IVector<nam, cnst, Type<Opts>...>;
      };
 
      template<Names nam, size_t n, class... Opts>
      struct TypeT<IArray<nam, n, Opts...>>
      {
        using Typ = IArray<nam, n, Type<Opts>...>;
      };
    }
 
    template<class Cont>
    class Iterator
    {
      Cont* cont_;
      size_t pos_;
      using Element_ = typename std::conditional<
                         std::is_const<Cont>::value,
                         typename std::add_const<typename Cont::Element>::type,
                         typename Cont::Element>::type;
    public:
      using iterator_category = std::input_iterator_tag;
      using difference_type = ptrdiff_t;
      using value_type = Element_;
      using reference = value_type&;
      using pointer = value_type*;
 
      Iterator(Cont* cont = nullptr, size_t pos = 0) : cont_(cont), pos_(pos) {}
      operator Iterator<typename std::add_const<Cont>::type>() const { return { cont_, pos_ }; }
      reference operator* () const { return (*cont_)[pos_]; }
      pointer   operator->() const { return &(*cont_)[pos_]; }
      Iterator& operator++() { ++pos_; return *this; }
      Iterator  operator++(int) { Iterator res(*this); ++*this; return res; }
      friend bool operator==(const Iterator& a, const Iterator& b) { return a.cont_ == b.cont_ && a.pos_ == b.pos_; };
      friend bool operator!=(const Iterator& a, const Iterator& b) { return !(a == b); };
    };
 
    /// A container of options.
    /** \tparam nam   The name of the container and its elements.
        \tparam Opts  The sequence of options that composes each element.
        Provides access to specific elements by index, to the default-element, and to the feed-element. */
    template<Names nam, class... Opts>
    struct IContainer :
      IBase
    {
      using Name = NameT<nam>;
      using Element = IGroup<nam, Opts...>;
      using Feed = ifeed::Type<Element>;
 
      /// The number of actual elements.
      virtual size_t size() const = 0;
      /// Returns size() == 0
      virtual bool empty() const = 0;
 
      /// \name Access an actual element.
      ///@{
      virtual const Element& operator[](size_t idx) const = 0;
      virtual       Element& operator[](size_t idx)       = 0;
      ///@}
 
      /** \name Access the default element.
          Changes to it are also applied immediately to all actual elements. */
      ///@{
      virtual const Element& all() const = 0;
      virtual       Element& all()       = 0;
      ///@}
 
      /** \name Access the feed element.
          Values set on it are distributed over the actual elements and thereby define their number. */
      ///@{
      virtual const Feed& feed() const = 0;
      virtual       Feed& feed()       = 0;
      ///@}
 
      /// \name iterator traversal
      ///@{
      Iterator<IContainer> begin()
      {
        return { this };
      }
 
      Iterator<const IContainer> begin() const
      {
        return { this };
      }
 
      Iterator<IContainer> end()
      {
        return { this, size() };
      }
 
      Iterator<const IContainer> end() const
      {
        return { this, size() };
      }
      ///@}
    };
 
    /// A vector of a variable number of options.
    /** \tparam nam   The name of the vector and its elements.
        \tparam cnst  If true, then this vector provides only constant access to its elements.
        \tparam Opts  The sequence of options that composes each element. */
    template<Names nam, bool cnst, class... Opts>
    struct IVector :
      IContainer<nam, Opts...>
    {
      using Node = NodeT<Nodes::vector>;
    };
 
    /// A vector of a variable number of read-write options.
    template<Names nam, class... Opts>
    struct IVector<nam, false, Opts...> :
      IContainer<nam, Opts...>
    {
      using Node = NodeT<Nodes::vector>;
      /// Set the number of elements. New elements are initialized with the default element.
      virtual void resize(size_t size) = 0;
    };
 
    /// An array of N options.
    /** \tparam nam   The name of the array and its elements.
        \tparam cnst  If true, then this array provides only constant access to its elements.
        \tparam N     The number of elements.
        \tparam Opts  The sequence of options that composes each element. */
    template<Names nam, size_t n, class... Opts>
    struct IArray :
      IContainer<nam, Opts...>
    {
      using Node = NodeT<Nodes::array>;
    };
  }
}