patterns.h

// ---------------------------------------------------------------------
//
// Copyright (C) 1998 - 2018 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#ifndef dealii_patterns_h
#define dealii_patterns_h


#include <deal.II/base/config.h>
#include <deal.II/base/exceptions.h>
#include <deal.II/base/subscriptor.h>
#include <deal.II/base/point.h>
#include <deal.II/base/subscriptor.h>
#include <deal.II/base/utilities.h>
#include <deal.II/base/template_constraints.h>

#include <deal.II/base/std_cxx14/memory.h>
#include <deal.II/base/std_cxx14/algorithm.h>
#include <deal.II/base/std_cxx14/utility.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 <array>
#include <deque>
#include <list>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

DEAL_II_NAMESPACE_OPEN

// forward declarations for interfaces and friendship
class LogStream;
class MultipleParameterLoop;

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);

  }

  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;

    virtual std::string description (const OutputStyle style=Machine) const;

    virtual std::unique_ptr<PatternBase> clone () const;

    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;

    virtual std::string description (const OutputStyle style=Machine) const;

    virtual std::unique_ptr<PatternBase> clone () const;

    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;

    virtual std::string description (const OutputStyle style=Machine) const;

    virtual std::unique_ptr<PatternBase> clone () const;

    std::size_t memory_consumption () const;

    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;

    virtual std::string description (const OutputStyle style=Machine) const;

    virtual std::unique_ptr<PatternBase> clone () const;

    static std::unique_ptr<List> create (const std::string &description);

    std::size_t memory_consumption () const;

    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;

    virtual std::string description (const OutputStyle style=Machine) const;

    virtual std::unique_ptr<PatternBase> clone () const;

    static std::unique_ptr<Map> create (const std::string &description);

    std::size_t memory_consumption () const;

    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;

    virtual std::string description (const OutputStyle style=Machine) const;

    virtual std::unique_ptr<PatternBase> clone () const;

    static std::unique_ptr<Tuple> create (const std::string &description);

    std::size_t memory_consumption () const;

    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;

    virtual std::string description (const OutputStyle style=Machine) const;

    virtual std::unique_ptr<PatternBase> clone () const;

    static std::unique_ptr<MultipleSelection> create (const std::string &description);

    std::size_t memory_consumption () const;

    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;

    virtual std::unique_ptr<PatternBase> clone () const;

    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;

    virtual std::string description (const OutputStyle style=Machine) const;

    virtual std::unique_ptr<PatternBase> clone () const;

    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;

    virtual std::string description (const OutputStyle style=Machine) const;

    virtual std::unique_ptr<PatternBase> clone () const;

    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;

    virtual std::string description (const OutputStyle style=Machine) const;

    virtual std::unique_ptr<PatternBase> clone () const;

    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 std::unique_ptr<Patterns::PatternBase>
                                   &p = Convert<T>::to_pattern()) = delete;

      static T to_value(const std::string &s,
                        const std::unique_ptr<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,
                   Patterns::PatternBase &,
                   << "The string " << arg1 << " does not match the pattern \""
                   << arg2.description()
                   << "\"");
  }
}


// ---------------------- 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!");
    auto pattern_pointers = { (static_cast<const PatternBase *>(&ps))... };
    for (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 (std::string(":"), 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;
      };
    }

    // Arithmetic types
    template <class T>
    struct Convert<T, typename std::enable_if<std::is_arithmetic<T>::value>::type>
    {

      static std::unique_ptr<Patterns::PatternBase> to_pattern()
      {
        if (std::is_same<T,bool>::value)
          return std_cxx14::make_unique<Patterns::Bool>();
        else if (std::is_integral<T>::value)
          return std_cxx14::make_unique<Patterns::Integer>(
                   std::numeric_limits<T>::min(), std::numeric_limits<T>::max());
        else if (std::is_floating_point<T>::value)
          return std_cxx14::make_unique<Patterns::Double>(
                   -std::numeric_limits<T>::max(), std::numeric_limits<T>::max());

        Assert(false, ExcNotImplemented());
        //the following line should never be invoked
        return nullptr;
      }

      static std::string to_string(const T &value,
                                   const std::unique_ptr<Patterns::PatternBase>
                                   &p = Convert<T>::to_pattern())
      {
        std::stringstream str;
        if (std::is_same<T, unsigned char>::value ||
            std::is_same<T, signed char>::value   ||
            std::is_same<T, char>::value)
          str << (int)value;
        else  if (std::is_same<T,bool>::value)
          str << (value ? "true" : "false");
        else
          str << value;
        AssertThrow(p->match(str.str()), ExcNoMatch(str.str(), *p));
        return str.str();
      }

      static T to_value(const std::string &s,
                        const std::unique_ptr<Patterns::PatternBase> &p =
                          Convert<T>::to_pattern())
      {
        AssertThrow(p->match(s), ExcNoMatch(s, *p));
        T value;
        if (std::is_same<T,bool>::value)
          value = (s == "true");
        else
          {
            std::istringstream is(s);
            if (std::is_same<T, unsigned char>::value ||
                std::is_same<T, signed char>::value   ||
                std::is_same<T, char>::value)
              {
                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
    {
      const std::array<std::string, 4> default_list_separator {{","  ,  ";"  ,  "|"  ,   "%"}};
      const std::array<std::string, 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 T, std::size_t N> struct is_list_compatible<std::array    <T,N>>     : std::true_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 {};
    }

    // type trait to use the implementation type traits as well as decay the type
    template <typename T>
    struct is_list_compatible
    {
      static constexpr bool const value =
        internal::is_list_compatible<typename std::decay<T>::type>::value;
    };

    template <typename T>
    struct is_map_compatible
    {
      static constexpr bool const value =
        internal::is_map_compatible<typename std::decay<T>::type>::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_cxx14::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_cxx14::max(RankInfo<T1>::map_rank,
                              max_map_rank<T2,Types...>());
      }

      // Rank of vector types
      template <class T>
      struct RankInfo<T,
        typename std::enable_if<is_list_compatible<T>::value>::type>
      {
        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, typename std::enable_if<is_map_compatible<T>::value>::type>
      {
        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;
      };

      template <class Key, class Value>
      struct RankInfo<std::pair<Key,Value>>
      {
        static constexpr int list_rank = std_cxx14::max(RankInfo<Key>::list_rank, RankInfo<Value>::list_rank);
        static constexpr int map_rank = std_cxx14::max(RankInfo<Key>::map_rank, RankInfo<Value>::map_rank)+1;
      };


      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;
      };
    }

    // stl containers
    template <class T>
    struct Convert<T, typename std::enable_if<is_list_compatible<T>::value>::type>
    {
      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_cxx14::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 std::unique_ptr<Patterns::PatternBase>
                                   &pattern = Convert<T>::to_pattern())
      {
        auto p = dynamic_cast<const Patterns::List *>(pattern.get());
        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());

        unsigned int i = 0;
        for (const auto &ti : t)
          vec[i++] = Convert<typename T::value_type>::to_string(ti, 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));
        return s;
      }

      static T to_value(const std::string &s,
                        const std::unique_ptr<Patterns::PatternBase> &pattern =
                          Convert<T>::to_pattern())
      {

        AssertThrow(pattern->match(s), ExcNoMatch(s, *pattern));

        auto p = dynamic_cast<const Patterns::List *>(pattern.get());
        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, typename std::enable_if<is_map_compatible<T>::value>::type>
    {
      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_cxx14::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 std::unique_ptr<Patterns::PatternBase>
                                   &pattern = Convert<T>::to_pattern())
      {
        auto p = dynamic_cast<const Patterns::Map *>(pattern.get());
        AssertThrow(p, ExcMessage("I need a Map pattern to convert a string to "
                                  "a Map compatbile 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));
        return s;
      }

      static T to_value(const std::string &s,
                        const std::unique_ptr<Patterns::PatternBase> &pattern =
                          Convert<T>::to_pattern())
      {

        AssertThrow(pattern->match(s), ExcNoMatch(s, *pattern));

        auto p = dynamic_cast<const Patterns::Map *>(pattern.get());
        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])));
          }

        return t;
      }
    };

    // Tensors
    template <int rank, int dim, class Number>
    struct Convert<Tensor<rank, dim, Number>>
    {
      typedef Tensor<rank, dim, Number> T;
      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_cxx14::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 std::unique_ptr<Patterns::PatternBase>
                                   &pattern = Convert<T>::to_pattern())
      {

        auto p = dynamic_cast<const Patterns::List *>(pattern.get());
        AssertThrow(p,ExcMessage("I need a List pattern to convert a string "
                                 "to a List compatbile 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));
        return s;
      }

      static T to_value(const std::string &s,
                        const std::unique_ptr<Patterns::PatternBase> &pattern =
                          Convert<T>::to_pattern())
      {

        AssertThrow(pattern->match(s), ExcNoMatch(s, *pattern));

        auto p = dynamic_cast<const Patterns::List *>(pattern.get());
        AssertThrow(p,ExcMessage("I need a List pattern to convert a string "
                                 "to a List compatbile 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>>
    {

      typedef Point<dim, Number> T;

      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 std::unique_ptr<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 std::unique_ptr<Patterns::PatternBase> &pattern =
                          Convert<T>::to_pattern())
      {
        return T(Convert<Tensor<1, dim, Number>>::to_value(s, pattern));
      }
    };

    // Complex numbers
    template <class Number>
    struct Convert<std::complex<Number>>
    {
      typedef std::complex<Number> T;

      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_cxx14::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 std::unique_ptr<Patterns::PatternBase>
                                   &pattern = Convert<T>::to_pattern())
      {

        auto p = dynamic_cast<const Patterns::List *>(pattern.get());
        AssertThrow(p,ExcMessage("I need a List pattern to convert a string "
                                 "to a List compatbile 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));
        return s;
      }

      static T to_value(const std::string &s,
                        const std::unique_ptr<Patterns::PatternBase> &pattern =
                          Convert<T>::to_pattern())
      {

        AssertThrow(pattern->match(s), ExcNoMatch(s, *pattern));

        auto p = dynamic_cast<const Patterns::List *>(pattern.get());
        AssertThrow(p,ExcMessage("I need a List pattern to convert a string "
                                 "to a List compatbile 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>
    {
      typedef std::string T;

      static std::unique_ptr<Patterns::PatternBase> to_pattern()
      {
        return std_cxx14::make_unique<Patterns::Anything>();
      }

      static std::string to_string(const T &t,
                                   const std::unique_ptr<Patterns::PatternBase>
                                   &pattern = Convert<T>::to_pattern())
      {
        AssertThrow(pattern->match(t), ExcNoMatch(t, *pattern));
        return t;
      }

      static T to_value(const std::string &s,
                        const std::unique_ptr<Patterns::PatternBase> &pattern =
                          Convert<T>::to_pattern())
      {
        AssertThrow(pattern->match(s), ExcNoMatch(s, *pattern));
        return s;
      }
    };

    // Pairs
    template <class Key, class Value>
    struct Convert<std::pair<Key,Value>>
    {
      typedef std::pair<Key,Value> T;

      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_cxx14::make_unique<Patterns::Map>(
                 *Convert<Key>::to_pattern(),
                 *Convert<Value>::to_pattern(),
                 1, 1,
                 // We keep the same list separator of the previous level, as this is
                 // a map with only 1 possible entry
                 internal::default_list_separator[internal::RankInfo<T>::list_rank],
                 internal::default_map_separator[internal::RankInfo<T>::map_rank - 1]);
      }

      static std::string to_string(const T &t,
                                   const std::unique_ptr<Patterns::PatternBase>
                                   &pattern = Convert<T>::to_pattern())
      {
        std::unordered_map<Key, Value> m;
        m.insert(t);
        std:: string s = Convert<decltype(m)>::to_string(m, pattern);
        AssertThrow(pattern->match(s), ExcNoMatch(s, *pattern));
        return s;
      }

      static T to_value(const std::string &s,
                        const std::unique_ptr<Patterns::PatternBase> &pattern =
                          Convert<T>::to_pattern())
      {
        std::unordered_map<Key, Value> m;
        m = Convert<decltype(m)>::to_value(s, pattern);
        return *m.begin();
      }
    };

    // Tuples
    template <class... Args>
    struct Convert<std::tuple<Args...>>
    {
      typedef std::tuple<Args...> T;

      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_cxx14::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 std::unique_ptr<Patterns::PatternBase>
                                   &pattern = Convert<T>::to_pattern())
      {
        auto p = dynamic_cast<const Patterns::Tuple *>(pattern.get());
        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 ? " " + p->get_separator() + " " : "") +string_array[i];
        AssertThrow(p->match(str), ExcNoMatch(str, *p));
        return str;
      }

      static T to_value(const std::string &s,
                        const std::unique_ptr<Patterns::PatternBase> &pattern =
                          Convert<T>::to_pattern())
      {
        AssertThrow(pattern->match(s), ExcNoMatch(s, *pattern));

        auto p = dynamic_cast<const Patterns::Tuple *>(pattern.get());
        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... I>
      static
      std::array<std::string, std::tuple_size<T>::value>
      to_string_internal_1(const T &t,
                           const Patterns::Tuple &pattern,
                           std_cxx14::index_sequence<I...>)
      {
        std::array<std::string, std::tuple_size<T>::value> a
        = {{
            Convert<typename std::tuple_element<I,T>::type>::
            to_string(std::get<I>(t), pattern.get_pattern(I).clone())...
          }
        };
        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_cxx14::make_index_sequence<std::tuple_size<T>::value> {});
      }

      template<std::size_t... I>
      static
      T to_value_internal_1(const std::vector<std::string> &s,
                            const Patterns::Tuple &pattern,
                            std_cxx14::index_sequence<I...>)
      {
        return std::make_tuple(Convert<typename std::tuple_element<I,T>::type>::
                               to_value(s[I], pattern.get_pattern(I).clone())...);
      }

      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_cxx14::make_index_sequence<std::tuple_size<T>::value> {});
      }
    };

    // 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);
    }
  }
}


DEAL_II_NAMESPACE_CLOSE

#endif