patterns.h

Go to the documentation of this file.

// ------------------------------------------------------------------------
//
// SPDX-License-Identifier: LGPL-2.1-or-later
// Copyright (C) 2017 - 2023 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Part of the source code is dual licensed under Apache-2.0 WITH
// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
// governing the source code and code contributions can be found in
// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
//
// ------------------------------------------------------------------------
 
#ifndef dealii_patterns_h
#define dealii_patterns_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/enable_observer_pointer.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/point.h>
#include <deal.II/base/template_constraints.h>
#include <deal.II/base/utilities.h>
 
#include <deal.II/fe/component_mask.h>
 
#include <boost/archive/basic_archive.hpp>
#include <boost/core/demangle.hpp>
#include <boost/property_tree/ptree_fwd.hpp>
#include <boost/property_tree/ptree_serialization.hpp>
#include <boost/serialization/split_member.hpp>
 
#include <algorithm>
#include <array>
#include <deque>
#include <limits>
#include <list>
#include <map>
#include <memory>
#include <set>
#include <sstream>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
 
#ifdef DEAL_II_WITH_MAGIC_ENUM
#  include <magic_enum.hpp>
#endif
 
DEAL_II_NAMESPACE_OPEN
 
// forward declarations for interfaces and friendship
#ifndef DOXYGEN
class LogStream;
class MultipleParameterLoop;
template <int dim>
class FunctionParser;
#endif
 
namespace Patterns
{
  class PatternBase
  {
  public:
    virtual ~PatternBase() = default;
 
    virtual bool
    match(const std::string &test_string) const = 0;
 
    enum OutputStyle
    {
      Machine,
      Text,
      LaTeX
    };
 
    virtual std::string
    description(const OutputStyle style = Machine) const = 0;
 
    virtual std::unique_ptr<PatternBase>
    clone() const = 0;
 
    virtual std::size_t
    memory_consumption() const;
  };
 
  std::unique_ptr<PatternBase>
  pattern_factory(const std::string &description);
 
  namespace internal
  {
    std::string
    escape(const std::string &input, const PatternBase::OutputStyle style);
 
  } // namespace internal
 
  class Integer : public PatternBase
  {
  public:
    static const int min_int_value;
 
    static const int max_int_value;
 
    Integer(const int lower_bound = min_int_value,
            const int upper_bound = max_int_value);
 
    virtual bool
    match(const std::string &test_string) const override;
 
    virtual std::string
    description(const OutputStyle style = Machine) const override;
 
    virtual std::unique_ptr<PatternBase>
    clone() const override;
 
    static std::unique_ptr<Integer>
    create(const std::string &description);
 
  private:
    const int lower_bound;
 
    const int upper_bound;
 
    static const char *description_init;
  };
 
  class Double : public PatternBase
  {
  public:
    static const double min_double_value;
 
    static const double max_double_value;
 
    Double(const double lower_bound = min_double_value,
           const double upper_bound = max_double_value);
 
    virtual bool
    match(const std::string &test_string) const override;
 
    virtual std::string
    description(const OutputStyle style = Machine) const override;
 
    virtual std::unique_ptr<PatternBase>
    clone() const override;
 
    static std::unique_ptr<Double>
    create(const std::string &description);
 
  private:
    const double lower_bound;
 
    const double upper_bound;
 
    static const char *description_init;
  };
 
  class Selection : public PatternBase
  {
  public:
    Selection(const std::string &seq);
 
    virtual bool
    match(const std::string &test_string) const override;
 
    virtual std::string
    description(const OutputStyle style = Machine) const override;
 
    virtual std::unique_ptr<PatternBase>
    clone() const override;
 
    std::size_t
    memory_consumption() const override;
 
    static std::unique_ptr<Selection>
    create(const std::string &description);
 
  private:
    std::string sequence;
 
    static const char *description_init;
  };
 
 
  class List : public PatternBase
  {
  public:
    static const unsigned int max_int_value;
 
    List(const PatternBase &base_pattern,
         const unsigned int min_elements = 0,
         const unsigned int max_elements = max_int_value,
         const std::string &separator    = ",");
 
 
    const std::string &
    get_separator() const;
 
    const PatternBase &
    get_base_pattern() const;
 
    List(const List &other);
 
    virtual bool
    match(const std::string &test_string) const override;
 
    virtual std::string
    description(const OutputStyle style = Machine) const override;
 
    virtual std::unique_ptr<PatternBase>
    clone() const override;
 
    static std::unique_ptr<List>
    create(const std::string &description);
 
    std::size_t
    memory_consumption() const override;
 
    DeclException2(ExcInvalidRange,
                   int,
                   int,
                   << "The values " << arg1 << " and " << arg2
                   << " do not form a valid range.");
  private:
    std::unique_ptr<PatternBase> pattern;
 
    const unsigned int min_elements;
 
    const unsigned int max_elements;
 
    const std::string separator;
 
    static const char *description_init;
  };
 
 
  class Map : public PatternBase
  {
  public:
    static const unsigned int max_int_value;
 
    Map(const PatternBase &key_pattern,
        const PatternBase &value_pattern,
        const unsigned int min_elements        = 0,
        const unsigned int max_elements        = max_int_value,
        const std::string &separator           = ",",
        const std::string &key_value_separator = ":");
 
    Map(const Map &other);
 
    virtual bool
    match(const std::string &test_string) const override;
 
    virtual std::string
    description(const OutputStyle style = Machine) const override;
 
    virtual std::unique_ptr<PatternBase>
    clone() const override;
 
    static std::unique_ptr<Map>
    create(const std::string &description);
 
    std::size_t
    memory_consumption() const override;
 
    const PatternBase &
    get_key_pattern() const;
 
    const PatternBase &
    get_value_pattern() const;
 
    const std::string &
    get_separator() const;
 
    const std::string &
    get_key_value_separator() const;
 
    DeclException2(ExcInvalidRange,
                   int,
                   int,
                   << "The values " << arg1 << " and " << arg2
                   << " do not form a valid range.");
  private:
    std::unique_ptr<PatternBase> key_pattern;
    std::unique_ptr<PatternBase> value_pattern;
 
    const unsigned int min_elements;
 
    const unsigned int max_elements;
 
    const std::string separator;
 
 
    const std::string key_value_separator;
 
    static const char *description_init;
  };
 
 
 
  class Tuple : public PatternBase
  {
  public:
    Tuple(const std::vector<std::unique_ptr<PatternBase>> &patterns,
          const std::string                               &separator = ":");
 
    Tuple(const std::vector<std::unique_ptr<PatternBase>> &patterns,
          const char                                      *separator);
 
 
    template <class... PatternTypes>
    Tuple(const std::string &separator, const PatternTypes &...patterns);
 
    template <class... PatternTypes>
    Tuple(const char *separator, const PatternTypes &...patterns);
 
    template <typename... Patterns>
    Tuple(const Patterns &...patterns);
 
    Tuple(const Tuple &other);
 
    virtual bool
    match(const std::string &test_string) const override;
 
    virtual std::string
    description(const OutputStyle style = Machine) const override;
 
    virtual std::unique_ptr<PatternBase>
    clone() const override;
 
    static std::unique_ptr<Tuple>
    create(const std::string &description);
 
    std::size_t
    memory_consumption() const override;
 
    const PatternBase &
    get_pattern(const unsigned int i) const;
 
    const std::string &
    get_separator() const;
 
  private:
    std::vector<std::unique_ptr<PatternBase>> patterns;
 
    const std::string separator;
 
    static const char *description_init;
  };
 
 
  class MultipleSelection : public PatternBase
  {
  public:
    MultipleSelection(const std::string &seq);
 
    virtual bool
    match(const std::string &test_string) const override;
 
    virtual std::string
    description(const OutputStyle style = Machine) const override;
 
    virtual std::unique_ptr<PatternBase>
    clone() const override;
 
    static std::unique_ptr<MultipleSelection>
    create(const std::string &description);
 
    std::size_t
    memory_consumption() const override;
 
    DeclException1(
      ExcCommasNotAllowed,
      int,
      << "A comma was found at position " << arg1
      << " of your input string, but commas are not allowed here.");
  private:
    std::string sequence;
 
    static const char *description_init;
  };
 
  class Bool : public Selection
  {
  public:
    Bool();
 
    virtual std::string
    description(const OutputStyle style = Machine) const override;
 
    virtual std::unique_ptr<PatternBase>
    clone() const override;
 
    static std::unique_ptr<Bool>
    create(const std::string &description);
 
  private:
    static const char *description_init;
  };
 
  class Anything : public PatternBase
  {
  public:
    Anything() = default;
 
    virtual bool
    match(const std::string &test_string) const override;
 
    virtual std::string
    description(const OutputStyle style = Machine) const override;
 
    virtual std::unique_ptr<PatternBase>
    clone() const override;
 
    static std::unique_ptr<Anything>
    create(const std::string &description);
 
  private:
    static const char *description_init;
  };
 
 
  class FileName : public PatternBase
  {
  public:
    enum FileType
    {
      input = 0,
      output = 1
    };
 
    FileName(const FileType type = input);
 
    virtual bool
    match(const std::string &test_string) const override;
 
    virtual std::string
    description(const OutputStyle style = Machine) const override;
 
    virtual std::unique_ptr<PatternBase>
    clone() const override;
 
    FileType file_type;
 
    static std::unique_ptr<FileName>
    create(const std::string &description);
 
  private:
    static const char *description_init;
  };
 
 
  class DirectoryName : public PatternBase
  {
  public:
    DirectoryName() = default;
 
    virtual bool
    match(const std::string &test_string) const override;
 
    virtual std::string
    description(const OutputStyle style = Machine) const override;
 
    virtual std::unique_ptr<PatternBase>
    clone() const override;
 
    static std::unique_ptr<DirectoryName>
    create(const std::string &description);
 
  private:
    static const char *description_init;
  };
 
 
  namespace Tools
  {
    template <class T, class Enable = void>
    struct Convert
    {
      static std::unique_ptr<Patterns::PatternBase>
      to_pattern() = delete;
 
      static std::string
      to_string(const T                     &s,
                const Patterns::PatternBase &p = *Convert<T>::to_pattern()) =
        delete;
 
      static T
      to_value(const std::string           &s,
               const Patterns::PatternBase &p = *Convert<T>::to_pattern()) =
        delete;
    };
 
    template <typename T>
    std::string
    to_string(const T &t);
 
    template <typename T>
    void
    to_value(const std::string &s, T &t);
 
    DeclException2(ExcNoMatch,
                   std::string,
                   std::string,
                   << "The string \"" << arg1
                   << "\" does not match the pattern \"" << arg2 << "\"");
  } // namespace Tools
} // namespace Patterns
 
 
// ---------------------- inline and template functions --------------------
namespace Patterns
{
  template <class... PatternTypes>
  Tuple::Tuple(const char *separator, const PatternTypes &...ps)
    : // forward to the version with std::string argument
    Tuple(std::string(separator), ps...)
  {}
 
 
 
  template <class... PatternTypes>
  Tuple::Tuple(const std::string &separator, const PatternTypes &...ps)
    : separator(separator)
  {
    static_assert(is_base_of_all<PatternBase, PatternTypes...>::value,
                  "Not all of the input arguments of this function "
                  "are derived from PatternBase");
    static_assert(sizeof...(ps) > 0,
                  "The number of PatternTypes must be greater than zero!");
    const auto pattern_pointers = {(static_cast<const PatternBase *>(&ps))...};
    for (const auto p : pattern_pointers)
      patterns.push_back(p->clone());
  }
 
 
 
  template <class... PatternTypes>
  Tuple::Tuple(const PatternTypes &...ps)
    : // forward to the version with the separator argument
    Tuple(":", ps...)
  {}
 
 
 
  namespace Tools
  {
    namespace internal
    {
      template <class T, class Enable = void>
      struct RankInfo
      {
        static constexpr int list_rank = 0;
        static constexpr int map_rank  = 0;
      };
    } // namespace internal
 
    // Arithmetic types
    template <class T>
    struct Convert<T, std::enable_if_t<std::is_arithmetic_v<T>>>
    {
      template <typename Dummy = T>
      static std::enable_if_t<std::is_same_v<Dummy, T> &&
                                std::is_same_v<T, bool>,
                              std::unique_ptr<Patterns::PatternBase>>
      to_pattern()
      {
        return std::make_unique<Patterns::Bool>();
      }
 
      template <typename Dummy = T>
      static std::enable_if_t<std::is_same_v<Dummy, T> &&
                                !std::is_same_v<T, bool> &&
                                std::is_integral_v<T>,
                              std::unique_ptr<Patterns::PatternBase>>
      to_pattern()
      {
        return std::make_unique<Patterns::Integer>(
          std::numeric_limits<T>::lowest(), std::numeric_limits<T>::max());
      }
 
      template <typename Dummy = T>
      static std::enable_if_t<std::is_same_v<Dummy, T> &&
                                !std::is_same_v<T, bool> &&
                                std::is_floating_point_v<T>,
                              std::unique_ptr<Patterns::PatternBase>>
      to_pattern()
      {
        return std::make_unique<Patterns::Double>(
          std::numeric_limits<T>::lowest(), std::numeric_limits<T>::max());
      }
 
      static std::string
      to_string(const T                     &value,
                const Patterns::PatternBase &p = *Convert<T>::to_pattern())
      {
        std::stringstream str;
        if (std::is_same_v<T, unsigned char> ||
            std::is_same_v<T, signed char> || std::is_same_v<T, char>)
          str << static_cast<int>(value);
        else if (std::is_same_v<T, bool>)
          str << (static_cast<bool>(value) ? "true" : "false");
        else
          str << value;
        AssertThrow(p.match(str.str()), ExcNoMatch(str.str(), p.description()));
        return str.str();
      }
 
      static T
      to_value(const std::string           &s,
               const Patterns::PatternBase &p = *Convert<T>::to_pattern())
      {
        AssertThrow(p.match(s), ExcNoMatch(s, p.description()));
        T value;
        if (std::is_same_v<T, bool>)
          value = (s == "true");
        else
          {
            std::istringstream is(s);
            if (std::is_same_v<T, unsigned char> ||
                std::is_same_v<T, signed char> || std::is_same_v<T, char>)
              {
                int i;
                is >> i;
                value = i;
              }
            else
              is >> value;
 
            // If someone passes "123 abc" to the function, the method yields an
            // integer 123 alright, but the space terminates the read from the
            // string although there is more to come. This case, however, is
            // checked for in the call p->match(s) at the beginning of this
            // function, and would throw earlier. Here it is safe to assume that
            // if we didn't fail the conversion with the operator >>, then we
            // are good to go.
            AssertThrow(
              !is.fail(),
              ExcMessage("Failed to convert from \"" + s + "\" to the type \"" +
                         boost::core::demangle(typeid(T).name()) + "\""));
          }
        return value;
      }
    };
 
    namespace internal
    {
      constexpr std::array<const char *, 4> default_list_separator{
        {",", ";", "|", "%"}};
      constexpr std::array<const char *, 4> default_map_separator{
        {":", "=", "@", "#"}};
 
      // specialize a type for all of the STL containers and maps
      template <typename T>
      struct is_list_compatible : std::false_type
      {};
      template <typename... Args>
      struct is_list_compatible<std::vector<Args...>> : std::true_type
      {};
      template <typename... Args>
      struct is_list_compatible<std::deque<Args...>> : std::true_type
      {};
      template <typename... Args>
      struct is_list_compatible<std::list<Args...>> : std::true_type
      {};
      template <typename... Args>
      struct is_list_compatible<std::set<Args...>> : std::true_type
      {};
      template <typename... Args>
      struct is_list_compatible<std::multiset<Args...>> : std::true_type
      {};
      template <typename... Args>
      struct is_list_compatible<std::unordered_set<Args...>> : std::true_type
      {};
      template <typename... Args>
      struct is_list_compatible<std::unordered_multiset<Args...>>
        : std::true_type
      {};
 
      template <typename T>
      struct is_map_compatible : std::false_type
      {};
      template <class Key, class T, class Compare, class Allocator>
      struct is_map_compatible<std::map<Key, T, Compare, Allocator>>
        : std::true_type
      {};
      template <class Key, class T, class Compare, class Allocator>
      struct is_map_compatible<std::multimap<Key, T, Compare, Allocator>>
        : std::true_type
      {};
      template <class Key, class T, class Hash, class KeyEqual, class Allocator>
      struct is_map_compatible<
        std::unordered_map<Key, T, Hash, KeyEqual, Allocator>> : std::true_type
      {};
      template <class Key, class T, class Hash, class KeyEqual, class Allocator>
      struct is_map_compatible<
        std::unordered_multimap<Key, T, Hash, KeyEqual, Allocator>>
        : std::true_type
      {};
    } // namespace internal
 
    // type trait to use the implementation type traits as well as decay the
    // type
    template <typename T>
    struct is_list_compatible
    {
      static constexpr const bool value =
        internal::is_list_compatible<std::decay_t<T>>::value;
    };
 
    template <typename T>
    struct is_map_compatible
    {
      static constexpr const bool value =
        internal::is_map_compatible<std::decay_t<T>>::value;
    };
 
    namespace internal
    {
      // Helper function for list_rank
      template <class T>
      constexpr int
      max_list_rank()
      {
        return RankInfo<T>::list_rank;
      }
 
      template <class T1, class T2, class... Types>
      constexpr int
      max_list_rank()
      {
        return std::max(RankInfo<T1>::list_rank, max_list_rank<T2, Types...>());
      }
 
      // Helper function for map_rank
      template <class T>
      constexpr int
      max_map_rank()
      {
        return RankInfo<T>::map_rank;
      }
 
      template <class T1, class T2, class... Types>
      constexpr int
      max_map_rank()
      {
        return std::max(RankInfo<T1>::map_rank, max_map_rank<T2, Types...>());
      }
 
      // Rank of vector types
      template <class T>
      struct RankInfo<T, std::enable_if_t<is_list_compatible<T>::value>>
      {
        static constexpr int list_rank =
          RankInfo<typename T::value_type>::list_rank + 1;
        static constexpr int map_rank =
          RankInfo<typename T::value_type>::map_rank;
      };
 
      // Rank of map types
      template <class T>
      struct RankInfo<T, std::enable_if_t<is_map_compatible<T>::value>>
      {
        static constexpr int list_rank =
          max_list_rank<typename T::key_type, typename T::mapped_type>() + 1;
        static constexpr int map_rank =
          max_map_rank<typename T::key_type, typename T::mapped_type>() + 1;
      };
 
      // Rank of Tensor types
      template <int rank, int dim, class Number>
      struct RankInfo<Tensor<rank, dim, Number>>
      {
        static constexpr int list_rank = rank + RankInfo<Number>::list_rank;
        static constexpr int map_rank  = RankInfo<Number>::map_rank;
      };
 
      template <int dim, class Number>
      struct RankInfo<Point<dim, Number>> : RankInfo<Tensor<1, dim, Number>>
      {};
 
      // Rank of complex types
      template <class Number>
      struct RankInfo<std::complex<Number>>
      {
        static constexpr int list_rank = RankInfo<Number>::list_rank + 1;
        static constexpr int map_rank  = RankInfo<Number>::map_rank;
      };
 
      // Rank of FunctionParser
      template <int dim>
      struct RankInfo<std::unique_ptr<FunctionParser<dim>>>
      {
        static constexpr int list_rank = 1;
        static constexpr int map_rank  = 0;
      };
 
      // Rank of ComponentMask
      template <>
      struct RankInfo<ComponentMask>
      {
        static constexpr int list_rank = 1;
        static constexpr int map_rank  = 0;
      };
 
      // Rank of std::pair
      template <class Key, class Value>
      struct RankInfo<std::pair<Key, Value>>
      {
        static constexpr int list_rank =
          std::max(RankInfo<Key>::list_rank, RankInfo<Value>::list_rank);
        static constexpr int map_rank =
          std::max(RankInfo<Key>::map_rank, RankInfo<Value>::map_rank) + 1;
      };
 
      // Rank of std::tuple types
      template <class... Types>
      struct RankInfo<std::tuple<Types...>>
      {
        static constexpr int list_rank = max_list_rank<Types...>();
        static constexpr int map_rank  = max_map_rank<Types...>() + 1;
      };
 
      // Rank of std::array types
      template <class T, std::size_t N>
      struct RankInfo<std::array<T, N>>
      {
        static constexpr int list_rank = RankInfo<T>::list_rank + 1;
        static constexpr int map_rank  = RankInfo<T>::map_rank;
      };
    } // namespace internal
 
    // stl containers
    template <class T>
    struct Convert<T, std::enable_if_t<is_list_compatible<T>::value>>
    {
      static std::unique_ptr<Patterns::PatternBase>
      to_pattern()
      {
        static_assert(internal::RankInfo<T>::list_rank > 0,
                      "Cannot use this class for non List-compatible types.");
        return std::make_unique<Patterns::List>(
          *Convert<typename T::value_type>::to_pattern(),
          0,
          std::numeric_limits<unsigned int>::max(),
          internal::default_list_separator[internal::RankInfo<T>::list_rank -
                                           1]);
      }
 
      static std::string
      to_string(
        const T                     &t,
        const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
      {
        const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
        AssertThrow(p,
                    ExcMessage("I need a List pattern to convert a "
                               "string to a List type."));
        auto                     base_p = p->get_base_pattern().clone();
        std::vector<std::string> vec(t.size());
 
        std::transform(
          t.cbegin(), t.cend(), vec.begin(), [&base_p](const auto &entry) {
            return Convert<typename T::value_type>::to_string(entry, *base_p);
          });
 
        std::string s;
        if (vec.size() > 0)
          s = vec[0];
        for (unsigned int i = 1; i < vec.size(); ++i)
          s += p->get_separator() + " " + vec[i];
 
        AssertThrow(pattern.match(s), ExcNoMatch(s, p->description()));
        return s;
      }
 
      static T
      to_value(const std::string           &s,
               const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
      {
        AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
 
        const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
        AssertThrow(p,
                    ExcMessage("I need a List pattern to convert a string "
                               "to a List type."));
 
        auto base_p = p->get_base_pattern().clone();
        T    t;
 
        auto v = Utilities::split_string_list(s, p->get_separator());
        for (const auto &str : v)
          t.insert(t.end(),
                   Convert<typename T::value_type>::to_value(str, *base_p));
 
        return t;
      }
    };
 
    // stl maps
    template <class T>
    struct Convert<T, std::enable_if_t<is_map_compatible<T>::value>>
    {
      static std::unique_ptr<Patterns::PatternBase>
      to_pattern()
      {
        static_assert(internal::RankInfo<T>::list_rank > 0,
                      "Cannot use this class for non List-compatible types.");
        static_assert(internal::RankInfo<T>::map_rank > 0,
                      "Cannot use this class for non Map-compatible types.");
        return std::make_unique<Patterns::Map>(
          *Convert<typename T::key_type>::to_pattern(),
          *Convert<typename T::mapped_type>::to_pattern(),
          0,
          std::numeric_limits<unsigned int>::max(),
          internal::default_list_separator[internal::RankInfo<T>::list_rank -
                                           1],
          internal::default_map_separator[internal::RankInfo<T>::map_rank - 1]);
      }
 
      static std::string
      to_string(
        const T                     &t,
        const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
      {
        const auto *p = dynamic_cast<const Patterns::Map *>(&pattern);
        AssertThrow(p,
                    ExcMessage("I need a Map pattern to convert a string to "
                               "a Map compatible type."));
        auto                     key_p = p->get_key_pattern().clone();
        auto                     val_p = p->get_value_pattern().clone();
        std::vector<std::string> vec(t.size());
 
        unsigned int i = 0;
        for (const auto &ti : t)
          vec[i++] =
            Convert<typename T::key_type>::to_string(ti.first, *key_p) +
            p->get_key_value_separator() +
            Convert<typename T::mapped_type>::to_string(ti.second, *val_p);
 
        std::string s;
        if (vec.size() > 0)
          s = vec[0];
        for (unsigned int i = 1; i < vec.size(); ++i)
          s += p->get_separator() + " " + vec[i];
 
        AssertThrow(p->match(s), ExcNoMatch(s, p->description()));
        return s;
      }
 
      static T
      to_value(const std::string           &s,
               const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
      {
        AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
 
        const auto *p = dynamic_cast<const Patterns::Map *>(&pattern);
        AssertThrow(p,
                    ExcMessage("I need a Map pattern to convert a "
                               "string to a Map compatible type."));
 
        auto key_p = p->get_key_pattern().clone();
        auto val_p = p->get_value_pattern().clone();
        T    t;
 
        auto v = Utilities::split_string_list(s, p->get_separator());
        for (const auto &str : v)
          {
            auto key_val =
              Utilities::split_string_list(str, p->get_key_value_separator());
            AssertDimension(key_val.size(), 2);
            t.insert(std::make_pair(
              Convert<typename T::key_type>::to_value(key_val[0], *key_p),
              Convert<typename T::mapped_type>::to_value(key_val[1], *val_p)));
          }
 
        return t;
      }
    };
 
    // std::array
    template <typename ValueType, std::size_t N>
    struct Convert<std::array<ValueType, N>>
    {
      using T = std::array<ValueType, N>;
 
      static std::unique_ptr<Patterns::PatternBase>
      to_pattern()
      {
        static_assert(internal::RankInfo<T>::list_rank > 0,
                      "Cannot use this class for non List-compatible types.");
        return std::make_unique<Patterns::List>(
          *Convert<typename T::value_type>::to_pattern(),
          N,
          N,
          internal::default_list_separator[internal::RankInfo<T>::list_rank -
                                           1]);
      }
 
      static std::string
      to_string(
        const T                     &t,
        const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
      {
        const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
        AssertThrow(p,
                    ExcMessage("I need a List pattern to convert a "
                               "string to a std::array."));
        auto                     base_p = p->get_base_pattern().clone();
        std::vector<std::string> vec(t.size());
 
        std::transform(
          t.cbegin(), t.cend(), vec.begin(), [&base_p](const auto &entry) {
            return Convert<typename T::value_type>::to_string(entry, *base_p);
          });
 
        std::string s;
        if (vec.size() > 0)
          s = vec[0];
        for (unsigned int i = 1; i < vec.size(); ++i)
          s += p->get_separator() + " " + vec[i];
 
        AssertThrow(pattern.match(s), ExcNoMatch(s, p->description()));
        return s;
      }
 
      static T
      to_value(const std::string           &s,
               const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
      {
        AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
 
        const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
        AssertThrow(p,
                    ExcMessage("I need a List pattern to convert a string "
                               "to a std::array."));
 
        auto base_p = p->get_base_pattern().clone();
        T    t;
 
        auto v = Utilities::split_string_list(s, p->get_separator());
        AssertDimension(v.size(), N);
        for (unsigned int i = 0; i < N; ++i)
          t[i] = Convert<typename T::value_type>::to_value(v[i], *base_p);
        return t;
      }
    };
 
    // Tensors
    template <int rank, int dim, class Number>
    struct Convert<Tensor<rank, dim, Number>>
    {
      using T = Tensor<rank, dim, Number>;
      static std::unique_ptr<Patterns::PatternBase>
      to_pattern()
      {
        static_assert(internal::RankInfo<T>::list_rank > 0,
                      "Cannot use this class for non List-compatible types.");
        return std::make_unique<Patterns::List>(
          *Convert<typename T::value_type>::to_pattern(),
          dim,
          dim,
          internal::default_list_separator[internal::RankInfo<T>::list_rank -
                                           1]);
      }
 
      static std::string
      to_string(
        const T                     &t,
        const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
      {
        const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
        AssertThrow(p,
                    ExcMessage("I need a List pattern to convert a string "
                               "to a List compatible type."));
        auto                     base_p = p->get_base_pattern().clone();
        std::vector<std::string> vec(dim);
 
        for (unsigned int i = 0; i < dim; ++i)
          vec[i] = Convert<typename T::value_type>::to_string(t[i], *base_p);
 
        std::string s;
        if (vec.size() > 0)
          s = vec[0];
        for (unsigned int i = 1; i < vec.size(); ++i)
          s += p->get_separator() + " " + vec[i];
 
        AssertThrow(p->match(s), ExcNoMatch(s, p->description()));
        return s;
      }
 
      static T
      to_value(const std::string           &s,
               const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
      {
        AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
 
        const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
        AssertThrow(p,
                    ExcMessage("I need a List pattern to convert a string "
                               "to a List compatible type."));
 
        auto base_p = p->get_base_pattern().clone();
        T    t;
 
        auto         v = Utilities::split_string_list(s, p->get_separator());
        unsigned int i = 0;
        for (const auto &str : v)
          t[i++] = Convert<typename T::value_type>::to_value(str, *base_p);
 
        return t;
      }
    };
 
    // Points
    template <int dim, class Number>
    struct Convert<Point<dim, Number>>
    {
      using T = Point<dim, Number>;
 
      static std::unique_ptr<Patterns::PatternBase>
      to_pattern()
      {
        return Convert<Tensor<1, dim, Number>>::to_pattern();
      }
 
      static std::string
      to_string(
        const T                     &t,
        const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
      {
        return Convert<Tensor<1, dim, Number>>::to_string(
          Tensor<1, dim, Number>(t), pattern);
      }
 
      static T
      to_value(const std::string           &s,
               const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
      {
        return T(Convert<Tensor<1, dim, Number>>::to_value(s, pattern));
      }
    };
 
    // Functions::FunctionParser
    template <int dim>
    struct Convert<std::unique_ptr<FunctionParser<dim>>>
    {
      using T = std::unique_ptr<FunctionParser<dim>>;
 
      static std::unique_ptr<Patterns::PatternBase>
      to_pattern()
      {
        static_assert(internal::RankInfo<T>::list_rank > 0,
                      "Cannot use this class for non List-compatible types.");
 
        return std::make_unique<Patterns::List>(
          Patterns::Anything(),
          1,
          Patterns::List::max_int_value,
          internal::default_list_separator[internal::RankInfo<T>::list_rank -
                                           1]);
      }
 
      static std::string
      to_string(
        const T                     &t,
        const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
      {
        const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
        AssertThrow(p,
                    ExcMessage("I need a List pattern to convert a string "
                               "to a List compatible type."));
 
        const auto &expressions = t->get_expressions();
        if (expressions.empty())
          return std::string();
 
        std::string s = expressions[0];
        for (unsigned int i = 1; i < expressions.size(); ++i)
          s = s + p->get_separator() + expressions[i];
 
        AssertThrow(pattern.match(s), ExcNoMatch(s, p->description()));
        return s;
      }
 
      static T
      to_value(const std::string           &s,
               const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
      {
        AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
 
        const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
        AssertThrow(p,
                    ExcMessage("I need a List pattern to convert a string "
                               "to a List compatible type."));
 
        const auto expressions =
          Utilities::split_string_list(s, p->get_separator());
 
        T t = std::make_unique<FunctionParser<dim>>(expressions.size());
        const std::string var =
          FunctionParser<dim>::default_variable_names() + ",t";
        const typename FunctionParser<dim>::ConstMap constants;
        t->initialize(var, expressions, constants, true);
        return t;
      }
    };
 
    // ComponentMask
    template <>
    struct Convert<ComponentMask>
    {
      using T = ComponentMask;
 
      static std::unique_ptr<Patterns::PatternBase>
      to_pattern()
      {
        return Convert<std::vector<bool>>::to_pattern();
      }
 
      static std::string
      to_string(
        const T                     &t,
        const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
      {
        std::vector<bool> mask(t.size());
        for (unsigned int i = 0; i < t.size(); ++i)
          mask[i] = t[i];
 
        return Convert<std::vector<bool>>::to_string(mask, pattern);
      }
 
      static T
      to_value(const std::string           &s,
               const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
      {
        const auto mask = Convert<std::vector<bool>>::to_value(s, pattern);
        return ComponentMask(mask);
      }
    };
 
    // Complex numbers
    template <class Number>
    struct Convert<std::complex<Number>>
    {
      using T = std::complex<Number>;
 
      static std::unique_ptr<Patterns::PatternBase>
      to_pattern()
      {
        static_assert(internal::RankInfo<T>::list_rank > 0,
                      "Cannot use this class for non List-compatible types.");
        return std::make_unique<Patterns::List>(
          *Convert<typename T::value_type>::to_pattern(),
          2,
          2,
          internal::default_list_separator[internal::RankInfo<T>::list_rank -
                                           1]);
      }
 
      static std::string
      to_string(
        const T                     &t,
        const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
      {
        const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
        AssertThrow(p,
                    ExcMessage("I need a List pattern to convert a string "
                               "to a List compatible type."));
 
        auto        base_p = p->get_base_pattern().clone();
        std::string s =
          Convert<typename T::value_type>::to_string(t.real(), *base_p) +
          p->get_separator() + " " +
          Convert<typename T::value_type>::to_string(t.imag(), *base_p);
 
        AssertThrow(pattern.match(s), ExcNoMatch(s, p->description()));
        return s;
      }
 
      static T
      to_value(const std::string           &s,
               const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
      {
        AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
 
        const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
        AssertThrow(p,
                    ExcMessage("I need a List pattern to convert a string "
                               "to a List compatible type."));
 
        auto base_p = p->get_base_pattern().clone();
 
        auto v = Utilities::split_string_list(s, p->get_separator());
        AssertDimension(v.size(), 2);
        T t(Convert<typename T::value_type>::to_value(v[0], *base_p),
            Convert<typename T::value_type>::to_value(v[1], *base_p));
        return t;
      }
    };
 
    // Strings
    template <>
    struct Convert<std::string>
    {
      using T = std::string;
 
      static std::unique_ptr<Patterns::PatternBase>
      to_pattern()
      {
        return std::make_unique<Patterns::Anything>();
      }
 
      static std::string
      to_string(
        const T                     &t,
        const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
      {
        AssertThrow(pattern.match(t), ExcNoMatch(t, pattern.description()));
        return t;
      }
 
      static T
      to_value(const std::string           &s,
               const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
      {
        AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
        return s;
      }
    };
 
    // Pairs
    template <class Key, class Value>
    struct Convert<std::pair<Key, Value>>
    {
      using T = std::pair<Key, Value>;
 
      static std::unique_ptr<Patterns::PatternBase>
      to_pattern()
      {
        static_assert(internal::RankInfo<T>::map_rank > 0,
                      "Cannot use this class for non Map-compatible types.");
        return std::make_unique<Patterns::Tuple>(
          internal::default_map_separator[internal::RankInfo<T>::map_rank - 1],
          *Convert<Key>::to_pattern(),
          *Convert<Value>::to_pattern());
      }
 
      static std::string
      to_string(
        const T                     &t,
        const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
      {
        std::tuple<Key, Value> m(t);
        std::string            s = Convert<decltype(m)>::to_string(m, pattern);
        AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
        return s;
      }
 
      static T
      to_value(const std::string           &s,
               const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
      {
        std::tuple<Key, Value> m;
        m = Convert<decltype(m)>::to_value(s, pattern);
        return std::make_pair(std::get<0>(m), std::get<1>(m));
      }
    };
 
    // Tuples
    template <class... Args>
    struct Convert<std::tuple<Args...>>
    {
      using T = std::tuple<Args...>;
 
      static std::unique_ptr<Patterns::PatternBase>
      to_pattern()
      {
        static_assert(internal::RankInfo<T>::map_rank > 0,
                      "Cannot use this class for non tuple-compatible types.");
        return std::make_unique<Patterns::Tuple>(
          internal::default_map_separator[internal::RankInfo<T>::map_rank - 1],
          *Convert<Args>::to_pattern()...);
      }
 
      static std::string
      to_string(
        const T                     &t,
        const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
      {
        const auto *p = dynamic_cast<const Patterns::Tuple *>(&pattern);
        AssertThrow(p,
                    ExcMessage("I need a Tuple pattern to convert a tuple "
                               "to a string."));
 
        const auto  string_array = Convert<T>::to_string_internal_2(t, *p);
        std::string str;
        for (unsigned int i = 0; i < string_array.size(); ++i)
          str +=
            (i != 0u ? " " + p->get_separator() + " " : "") + string_array[i];
        AssertThrow(p->match(str), ExcNoMatch(str, p->description()));
        return str;
      }
 
      static T
      to_value(const std::string           &s,
               const Patterns::PatternBase &pattern = *Convert<T>::to_pattern())
      {
        AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
 
        const auto *p = dynamic_cast<const Patterns::Tuple *>(&pattern);
        AssertThrow(p,
                    ExcMessage("I need a Tuple pattern to convert a string "
                               "to a tuple type."));
 
        auto v = Utilities::split_string_list(s, p->get_separator());
 
        return Convert<T>::to_value_internal_2(v, *p);
      }
 
    private:
      template <std::size_t... U>
      static std::array<std::string, std::tuple_size<T>::value>
      to_string_internal_1(const T               &t,
                           const Patterns::Tuple &pattern,
                           std::index_sequence<U...>)
      {
        std::array<std::string, std::tuple_size<T>::value> a = {
          {Convert<typename std::tuple_element<U, T>::type>::to_string(
            std::get<U>(t), pattern.get_pattern(U))...}};
        return a;
      }
 
      static std::array<std::string, std::tuple_size<T>::value>
      to_string_internal_2(const T &t, const Patterns::Tuple &pattern)
      {
        return Convert<T>::to_string_internal_1(
          t, pattern, std::make_index_sequence<std::tuple_size<T>::value>{});
      }
 
      template <std::size_t... U>
      static T
      to_value_internal_1(const std::vector<std::string> &s,
                          const Patterns::Tuple          &pattern,
                          std::index_sequence<U...>)
      {
        return std::make_tuple(
          Convert<typename std::tuple_element<U, T>::type>::to_value(
            s[U], pattern.get_pattern(U))...);
      }
 
      static T
      to_value_internal_2(const std::vector<std::string> &s,
                          const Patterns::Tuple          &pattern)
      {
        return Convert<T>::to_value_internal_1(
          s, pattern, std::make_index_sequence<std::tuple_size<T>::value>{});
      }
    };
 
#ifdef DEAL_II_WITH_MAGIC_ENUM
    // Enums
    template <class T>
    struct Convert<T, typename std::enable_if<std::is_enum<T>::value>::type>
    {
      static std::unique_ptr<Patterns::PatternBase>
      to_pattern()
      {
        const auto               n     = magic_enum::enum_names<T>();
        std::vector<std::string> names = {n.begin(), n.end()};
        const auto               selection =
          Patterns::Tools::Convert<decltype(names)>::to_string(
            names,
            Patterns::List(
              Patterns::Anything(), names.size(), names.size(), "|"));
        // Allow parsing a list of enums, and make bitwise or between them
        return Patterns::List(Patterns::Selection(selection),
                              0,
                              names.size(),
                              "|")
          .clone();
      }
 
      static std::string
      to_string(const T                     &value,
                const Patterns::PatternBase &p = *Convert<T>::to_pattern())
      {
        const auto               values = magic_enum::enum_values<T>();
        std::vector<std::string> names;
        for (const auto &v : values)
          if (magic_enum::bitwise_operators::operator&(value, v) == v)
            names.push_back(std::string(magic_enum::enum_name(v)));
        return Patterns::Tools::Convert<decltype(names)>::to_string(names, p);
      }
 
      static T
      to_value(const std::string                   &s,
               const ::Patterns::PatternBase &p = *to_pattern())
      {
        // Make sure we have a valid enum value, or empty value
        AssertThrow(p.match(s), ExcNoMatch(s, p.description()));
        T                        value = T();
        std::vector<std::string> value_names;
        value_names =
          Patterns::Tools::Convert<decltype(value_names)>::to_value(s, p);
        for (const auto &name : value_names)
          {
            auto v = magic_enum::enum_cast<T>(name);
            if (v.has_value())
              value =
                magic_enum::bitwise_operators::operator|(value, v.value());
          }
        return value;
      }
    };
#endif
 
    // Utility function with default Pattern
    template <typename T>
    std::string
    to_string(const T &t)
    {
      return Convert<T>::to_string(t);
    }
 
    // Utility function with default Pattern
    template <typename T>
    void
    to_value(const std::string &s, T &t)
    {
      t = Convert<T>::to_value(s);
    }
  } // namespace Tools
} // namespace Patterns
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif