Loading [MathJax]/extensions/TeX/AMSsymbols.js
 deal.II version GIT relicensing-2846-g6fb608615f 2025-03-15 04:10:00+00:00
\(\newcommand{\dealvcentcolon}{\mathrel{\mathop{:}}}\) \(\newcommand{\dealcoloneq}{\dealvcentcolon\mathrel{\mkern-1.2mu}=}\) \(\newcommand{\jump}[1]{\left[\!\left[ #1 \right]\!\right]}\) \(\newcommand{\average}[1]{\left\{\!\left\{ #1 \right\}\!\right\}}\)
All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages Concepts
patterns.h
Go to the documentation of this file.
1// ------------------------------------------------------------------------
2//
3// SPDX-License-Identifier: LGPL-2.1-or-later
4// Copyright (C) 2017 - 2023 by the deal.II authors
5//
6// This file is part of the deal.II library.
7//
8// Part of the source code is dual licensed under Apache-2.0 WITH
9// LLVM-exception OR LGPL-2.1-or-later. Detailed license information
10// governing the source code and code contributions can be found in
11// LICENSE.md and CONTRIBUTING.md at the top level directory of deal.II.
12//
13// ------------------------------------------------------------------------
14
15#ifndef dealii_patterns_h
16#define dealii_patterns_h
17
18
19#include <deal.II/base/config.h>
20
23#include <deal.II/base/point.h>
25#include <deal.II/base/tensor.h>
27
29
30#include <boost/archive/basic_archive.hpp>
31#include <boost/core/demangle.hpp>
32#include <boost/property_tree/ptree_fwd.hpp>
33#include <boost/property_tree/ptree_serialization.hpp>
34#include <boost/serialization/split_member.hpp>
35
36#include <algorithm>
37#include <array>
38#include <deque>
39#include <limits>
40#include <list>
41#include <map>
42#include <memory>
43#include <set>
44#include <sstream>
45#include <string>
46#include <type_traits>
47#include <unordered_map>
48#include <unordered_set>
49#include <utility>
50#include <vector>
51
52#ifdef DEAL_II_WITH_MAGIC_ENUM
53# include <magic_enum.hpp>
54#endif
55
57
58// forward declarations for interfaces and friendship
59#ifndef DOXYGEN
60class LogStream;
62template <int dim>
63class FunctionParser;
64#endif
65
74namespace Patterns
75{
83 {
84 public:
88 virtual ~PatternBase() = default;
89
93 virtual bool
94 match(const std::string &test_string) const = 0;
95
120
124 virtual std::string
125 description(const OutputStyle style = Machine) const = 0;
126
136 virtual std::unique_ptr<PatternBase>
137 clone() const = 0;
138
154 virtual std::size_t
155 memory_consumption() const;
156 };
157
161 std::unique_ptr<PatternBase>
162 pattern_factory(const std::string &description);
163
164 namespace internal
165 {
171 std::string
172 escape(const std::string &input, const PatternBase::OutputStyle style);
173
174 } // namespace internal
175
192 class Integer : public PatternBase
193 {
194 public:
200 static const int min_int_value;
201
207 static const int max_int_value;
208
222 const int upper_bound = max_int_value);
223
228 virtual bool
229 match(const std::string &test_string) const override;
230
236 virtual std::string
237 description(const OutputStyle style = Machine) const override;
238
244 virtual std::unique_ptr<PatternBase>
245 clone() const override;
246
252 static std::unique_ptr<Integer>
253 create(const std::string &description);
254
255 private:
262 const int lower_bound;
263
270 const int upper_bound;
271
275 static const char *description_init;
276 };
277
295 class Double : public PatternBase
296 {
297 public:
302 static const double min_double_value;
303
308 static const double max_double_value;
309
317 Double(const double lower_bound = min_double_value,
318 const double upper_bound = max_double_value);
319
324 virtual bool
325 match(const std::string &test_string) const override;
326
332 virtual std::string
333 description(const OutputStyle style = Machine) const override;
334
340 virtual std::unique_ptr<PatternBase>
341 clone() const override;
342
350 static std::unique_ptr<Double>
351 create(const std::string &description);
352
353 private:
360 const double lower_bound;
361
368 const double upper_bound;
369
373 static const char *description_init;
374 };
375
385 class Selection : public PatternBase
386 {
387 public:
392 Selection(const std::string &seq);
393
398 virtual bool
399 match(const std::string &test_string) const override;
400
406 virtual std::string
407 description(const OutputStyle style = Machine) const override;
408
414 virtual std::unique_ptr<PatternBase>
415 clone() const override;
416
421 std::size_t
422 memory_consumption() const override;
423
429 static std::unique_ptr<Selection>
430 create(const std::string &description);
431
432 private:
437 std::string sequence;
438
442 static const char *description_init;
443 };
444
445
453 class List : public PatternBase
454 {
455 public:
461 static const unsigned int max_int_value;
462
471 List(const PatternBase &base_pattern,
472 const unsigned int min_elements = 0,
473 const unsigned int max_elements = max_int_value,
474 const std::string &separator = ",");
475
476
480 const std::string &
481 get_separator() const;
482
486 const PatternBase &
487 get_base_pattern() const;
488
492 List(const List &other);
493
498 virtual bool
499 match(const std::string &test_string) const override;
500
505 virtual std::string
506 description(const OutputStyle style = Machine) const override;
507
513 virtual std::unique_ptr<PatternBase>
514 clone() const override;
515
521 static std::unique_ptr<List>
522 create(const std::string &description);
523
528 std::size_t
529 memory_consumption() const override;
530
540 int,
541 int,
542 << "The values " << arg1 << " and " << arg2
543 << " do not form a valid range.");
545 private:
549 std::unique_ptr<PatternBase> pattern;
550
554 const unsigned int min_elements;
555
559 const unsigned int max_elements;
560
564 const std::string separator;
565
569 static const char *description_init;
570 };
571
572
587 class Map : public PatternBase
588 {
589 public:
595 static const unsigned int max_int_value;
596
607 const unsigned int min_elements = 0,
608 const unsigned int max_elements = max_int_value,
609 const std::string &separator = ",",
610 const std::string &key_value_separator = ":");
611
615 Map(const Map &other);
616
621 virtual bool
622 match(const std::string &test_string) const override;
623
628 virtual std::string
629 description(const OutputStyle style = Machine) const override;
630
636 virtual std::unique_ptr<PatternBase>
637 clone() const override;
638
644 static std::unique_ptr<Map>
645 create(const std::string &description);
646
651 std::size_t
652 memory_consumption() const override;
653
657 const PatternBase &
658 get_key_pattern() const;
659
663 const PatternBase &
664 get_value_pattern() const;
665
669 const std::string &
670 get_separator() const;
671
675 const std::string &
677
687 int,
688 int,
689 << "The values " << arg1 << " and " << arg2
690 << " do not form a valid range.");
692 private:
697 std::unique_ptr<PatternBase> key_pattern;
698 std::unique_ptr<PatternBase> value_pattern;
699
703 const unsigned int min_elements;
704
708 const unsigned int max_elements;
709
713 const std::string separator;
714
715
719 const std::string key_value_separator;
720
724 static const char *description_init;
725 };
726
727
728
774 class Tuple : public PatternBase
775 {
776 public:
785 Tuple(const std::vector<std::unique_ptr<PatternBase>> &patterns,
786 const std::string &separator = ":");
787
793 Tuple(const std::vector<std::unique_ptr<PatternBase>> &patterns,
794 const char *separator);
795
796
804 template <class... PatternTypes>
805 Tuple(const std::string &separator, const PatternTypes &...patterns);
806
814 template <class... PatternTypes>
815 Tuple(const char *separator, const PatternTypes &...patterns);
816
822 template <typename... Patterns>
824
828 Tuple(const Tuple &other);
829
834 virtual bool
835 match(const std::string &test_string) const override;
836
841 virtual std::string
842 description(const OutputStyle style = Machine) const override;
843
849 virtual std::unique_ptr<PatternBase>
850 clone() const override;
851
857 static std::unique_ptr<Tuple>
858 create(const std::string &description);
859
864 std::size_t
865 memory_consumption() const override;
866
870 const PatternBase &
871 get_pattern(const unsigned int i) const;
872
876 const std::string &
877 get_separator() const;
878
879 private:
883 std::vector<std::unique_ptr<PatternBase>> patterns;
884
888 const std::string separator;
889
893 static const char *description_init;
894 };
895
896
908 {
909 public:
913 MultipleSelection(const std::string &seq);
914
919 virtual bool
920 match(const std::string &test_string) const override;
921
927 virtual std::string
928 description(const OutputStyle style = Machine) const override;
929
935 virtual std::unique_ptr<PatternBase>
936 clone() const override;
937
943 static std::unique_ptr<MultipleSelection>
944 create(const std::string &description);
945
950 std::size_t
951 memory_consumption() const override;
952
963 int,
964 << "A comma was found at position " << arg1
965 << " of your input string, but commas are not allowed here.");
967 private:
972 std::string sequence;
973
977 static const char *description_init;
978 };
979
984 class Bool : public Selection
985 {
986 public:
990 Bool();
991
996 virtual std::string
997 description(const OutputStyle style = Machine) const override;
998
1004 virtual std::unique_ptr<PatternBase>
1005 clone() const override;
1006
1012 static std::unique_ptr<Bool>
1013 create(const std::string &description);
1014
1015 private:
1019 static const char *description_init;
1020 };
1021
1025 class Anything : public PatternBase
1026 {
1027 public:
1032 Anything() = default;
1033
1038 virtual bool
1039 match(const std::string &test_string) const override;
1040
1045 virtual std::string
1046 description(const OutputStyle style = Machine) const override;
1047
1053 virtual std::unique_ptr<PatternBase>
1054 clone() const override;
1055
1061 static std::unique_ptr<Anything>
1062 create(const std::string &description);
1063
1064 private:
1068 static const char *description_init;
1069 };
1070
1071
1086 class FileName : public PatternBase
1087 {
1088 public:
1094 {
1102 output = 1
1104
1109 FileName(const FileType type = input);
1110
1115 virtual bool
1116 match(const std::string &test_string) const override;
1117
1122 virtual std::string
1123 description(const OutputStyle style = Machine) const override;
1124
1130 virtual std::unique_ptr<PatternBase>
1131 clone() const override;
1132
1137
1143 static std::unique_ptr<FileName>
1144 create(const std::string &description);
1145
1146 private:
1150 static const char *description_init;
1151 };
1152
1153
1167 {
1168 public:
1172 DirectoryName() = default;
1173
1178 virtual bool
1179 match(const std::string &test_string) const override;
1180
1185 virtual std::string
1186 description(const OutputStyle style = Machine) const override;
1187
1193 virtual std::unique_ptr<PatternBase>
1194 clone() const override;
1195
1201 static std::unique_ptr<DirectoryName>
1202 create(const std::string &description);
1203
1204 private:
1208 static const char *description_init;
1209 };
1210
1211
1290 namespace Tools
1291 {
1301 template <class T, class Enable = void>
1302 struct Convert
1303 {
1313 static std::unique_ptr<Patterns::PatternBase>
1314 to_pattern() = delete;
1315
1326 static std::string
1327 to_string(const T &s,
1329 delete;
1330
1340 static T
1341 to_value(const std::string &s,
1343 delete;
1344 };
1345
1364 template <typename T>
1365 std::string
1366 to_string(const T &t);
1367
1393 template <typename T>
1394 void
1395 to_value(const std::string &s, T &t);
1396
1406 std::string,
1407 std::string,
1408 << "The string \"" << arg1
1409 << "\" does not match the pattern \"" << arg2 << "\"");
1411 } // namespace Tools
1412} // namespace Patterns
1413
1414
1415// ---------------------- inline and template functions --------------------
1416namespace Patterns
1417{
1418 template <class... PatternTypes>
1419 Tuple::Tuple(const char *separator, const PatternTypes &...ps)
1420 : // forward to the version with std::string argument
1421 Tuple(std::string(separator), ps...)
1422 {}
1423
1424
1425
1426 template <class... PatternTypes>
1427 Tuple::Tuple(const std::string &separator, const PatternTypes &...ps)
1428 : separator(separator)
1429 {
1430 static_assert(is_base_of_all<PatternBase, PatternTypes...>::value,
1431 "Not all of the input arguments of this function "
1432 "are derived from PatternBase");
1433 static_assert(sizeof...(ps) > 0,
1434 "The number of PatternTypes must be greater than zero!");
1435 const auto pattern_pointers = {(static_cast<const PatternBase *>(&ps))...};
1436 for (const auto p : pattern_pointers)
1437 patterns.push_back(p->clone());
1438 }
1439
1440
1441
1442 template <class... PatternTypes>
1443 Tuple::Tuple(const PatternTypes &...ps)
1444 : // forward to the version with the separator argument
1445 Tuple(":", ps...)
1446 {}
1447
1448
1449
1450 namespace Tools
1451 {
1452 namespace internal
1453 {
1478 template <class T, class Enable = void>
1480 {
1481 static constexpr int list_rank = 0;
1482 static constexpr int map_rank = 0;
1483 };
1484 } // namespace internal
1485
1486 // Arithmetic types
1487 template <class T>
1488 struct Convert<T, std::enable_if_t<std::is_arithmetic_v<T>>>
1489 {
1490 template <typename Dummy = T>
1491 static std::enable_if_t<std::is_same_v<Dummy, T> &&
1492 std::is_same_v<T, bool>,
1493 std::unique_ptr<Patterns::PatternBase>>
1495 {
1496 return std::make_unique<Patterns::Bool>();
1497 }
1498
1499 template <typename Dummy = T>
1500 static std::enable_if_t<std::is_same_v<Dummy, T> &&
1501 !std::is_same_v<T, bool> &&
1502 std::is_integral_v<T>,
1503 std::unique_ptr<Patterns::PatternBase>>
1505 {
1506 return std::make_unique<Patterns::Integer>(
1507 std::numeric_limits<T>::lowest(), std::numeric_limits<T>::max());
1508 }
1509
1510 template <typename Dummy = T>
1511 static std::enable_if_t<std::is_same_v<Dummy, T> &&
1512 !std::is_same_v<T, bool> &&
1513 std::is_floating_point_v<T>,
1514 std::unique_ptr<Patterns::PatternBase>>
1516 {
1517 return std::make_unique<Patterns::Double>(
1518 std::numeric_limits<T>::lowest(), std::numeric_limits<T>::max());
1519 }
1520
1521 static std::string
1522 to_string(const T &value,
1524 {
1525 std::stringstream str;
1526 if (std::is_same_v<T, unsigned char> ||
1527 std::is_same_v<T, signed char> || std::is_same_v<T, char>)
1528 str << static_cast<int>(value);
1529 else if (std::is_same_v<T, bool>)
1530 str << (static_cast<bool>(value) ? "true" : "false");
1531 else
1532 str << value;
1533 AssertThrow(p.match(str.str()), ExcNoMatch(str.str(), p.description()));
1534 return str.str();
1535 }
1536
1537 static T
1538 to_value(const std::string &s,
1540 {
1541 AssertThrow(p.match(s), ExcNoMatch(s, p.description()));
1542 T value;
1543 if (std::is_same_v<T, bool>)
1544 value = (s == "true");
1545 else
1546 {
1547 std::istringstream is(s);
1548 if (std::is_same_v<T, unsigned char> ||
1549 std::is_same_v<T, signed char> || std::is_same_v<T, char>)
1550 {
1551 int i;
1552 is >> i;
1553 value = i;
1554 }
1555 else
1556 is >> value;
1557
1558 // If someone passes "123 abc" to the function, the method yields an
1559 // integer 123 alright, but the space terminates the read from the
1560 // string although there is more to come. This case, however, is
1561 // checked for in the call p->match(s) at the beginning of this
1562 // function, and would throw earlier. Here it is safe to assume that
1563 // if we didn't fail the conversion with the operator >>, then we
1564 // are good to go.
1566 !is.fail(),
1567 ExcMessage("Failed to convert from \"" + s + "\" to the type \"" +
1568 boost::core::demangle(typeid(T).name()) + "\""));
1569 }
1570 return value;
1571 }
1572 };
1573
1574 namespace internal
1575 {
1576 constexpr std::array<const char *, 4> default_list_separator{
1577 {",", ";", "|", "%"}};
1578 constexpr std::array<const char *, 4> default_map_separator{
1579 {":", "=", "@", "#"}};
1580
1581 // specialize a type for all of the STL containers and maps
1582 template <typename T>
1583 struct is_list_compatible : std::false_type
1584 {};
1585 template <typename... Args>
1586 struct is_list_compatible<std::vector<Args...>> : std::true_type
1587 {};
1588 template <typename... Args>
1589 struct is_list_compatible<std::deque<Args...>> : std::true_type
1590 {};
1591 template <typename... Args>
1592 struct is_list_compatible<std::list<Args...>> : std::true_type
1593 {};
1594 template <typename... Args>
1595 struct is_list_compatible<std::set<Args...>> : std::true_type
1596 {};
1597 template <typename... Args>
1598 struct is_list_compatible<std::multiset<Args...>> : std::true_type
1599 {};
1600 template <typename... Args>
1601 struct is_list_compatible<std::unordered_set<Args...>> : std::true_type
1602 {};
1603 template <typename... Args>
1604 struct is_list_compatible<std::unordered_multiset<Args...>>
1605 : std::true_type
1606 {};
1607
1608 template <typename T>
1609 struct is_map_compatible : std::false_type
1610 {};
1611 template <class Key, class T, class Compare, class Allocator>
1612 struct is_map_compatible<std::map<Key, T, Compare, Allocator>>
1613 : std::true_type
1614 {};
1615 template <class Key, class T, class Compare, class Allocator>
1616 struct is_map_compatible<std::multimap<Key, T, Compare, Allocator>>
1617 : std::true_type
1618 {};
1619 template <class Key, class T, class Hash, class KeyEqual, class Allocator>
1621 std::unordered_map<Key, T, Hash, KeyEqual, Allocator>> : std::true_type
1622 {};
1623 template <class Key, class T, class Hash, class KeyEqual, class Allocator>
1625 std::unordered_multimap<Key, T, Hash, KeyEqual, Allocator>>
1626 : std::true_type
1627 {};
1628 } // namespace internal
1629
1630 // type trait to use the implementation type traits as well as decay the
1631 // type
1632 template <typename T>
1634 {
1635 static constexpr const bool value =
1637 };
1638
1639 template <typename T>
1641 {
1642 static constexpr const bool value =
1644 };
1645
1646 namespace internal
1647 {
1648 // Helper function for list_rank
1649 template <class T>
1650 constexpr int
1652 {
1654 }
1655
1656 template <class T1, class T2, class... Types>
1657 constexpr int
1659 {
1660 return std::max(RankInfo<T1>::list_rank, max_list_rank<T2, Types...>());
1661 }
1662
1663 // Helper function for map_rank
1664 template <class T>
1665 constexpr int
1667 {
1668 return RankInfo<T>::map_rank;
1669 }
1670
1671 template <class T1, class T2, class... Types>
1672 constexpr int
1674 {
1675 return std::max(RankInfo<T1>::map_rank, max_map_rank<T2, Types...>());
1676 }
1677
1678 // Rank of vector types
1679 template <class T>
1680 struct RankInfo<T, std::enable_if_t<is_list_compatible<T>::value>>
1681 {
1682 static constexpr int list_rank =
1684 static constexpr int map_rank =
1686 };
1687
1688 // Rank of map types
1689 template <class T>
1690 struct RankInfo<T, std::enable_if_t<is_map_compatible<T>::value>>
1691 {
1692 static constexpr int list_rank =
1693 max_list_rank<typename T::key_type, typename T::mapped_type>() + 1;
1694 static constexpr int map_rank =
1695 max_map_rank<typename T::key_type, typename T::mapped_type>() + 1;
1696 };
1697
1698 // Rank of Tensor types
1699 template <int rank, int dim, class Number>
1700 struct RankInfo<Tensor<rank, dim, Number>>
1701 {
1702 static constexpr int list_rank = rank + RankInfo<Number>::list_rank;
1703 static constexpr int map_rank = RankInfo<Number>::map_rank;
1704 };
1705
1706 template <int dim, class Number>
1707 struct RankInfo<Point<dim, Number>> : RankInfo<Tensor<1, dim, Number>>
1708 {};
1709
1710 // Rank of complex types
1711 template <class Number>
1712 struct RankInfo<std::complex<Number>>
1713 {
1714 static constexpr int list_rank = RankInfo<Number>::list_rank + 1;
1715 static constexpr int map_rank = RankInfo<Number>::map_rank;
1716 };
1717
1718 // Rank of FunctionParser
1719 template <int dim>
1720 struct RankInfo<std::unique_ptr<FunctionParser<dim>>>
1721 {
1722 static constexpr int list_rank = 1;
1723 static constexpr int map_rank = 0;
1724 };
1725
1726 // Rank of ComponentMask
1727 template <>
1729 {
1730 static constexpr int list_rank = 1;
1731 static constexpr int map_rank = 0;
1732 };
1733
1734 // Rank of std::pair
1735 template <class Key, class Value>
1736 struct RankInfo<std::pair<Key, Value>>
1737 {
1738 static constexpr int list_rank =
1740 static constexpr int map_rank =
1742 };
1743
1744 // Rank of std::tuple types
1745 template <class... Types>
1746 struct RankInfo<std::tuple<Types...>>
1747 {
1748 static constexpr int list_rank = max_list_rank<Types...>();
1749 static constexpr int map_rank = max_map_rank<Types...>() + 1;
1750 };
1751
1752 // Rank of std::array types
1753 template <class T, std::size_t N>
1754 struct RankInfo<std::array<T, N>>
1755 {
1756 static constexpr int list_rank = RankInfo<T>::list_rank + 1;
1757 static constexpr int map_rank = RankInfo<T>::map_rank;
1758 };
1759 } // namespace internal
1760
1761 // stl containers
1762 template <class T>
1763 struct Convert<T, std::enable_if_t<is_list_compatible<T>::value>>
1764 {
1765 static std::unique_ptr<Patterns::PatternBase>
1767 {
1768 static_assert(internal::RankInfo<T>::list_rank > 0,
1769 "Cannot use this class for non List-compatible types.");
1770 return std::make_unique<Patterns::List>(
1772 0,
1773 std::numeric_limits<unsigned int>::max(),
1775 1]);
1776 }
1777
1778 static std::string
1780 const T &t,
1782 {
1783 const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
1784 AssertThrow(p,
1785 ExcMessage("I need a List pattern to convert a "
1786 "string to a List type."));
1787 auto base_p = p->get_base_pattern().clone();
1788 std::vector<std::string> vec(t.size());
1789
1790 std::transform(
1791 t.cbegin(), t.cend(), vec.begin(), [&base_p](const auto &entry) {
1792 return Convert<typename T::value_type>::to_string(entry, *base_p);
1793 });
1794
1795 std::string s;
1796 if (vec.size() > 0)
1797 s = vec[0];
1798 for (unsigned int i = 1; i < vec.size(); ++i)
1799 s += p->get_separator() + " " + vec[i];
1800
1801 AssertThrow(pattern.match(s), ExcNoMatch(s, p->description()));
1802 return s;
1803 }
1804
1805 static T
1806 to_value(const std::string &s,
1808 {
1809 AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
1810
1811 const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
1812 AssertThrow(p,
1813 ExcMessage("I need a List pattern to convert a string "
1814 "to a List type."));
1815
1816 auto base_p = p->get_base_pattern().clone();
1817 T t;
1818
1819 auto v = Utilities::split_string_list(s, p->get_separator());
1820 for (const auto &str : v)
1821 t.insert(t.end(),
1823
1824 return t;
1825 }
1826 };
1827
1828 // stl maps
1829 template <class T>
1830 struct Convert<T, std::enable_if_t<is_map_compatible<T>::value>>
1831 {
1832 static std::unique_ptr<Patterns::PatternBase>
1834 {
1835 static_assert(internal::RankInfo<T>::list_rank > 0,
1836 "Cannot use this class for non List-compatible types.");
1837 static_assert(internal::RankInfo<T>::map_rank > 0,
1838 "Cannot use this class for non Map-compatible types.");
1839 return std::make_unique<Patterns::Map>(
1842 0,
1843 std::numeric_limits<unsigned int>::max(),
1845 1],
1847 }
1848
1849 static std::string
1851 const T &t,
1853 {
1854 const auto *p = dynamic_cast<const Patterns::Map *>(&pattern);
1855 AssertThrow(p,
1856 ExcMessage("I need a Map pattern to convert a string to "
1857 "a Map compatible type."));
1858 auto key_p = p->get_key_pattern().clone();
1859 auto val_p = p->get_value_pattern().clone();
1860 std::vector<std::string> vec(t.size());
1861
1862 unsigned int i = 0;
1863 for (const auto &ti : t)
1864 vec[i++] =
1866 p->get_key_value_separator() +
1868
1869 std::string s;
1870 if (vec.size() > 0)
1871 s = vec[0];
1872 for (unsigned int i = 1; i < vec.size(); ++i)
1873 s += p->get_separator() + " " + vec[i];
1874
1875 AssertThrow(p->match(s), ExcNoMatch(s, p->description()));
1876 return s;
1877 }
1878
1879 static T
1880 to_value(const std::string &s,
1882 {
1883 AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
1884
1885 const auto *p = dynamic_cast<const Patterns::Map *>(&pattern);
1886 AssertThrow(p,
1887 ExcMessage("I need a Map pattern to convert a "
1888 "string to a Map compatible type."));
1889
1890 auto key_p = p->get_key_pattern().clone();
1891 auto val_p = p->get_value_pattern().clone();
1892 T t;
1893
1894 auto v = Utilities::split_string_list(s, p->get_separator());
1895 for (const auto &str : v)
1896 {
1897 auto key_val =
1898 Utilities::split_string_list(str, p->get_key_value_separator());
1899 AssertDimension(key_val.size(), 2);
1900 t.insert(std::make_pair(
1901 Convert<typename T::key_type>::to_value(key_val[0], *key_p),
1902 Convert<typename T::mapped_type>::to_value(key_val[1], *val_p)));
1903 }
1904
1905 return t;
1906 }
1907 };
1908
1909 // std::array
1910 template <typename ValueType, std::size_t N>
1911 struct Convert<std::array<ValueType, N>>
1912 {
1913 using T = std::array<ValueType, N>;
1914
1915 static std::unique_ptr<Patterns::PatternBase>
1917 {
1918 static_assert(internal::RankInfo<T>::list_rank > 0,
1919 "Cannot use this class for non List-compatible types.");
1920 return std::make_unique<Patterns::List>(
1922 N,
1923 N,
1925 1]);
1926 }
1927
1928 static std::string
1930 const T &t,
1932 {
1933 const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
1934 AssertThrow(p,
1935 ExcMessage("I need a List pattern to convert a "
1936 "string to a std::array."));
1937 auto base_p = p->get_base_pattern().clone();
1938 std::vector<std::string> vec(t.size());
1939
1940 std::transform(
1941 t.cbegin(), t.cend(), vec.begin(), [&base_p](const auto &entry) {
1942 return Convert<typename T::value_type>::to_string(entry, *base_p);
1943 });
1944
1945 std::string s;
1946 if (vec.size() > 0)
1947 s = vec[0];
1948 for (unsigned int i = 1; i < vec.size(); ++i)
1949 s += p->get_separator() + " " + vec[i];
1950
1951 AssertThrow(pattern.match(s), ExcNoMatch(s, p->description()));
1952 return s;
1953 }
1954
1955 static T
1956 to_value(const std::string &s,
1958 {
1959 AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
1960
1961 const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
1962 AssertThrow(p,
1963 ExcMessage("I need a List pattern to convert a string "
1964 "to a std::array."));
1965
1966 auto base_p = p->get_base_pattern().clone();
1967 T t;
1968
1969 auto v = Utilities::split_string_list(s, p->get_separator());
1970 AssertDimension(v.size(), N);
1971 for (unsigned int i = 0; i < N; ++i)
1972 t[i] = Convert<typename T::value_type>::to_value(v[i], *base_p);
1973 return t;
1974 }
1975 };
1976
1977 // Tensors
1978 template <int rank, int dim, class Number>
1979 struct Convert<Tensor<rank, dim, Number>>
1980 {
1982 static std::unique_ptr<Patterns::PatternBase>
1984 {
1985 static_assert(internal::RankInfo<T>::list_rank > 0,
1986 "Cannot use this class for non List-compatible types.");
1987 return std::make_unique<Patterns::List>(
1989 dim,
1990 dim,
1992 1]);
1993 }
1994
1995 static std::string
1997 const T &t,
1999 {
2000 const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
2001 AssertThrow(p,
2002 ExcMessage("I need a List pattern to convert a string "
2003 "to a List compatible type."));
2004 auto base_p = p->get_base_pattern().clone();
2005 std::vector<std::string> vec(dim);
2006
2007 for (unsigned int i = 0; i < dim; ++i)
2008 vec[i] = Convert<typename T::value_type>::to_string(t[i], *base_p);
2009
2010 std::string s;
2011 if (vec.size() > 0)
2012 s = vec[0];
2013 for (unsigned int i = 1; i < vec.size(); ++i)
2014 s += p->get_separator() + " " + vec[i];
2015
2016 AssertThrow(p->match(s), ExcNoMatch(s, p->description()));
2017 return s;
2018 }
2019
2020 static T
2021 to_value(const std::string &s,
2023 {
2024 AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
2025
2026 const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
2027 AssertThrow(p,
2028 ExcMessage("I need a List pattern to convert a string "
2029 "to a List compatible type."));
2030
2031 auto base_p = p->get_base_pattern().clone();
2032 T t;
2033
2034 auto v = Utilities::split_string_list(s, p->get_separator());
2035 unsigned int i = 0;
2036 for (const auto &str : v)
2037 t[i++] = Convert<typename T::value_type>::to_value(str, *base_p);
2038
2039 return t;
2040 }
2041 };
2042
2043 // Points
2044 template <int dim, class Number>
2045 struct Convert<Point<dim, Number>>
2046 {
2048
2049 static std::unique_ptr<Patterns::PatternBase>
2054
2055 static std::string
2057 const T &t,
2059 {
2061 Tensor<1, dim, Number>(t), pattern);
2062 }
2063
2064 static T
2065 to_value(const std::string &s,
2067 {
2068 return T(Convert<Tensor<1, dim, Number>>::to_value(s, pattern));
2069 }
2070 };
2071
2072 // Functions::FunctionParser
2073 template <int dim>
2074 struct Convert<std::unique_ptr<FunctionParser<dim>>>
2075 {
2076 using T = std::unique_ptr<FunctionParser<dim>>;
2077
2078 static std::unique_ptr<Patterns::PatternBase>
2080 {
2081 static_assert(internal::RankInfo<T>::list_rank > 0,
2082 "Cannot use this class for non List-compatible types.");
2083
2084 return std::make_unique<Patterns::List>(
2086 1,
2089 1]);
2090 }
2091
2092 static std::string
2094 const T &t,
2096 {
2097 const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
2098 AssertThrow(p,
2099 ExcMessage("I need a List pattern to convert a string "
2100 "to a List compatible type."));
2101
2102 const auto &expressions = t->get_expressions();
2103 if (expressions.empty())
2104 return std::string();
2105
2106 std::string s = expressions[0];
2107 for (unsigned int i = 1; i < expressions.size(); ++i)
2108 s = s + p->get_separator() + expressions[i];
2109
2110 AssertThrow(pattern.match(s), ExcNoMatch(s, p->description()));
2111 return s;
2112 }
2113
2114 static T
2115 to_value(const std::string &s,
2117 {
2118 AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
2119
2120 const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
2121 AssertThrow(p,
2122 ExcMessage("I need a List pattern to convert a string "
2123 "to a List compatible type."));
2124
2125 const auto expressions =
2126 Utilities::split_string_list(s, p->get_separator());
2127
2128 T t = std::make_unique<FunctionParser<dim>>(expressions.size());
2129 const std::string var =
2131 const typename FunctionParser<dim>::ConstMap constants;
2132 t->initialize(var, expressions, constants, true);
2133 return t;
2134 }
2135 };
2136
2137 // ComponentMask
2138 template <>
2140 {
2142
2143 static std::unique_ptr<Patterns::PatternBase>
2145 {
2147 }
2148
2149 static std::string
2151 const T &t,
2153 {
2154 std::vector<bool> mask(t.size());
2155 for (unsigned int i = 0; i < t.size(); ++i)
2156 mask[i] = t[i];
2157
2158 return Convert<std::vector<bool>>::to_string(mask, pattern);
2159 }
2160
2161 static T
2162 to_value(const std::string &s,
2164 {
2165 const auto mask = Convert<std::vector<bool>>::to_value(s, pattern);
2166 return ComponentMask(mask);
2167 }
2168 };
2169
2170 // Complex numbers
2171 template <class Number>
2172 struct Convert<std::complex<Number>>
2173 {
2174 using T = std::complex<Number>;
2175
2176 static std::unique_ptr<Patterns::PatternBase>
2178 {
2179 static_assert(internal::RankInfo<T>::list_rank > 0,
2180 "Cannot use this class for non List-compatible types.");
2181 return std::make_unique<Patterns::List>(
2183 2,
2184 2,
2186 1]);
2187 }
2188
2189 static std::string
2191 const T &t,
2193 {
2194 const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
2195 AssertThrow(p,
2196 ExcMessage("I need a List pattern to convert a string "
2197 "to a List compatible type."));
2198
2199 auto base_p = p->get_base_pattern().clone();
2200 std::string s =
2202 p->get_separator() + " " +
2204
2205 AssertThrow(pattern.match(s), ExcNoMatch(s, p->description()));
2206 return s;
2207 }
2208
2212 static T
2213 to_value(const std::string &s,
2215 {
2216 AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
2217
2218 const auto *p = dynamic_cast<const Patterns::List *>(&pattern);
2219 AssertThrow(p,
2220 ExcMessage("I need a List pattern to convert a string "
2221 "to a List compatible type."));
2222
2223 auto base_p = p->get_base_pattern().clone();
2224
2225 auto v = Utilities::split_string_list(s, p->get_separator());
2226 AssertDimension(v.size(), 2);
2229 return t;
2230 }
2231 };
2232
2233 // Strings
2234 template <>
2235 struct Convert<std::string>
2236 {
2237 using T = std::string;
2238
2239 static std::unique_ptr<Patterns::PatternBase>
2241 {
2242 return std::make_unique<Patterns::Anything>();
2243 }
2244
2245 static std::string
2247 const T &t,
2249 {
2250 AssertThrow(pattern.match(t), ExcNoMatch(t, pattern.description()));
2251 return t;
2252 }
2253
2254 static T
2255 to_value(const std::string &s,
2257 {
2258 AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
2259 return s;
2260 }
2261 };
2262
2263 // Pairs
2264 template <class Key, class Value>
2265 struct Convert<std::pair<Key, Value>>
2266 {
2267 using T = std::pair<Key, Value>;
2268
2269 static std::unique_ptr<Patterns::PatternBase>
2271 {
2272 static_assert(internal::RankInfo<T>::map_rank > 0,
2273 "Cannot use this class for non Map-compatible types.");
2274 return std::make_unique<Patterns::Tuple>(
2278 }
2279
2280 static std::string
2282 const T &t,
2284 {
2285 std::tuple<Key, Value> m(t);
2286 std::string s = Convert<decltype(m)>::to_string(m, pattern);
2287 AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
2288 return s;
2289 }
2290
2291 static T
2292 to_value(const std::string &s,
2294 {
2295 std::tuple<Key, Value> m;
2296 m = Convert<decltype(m)>::to_value(s, pattern);
2297 return std::make_pair(std::get<0>(m), std::get<1>(m));
2298 }
2299 };
2300
2301 // Tuples
2302 template <class... Args>
2303 struct Convert<std::tuple<Args...>>
2304 {
2305 using T = std::tuple<Args...>;
2306
2307 static std::unique_ptr<Patterns::PatternBase>
2309 {
2310 static_assert(internal::RankInfo<T>::map_rank > 0,
2311 "Cannot use this class for non tuple-compatible types.");
2312 return std::make_unique<Patterns::Tuple>(
2315 }
2316
2317 static std::string
2319 const T &t,
2321 {
2322 const auto *p = dynamic_cast<const Patterns::Tuple *>(&pattern);
2323 AssertThrow(p,
2324 ExcMessage("I need a Tuple pattern to convert a tuple "
2325 "to a string."));
2326
2327 const auto string_array = Convert<T>::to_string_internal_2(t, *p);
2328 std::string str;
2329 for (unsigned int i = 0; i < string_array.size(); ++i)
2330 str +=
2331 (i != 0u ? " " + p->get_separator() + " " : "") + string_array[i];
2332 AssertThrow(p->match(str), ExcNoMatch(str, p->description()));
2333 return str;
2334 }
2335
2336 static T
2337 to_value(const std::string &s,
2339 {
2340 AssertThrow(pattern.match(s), ExcNoMatch(s, pattern.description()));
2341
2342 const auto *p = dynamic_cast<const Patterns::Tuple *>(&pattern);
2343 AssertThrow(p,
2344 ExcMessage("I need a Tuple pattern to convert a string "
2345 "to a tuple type."));
2346
2347 auto v = Utilities::split_string_list(s, p->get_separator());
2348
2349 return Convert<T>::to_value_internal_2(v, *p);
2350 }
2351
2352 private:
2353 template <std::size_t... U>
2354 static std::array<std::string, std::tuple_size<T>::value>
2356 const Patterns::Tuple &pattern,
2357 std::index_sequence<U...>)
2358 {
2359 std::array<std::string, std::tuple_size<T>::value> a = {
2361 std::get<U>(t), pattern.get_pattern(U))...}};
2362 return a;
2363 }
2364
2365 static std::array<std::string, std::tuple_size<T>::value>
2366 to_string_internal_2(const T &t, const Patterns::Tuple &pattern)
2367 {
2369 t, pattern, std::make_index_sequence<std::tuple_size<T>::value>{});
2370 }
2371
2372 template <std::size_t... U>
2373 static T
2374 to_value_internal_1(const std::vector<std::string> &s,
2375 const Patterns::Tuple &pattern,
2376 std::index_sequence<U...>)
2377 {
2378 return std::make_tuple(
2379 Convert<typename std::tuple_element<U, T>::type>::to_value(
2380 s[U], pattern.get_pattern(U))...);
2381 }
2382
2383 static T
2384 to_value_internal_2(const std::vector<std::string> &s,
2385 const Patterns::Tuple &pattern)
2386 {
2388 s, pattern, std::make_index_sequence<std::tuple_size<T>::value>{});
2389 }
2390 };
2391
2392#ifdef DEAL_II_WITH_MAGIC_ENUM
2393 // Enums
2394 template <class T>
2395 struct Convert<T, typename std::enable_if<std::is_enum<T>::value>::type>
2396 {
2397 static std::unique_ptr<Patterns::PatternBase>
2398 to_pattern()
2399 {
2400 const auto n = magic_enum::enum_names<T>();
2401 std::vector<std::string> names = {n.begin(), n.end()};
2402 const auto selection =
2403 Patterns::Tools::Convert<decltype(names)>::to_string(
2404 names,
2406 Patterns::Anything(), names.size(), names.size(), "|"));
2407 // Allow parsing a list of enums, and make bitwise or between them
2408 return Patterns::List(Patterns::Selection(selection),
2409 0,
2410 names.size(),
2411 "|")
2412 .clone();
2413 }
2414
2415 static std::string
2416 to_string(const T &value,
2418 {
2419 const auto values = magic_enum::enum_values<T>();
2420 std::vector<std::string> names;
2421 for (const auto &v : values)
2422 if (magic_enum::bitwise_operators::operator&(value, v) == v)
2423 names.push_back(std::string(magic_enum::enum_name(v)));
2424 return Patterns::Tools::Convert<decltype(names)>::to_string(names, p);
2425 }
2426
2427 static T
2428 to_value(const std::string &s,
2429 const ::Patterns::PatternBase &p = *to_pattern())
2430 {
2431 // Make sure we have a valid enum value, or empty value
2432 AssertThrow(p.match(s), ExcNoMatch(s, p.description()));
2433 T value = T();
2434 std::vector<std::string> value_names;
2435 value_names =
2436 Patterns::Tools::Convert<decltype(value_names)>::to_value(s, p);
2437 for (const auto &name : value_names)
2438 {
2439 auto v = magic_enum::enum_cast<T>(name);
2440 if (v.has_value())
2441 value =
2442 magic_enum::bitwise_operators::operator|(value, v.value());
2443 }
2444 return value;
2445 }
2446 };
2447#endif
2448
2449 // Utility function with default Pattern
2450 template <typename T>
2451 std::string
2452 to_string(const T &t)
2453 {
2454 return Convert<T>::to_string(t);
2455 }
2456
2457 // Utility function with default Pattern
2458 template <typename T>
2459 void
2460 to_value(const std::string &s, T &t)
2461 {
2462 t = Convert<T>::to_value(s);
2463 }
2464 } // namespace Tools
2465} // namespace Patterns
2466
2467
2469
2470#endif
unsigned int size() const
std::map< std::string, double > ConstMap
static std::string default_variable_names()
static std::unique_ptr< Anything > create(const std::string &description)
Definition patterns.cc:1510
virtual bool match(const std::string &test_string) const override
Definition patterns.cc:1466
static const char * description_init
Definition patterns.h:1068
virtual std::string description(const OutputStyle style=Machine) const override
Definition patterns.cc:1474
virtual std::unique_ptr< PatternBase > clone() const override
Definition patterns.cc:1502
virtual std::string description(const OutputStyle style=Machine) const override
Definition patterns.cc:1413
static const char * description_init
Definition patterns.h:1019
virtual std::unique_ptr< PatternBase > clone() const override
Definition patterns.cc:1441
static std::unique_ptr< Bool > create(const std::string &description)
Definition patterns.cc:1449
virtual std::unique_ptr< PatternBase > clone() const override
Definition patterns.cc:1652
static const char * description_init
Definition patterns.h:1208
virtual std::string description(const OutputStyle style=Machine) const override
Definition patterns.cc:1624
static std::unique_ptr< DirectoryName > create(const std::string &description)
Definition patterns.cc:1660
virtual bool match(const std::string &test_string) const override
Definition patterns.cc:1616
static std::unique_ptr< Double > create(const std::string &description)
Definition patterns.cc:488
static const char * description_init
Definition patterns.h:373
virtual std::unique_ptr< PatternBase > clone() const override
Definition patterns.cc:480
const double lower_bound
Definition patterns.h:360
const double upper_bound
Definition patterns.h:368
static const double max_double_value
Definition patterns.h:308
static const double min_double_value
Definition patterns.h:302
virtual std::string description(const OutputStyle style=Machine) const override
Definition patterns.cc:380
virtual bool match(const std::string &test_string) const override
Definition patterns.cc:357
virtual bool match(const std::string &test_string) const override
Definition patterns.cc:1532
static const char * description_init
Definition patterns.h:1150
virtual std::unique_ptr< PatternBase > clone() const override
Definition patterns.cc:1576
static std::unique_ptr< FileName > create(const std::string &description)
Definition patterns.cc:1584
virtual std::string description(const OutputStyle style=Machine) const override
Definition patterns.cc:1540
static std::unique_ptr< Integer > create(const std::string &description)
Definition patterns.cc:309
static const char * description_init
Definition patterns.h:275
const int upper_bound
Definition patterns.h:270
virtual std::unique_ptr< PatternBase > clone() const override
Definition patterns.cc:301
const int lower_bound
Definition patterns.h:262
static const int min_int_value
Definition patterns.h:200
virtual std::string description(const OutputStyle style=Machine) const override
Definition patterns.cc:240
virtual bool match(const std::string &test_string) const override
Definition patterns.cc:218
static const int max_int_value
Definition patterns.h:207
const unsigned int max_elements
Definition patterns.h:559
static const char * description_init
Definition patterns.h:569
const unsigned int min_elements
Definition patterns.h:554
std::unique_ptr< PatternBase > pattern
Definition patterns.h:549
const std::string separator
Definition patterns.h:564
std::size_t memory_consumption() const override
Definition patterns.cc:765
static std::unique_ptr< List > create(const std::string &description)
Definition patterns.cc:774
virtual std::string description(const OutputStyle style=Machine) const override
Definition patterns.cc:713
const PatternBase & get_base_pattern() const
Definition patterns.cc:685
virtual bool match(const std::string &test_string) const override
Definition patterns.cc:693
const std::string & get_separator() const
Definition patterns.cc:677
static const unsigned int max_int_value
Definition patterns.h:461
virtual std::unique_ptr< PatternBase > clone() const override
Definition patterns.cc:757
static std::unique_ptr< Map > create(const std::string &description)
Definition patterns.cc:983
std::unique_ptr< PatternBase > value_pattern
Definition patterns.h:698
const unsigned int min_elements
Definition patterns.h:703
const PatternBase & get_key_pattern() const
Definition patterns.cc:1038
virtual bool match(const std::string &test_string) const override
Definition patterns.cc:879
const unsigned int max_elements
Definition patterns.h:708
virtual std::unique_ptr< PatternBase > clone() const override
Definition patterns.cc:959
const PatternBase & get_value_pattern() const
Definition patterns.cc:1046
const std::string & get_separator() const
Definition patterns.cc:1054
virtual std::string description(const OutputStyle style=Machine) const override
Definition patterns.cc:909
static const unsigned int max_int_value
Definition patterns.h:595
std::unique_ptr< PatternBase > key_pattern
Definition patterns.h:697
const std::string separator
Definition patterns.h:713
std::size_t memory_consumption() const override
Definition patterns.cc:971
static const char * description_init
Definition patterns.h:724
const std::string & get_key_value_separator() const
Definition patterns.cc:1061
const std::string key_value_separator
Definition patterns.h:719
static std::unique_ptr< MultipleSelection > create(const std::string &description)
Definition patterns.cc:1384
virtual bool match(const std::string &test_string) const override
Definition patterns.cc:1270
virtual std::unique_ptr< PatternBase > clone() const override
Definition patterns.cc:1368
static const char * description_init
Definition patterns.h:977
std::size_t memory_consumption() const override
Definition patterns.cc:1375
virtual std::string description(const OutputStyle style=Machine) const override
Definition patterns.cc:1333
virtual std::size_t memory_consumption() const
Definition patterns.cc:189
virtual std::unique_ptr< PatternBase > clone() const =0
virtual std::string description(const OutputStyle style=Machine) const =0
virtual bool match(const std::string &test_string) const =0
virtual ~PatternBase()=default
static const char * description_init
Definition patterns.h:442
virtual std::string description(const OutputStyle style=Machine) const override
Definition patterns.cc:575
virtual std::unique_ptr< PatternBase > clone() const override
Definition patterns.cc:610
virtual bool match(const std::string &test_string) const override
Definition patterns.cc:543
static std::unique_ptr< Selection > create(const std::string &description)
Definition patterns.cc:626
std::size_t memory_consumption() const override
Definition patterns.cc:617
std::string sequence
Definition patterns.h:437
virtual bool match(const std::string &test_string) const override
Definition patterns.cc:1104
std::size_t memory_consumption() const override
Definition patterns.cc:1180
static std::unique_ptr< Tuple > create(const std::string &description)
Definition patterns.cc:1189
std::vector< std::unique_ptr< PatternBase > > patterns
Definition patterns.h:883
virtual std::unique_ptr< PatternBase > clone() const override
Definition patterns.cc:1173
Tuple(const Patterns &...patterns)
const std::string separator
Definition patterns.h:888
static const char * description_init
Definition patterns.h:893
Tuple(const std::vector< std::unique_ptr< PatternBase > > &patterns, const std::string &separator=":")
Definition patterns.cc:1071
const std::string & get_separator() const
Definition patterns.cc:1245
const PatternBase & get_pattern(const unsigned int i) const
Definition patterns.cc:1237
virtual std::string description(const OutputStyle style=Machine) const override
Definition patterns.cc:1123
Definition point.h:113
#define DEAL_II_NAMESPACE_OPEN
Definition config.h:40
#define DEAL_II_NAMESPACE_CLOSE
Definition config.h:41
static ::ExceptionBase & ExcInvalidRange(int arg1, int arg2)
static ::ExceptionBase & ExcInvalidRange(int arg1, int arg2)
static ::ExceptionBase & ExcNoMatch(std::string arg1, std::string arg2)
#define DeclException2(Exception2, type1, type2, outsequence)
#define AssertDimension(dim1, dim2)
static ::ExceptionBase & ExcCommasNotAllowed(int arg1)
#define DeclException1(Exception1, type1, outsequence)
static ::ExceptionBase & ExcMessage(std::string arg1)
#define AssertThrow(cond, exc)
constexpr char T
constexpr std::array< const char *, 4 > default_map_separator
Definition patterns.h:1578
constexpr int max_map_rank()
Definition patterns.h:1666
constexpr int max_list_rank()
Definition patterns.h:1651
constexpr std::array< const char *, 4 > default_list_separator
Definition patterns.h:1576
void to_value(const std::string &s, T &t)
Definition patterns.h:2460
std::string to_string(const T &t)
Definition patterns.h:2452
std::string escape(const std::string &input, const PatternBase::OutputStyle style)
Definition patterns.cc:52
std::unique_ptr< PatternBase > pattern_factory(const std::string &description)
Definition patterns.cc:137
std::vector< std::string > split_string_list(const std::string &s, const std::string &delimiter=",")
Definition utilities.cc:699
STL namespace.
::VectorizedArray< Number, width > max(const ::VectorizedArray< Number, width > &, const ::VectorizedArray< Number, width > &)
static std::unique_ptr< Patterns::PatternBase > to_pattern()
Definition patterns.h:2144
static T to_value(const std::string &s, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
Definition patterns.h:2162
static std::string to_string(const T &t, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
Definition patterns.h:2150
static std::unique_ptr< Patterns::PatternBase > to_pattern()
Definition patterns.h:2050
static std::string to_string(const T &t, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
Definition patterns.h:2056
static T to_value(const std::string &s, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
Definition patterns.h:2065
static T to_value(const std::string &s, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
Definition patterns.h:1806
static std::string to_string(const T &t, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
Definition patterns.h:1779
static std::string to_string(const T &t, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
Definition patterns.h:1850
static T to_value(const std::string &s, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
Definition patterns.h:1880
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()
Definition patterns.h:1515
static T to_value(const std::string &s, const Patterns::PatternBase &p= *Convert< T >::to_pattern())
Definition patterns.h:1538
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()
Definition patterns.h:1504
static std::enable_if_t< std::is_same_v< Dummy, T > &&std::is_same_v< T, bool >, std::unique_ptr< Patterns::PatternBase > > to_pattern()
Definition patterns.h:1494
static std::string to_string(const T &value, const Patterns::PatternBase &p= *Convert< T >::to_pattern())
Definition patterns.h:1522
static std::unique_ptr< Patterns::PatternBase > to_pattern()
Definition patterns.h:1983
static T to_value(const std::string &s, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
Definition patterns.h:2021
static std::string to_string(const T &t, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
Definition patterns.h:1996
static std::unique_ptr< Patterns::PatternBase > to_pattern()
Definition patterns.h:1916
static T to_value(const std::string &s, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
Definition patterns.h:1956
static std::string to_string(const T &t, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
Definition patterns.h:1929
static std::unique_ptr< Patterns::PatternBase > to_pattern()
Definition patterns.h:2177
static T to_value(const std::string &s, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
Definition patterns.h:2213
static std::string to_string(const T &t, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
Definition patterns.h:2190
static std::unique_ptr< Patterns::PatternBase > to_pattern()
Definition patterns.h:2270
static T to_value(const std::string &s, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
Definition patterns.h:2292
static std::string to_string(const T &t, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
Definition patterns.h:2281
static std::unique_ptr< Patterns::PatternBase > to_pattern()
Definition patterns.h:2240
static T to_value(const std::string &s, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
Definition patterns.h:2255
static std::string to_string(const T &t, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
Definition patterns.h:2246
static T to_value_internal_2(const std::vector< std::string > &s, const Patterns::Tuple &pattern)
Definition patterns.h:2384
static T to_value(const std::string &s, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
Definition patterns.h:2337
static std::array< std::string, std::tuple_size< T >::value > to_string_internal_2(const T &t, const Patterns::Tuple &pattern)
Definition patterns.h:2366
static std::unique_ptr< Patterns::PatternBase > to_pattern()
Definition patterns.h:2308
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... >)
Definition patterns.h:2355
static T to_value_internal_1(const std::vector< std::string > &s, const Patterns::Tuple &pattern, std::index_sequence< U... >)
Definition patterns.h:2374
static std::string to_string(const T &t, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
Definition patterns.h:2318
static std::unique_ptr< Patterns::PatternBase > to_pattern()
Definition patterns.h:2079
static T to_value(const std::string &s, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
Definition patterns.h:2115
static std::string to_string(const T &t, const Patterns::PatternBase &pattern= *Convert< T >::to_pattern())
Definition patterns.h:2093
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 constexpr int list_rank
Definition patterns.h:1481
static constexpr int map_rank
Definition patterns.h:1482
static constexpr const bool value
Definition patterns.h:1635
static constexpr const bool value
Definition patterns.h:1642