Patterns::Tuple Class Reference

#include <deal.II/base/patterns.h>

Inheritance diagram for Patterns::Tuple:

Public Types
enum	OutputStyle { Machine , Text , LaTeX }

Public Member Functions
	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
std::size_t	memory_consumption () const override
const PatternBase &	get_pattern (const unsigned int i) const
const std::string &	get_separator () const
template<class... PatternTypes>
	Tuple (const PatternTypes &...ps)

Static Public Member Functions
static std::unique_ptr< Tuple >	create (const std::string &description)

Private Attributes
std::vector< std::unique_ptr< PatternBase > >	patterns
const std::string	separator

Static Private Attributes
static const char *	description_init = "[Tuple"

Detailed Description

This pattern matches colon-separated values of arbitrary types. Each type has to match a pattern given to the constructor.

An example usage is the following:

std::vector< std::unique_ptr<Patterns::PatternBase> > ps;
 
ps.push_back(std::unique_ptr<Patterns::Integer>());
ps.push_back(std::unique_ptr<Patterns::Double>());
ps.push_back(std::unique_ptr<Patterns::Anything>());
 
Patterns::Tuple pattern(ps, ":");
 
bool check = ps.match("5 : 3.14 : Ciao"); // check = true

or, if you want to exploit ParameterHandler::add_parameter():

using T = std::tuple<std::string, Point<3>, unsigned int>;
 
T a = Patterns::Tools::Convert<T>::to_value("Ciao : 1.0, 2.0, 3.0 : 33");
 
ParameterHandler prm;
prm.add_parameter("A tuple", a);
 
prm.log_parameters(deallog);
// DEAL:parameters::A tuple: Ciao : 1.000000, 2.000000, 3.000000 : 33
 
prm.set("A tuple", "Mondo : 2.0, 3.0, 4.0 : 34");
prm.log_parameters(deallog);
// DEAL:parameters::A tuple: Mondo : 2.0, 3.0, 4.0 : 34
 
deallog << Patterns::Tools::Convert<T>::to_string(a) << std::endl;
// DEAL::Mondo : 2.000000, 3.000000, 4.000000 : 34

The constructor expects a vector of Patterns, and optionally a string specifying the separator to use when parsing the Tuple from a string.

The default separator is a colon, owing to the fact that a pair is in fact a tuple with two elements.

Definition at line 771 of file patterns.h.

Member Enumeration Documentation

OutputStyle

enum Patterns::PatternBase::OutputStyle

inherited

List of possible description output formats.

Capitalization chosen for similarity to ParameterHandler::OutputStyle.

Enumerator
Machine	Simple text suitable for machine parsing in the static public member functions for all of the built in inheriting classes. Preferably human readable, but machine parsing is more critical.
Text	Easily human readable plain text format suitable for plain text documentation.
LaTeX	Easily human readable LaTeX format suitable for printing in manuals.

Definition at line 98 of file patterns.h.

---

The documentation for this class was generated from the following files:

• include/deal.II/base/patterns.h
• source/base/patterns.cc