 Reference documentation for deal.II version 9.4.0
Patterns::Tools Namespace Reference

## Namespaces

namespace  internal

## Classes

struct  Convert

struct  Convert< Point< dim, Number > >

struct  Convert< std::array< ValueType, N > >

struct  Convert< std::complex< Number > >

struct  Convert< std::pair< Key, Value > >

struct  Convert< std::string >

struct  Convert< std::tuple< Args... > >

struct  Convert< std::unique_ptr< FunctionParser< dim > > >

struct  Convert< T, typename std::enable_if< is_list_compatible< T >::value >::type >

struct  Convert< T, typename std::enable_if< is_map_compatible< T >::value >::type >

struct  Convert< T, typename std::enable_if< std::is_arithmetic< T >::value >::type >

struct  Convert< Tensor< rank, dim, Number > >

struct  Convert< VectorTools::NormType, void >

struct  is_list_compatible

struct  is_map_compatible

## Functions

template<typename T >
std::string to_string (const T &t)

template<typename T >
void to_value (const std::string &s, T &t)

static ::ExceptionBaseExcNoMatch (std::string arg1, std::string arg2)

## Detailed Description

Namespace for a few classes and functions that act on values and patterns, and allow to convert from non elementary types to strings and vice versa.

A typical usage of these tools is in the following example:

using T = std::vector<unsigned int>;
T vec(3);
vec = 1;
vec = 3;
vec = 5;
std::cout << pattern->description() << std::endl;
// [List of <[Integer]> of length 0...4294967295 (inclusive)]
std::cout << s << std::endl;
// 1, 2, 3
// now vec has size 4, and contains the elements 2,3,4,5
std::cout << internal::RankInfo<T>::list_rank << std::endl; // Outputs 1
std::cout << internal::RankInfo<T>::map_rank << std::endl; // Outputs 0
static std::unique_ptr< Patterns::PatternBase > to_pattern()=delete
static T to_value(const std::string &s, const Patterns::PatternBase &p= *Convert< T >::to_pattern())=delete
static std::string to_string(const T &s, const Patterns::PatternBase &p= *Convert< T >::to_pattern())=delete
static const char T

Convert<T> is used by the function Patterns::Tools::add_parameter() in this namespace. Internally it uses the internal::RankInfo<T> class to decide how many different separators are required to convert the given type to a string.

For example, to write vectors of vectors, the default is to use "," for the first (inner) separator, and ";" for the second (outer) separator, i.e.

std::vector<std::vector<unsigned int>> vec;
vec = Convert<decltype(vec)>::to_value("1,2,3 ; 4,5,6");
s = convert<decltype(vec)>::to_string(vec);
// s now contains the string "1,2,3"
void to_value(const std::string &s, T &t)
Definition: patterns.h:2411
std::string to_string(const T &t)
Definition: patterns.h:2403

Separators for Patterns::List and Patterns::Map compatible types are selected according to the rank of the list and map objects, using the arrays Patterns::Tools::internal::default_list_separator and Patterns::Tools::internal::default_map_separator.

They are currently set to:

default_list_separator{{"," , ";" , "|" , "%"}};
default_map_separator {{":" , "=" , "@" , "#"}};
constexpr std::array< const char *, 4 > default_map_separator
Definition: patterns.h:1580
constexpr std::array< const char *, 4 > default_list_separator
Definition: patterns.h:1578

When one needs a mixture of Patterns::List and Patterns::Map types, their RankInfo is computed by taking the maximum of the vector_rank of the Key and of the Value type, so that, for example, it is possible to have the following

... // Build compare class
std::map<std::vector<unsigned int>, std::vector<double>, compare> map;
map = convert<decltype(map)>::to_value(
"1,2,3 : 5.0,6.0,7.0 ; 8,9,10 : 11.0,12.0,13.0");

Some non elementary types are supported, like Point(), or std::complex<double>. If you wish to support more types, you have to specialize the Convert struct as well as the RankInfo struct.