40 #ifndef EWOMS_PROPERTIES_HH
41 #define EWOMS_PROPERTIES_HH
43 #include <opm/material/common/ClassName.hpp>
44 #include <opm/common/ErrorMacros.hpp>
45 #include <opm/common/Exceptions.hpp>
47 #include <type_traits>
61 namespace Properties {
63 #define EWOMS_GET_HEAD_(Arg1, ...) Arg1
65 #if !defined NO_PROPERTY_INTROSPECTION
68 #define PROP_INFO_(EffTypeTagName, PropKind, PropTagName, ...) \
70 struct PropertyInfo<TTAG(EffTypeTagName), PTAG(PropTagName)> \
73 propertyName = #PropTagName; \
74 PropertyRegistryKey key( \
75 Opm::className<TTAG(EffTypeTagName)>(), \
81 PropertyRegistry::addKey(key); \
84 static std::string propertyName; \
87 std::string PropertyInfo<TTAG(EffTypeTagName), PTAG(PropTagName)>::propertyName; \
88 int PropertyInfo<TTAG(EffTypeTagName), PTAG(PropTagName)>::foo = \
89 PropertyInfo<TTAG(EffTypeTagName), PTAG(PropTagName)>::init();
92 #define TTAG_INFO_(...) \
94 struct TypeTagInfo<EWOMS_GET_HEAD_(__VA_ARGS__)> \
97 TypeTagRegistry::addChildren<__VA_ARGS__>(); \
102 int TypeTagInfo<EWOMS_GET_HEAD_(__VA_ARGS__)>::foo = \
103 TypeTagInfo<EWOMS_GET_HEAD_(__VA_ARGS__)>::init();
106 #define SPLICE_INFO_(...) \
108 struct SpliceInfo<EWOMS_GET_HEAD_(__VA_ARGS__)> \
110 static int init() { \
111 TypeTagRegistry::addSplices<__VA_ARGS__>(); \
116 int SpliceInfo<EWOMS_GET_HEAD_(__VA_ARGS__)>::foo = \
117 SpliceInfo<EWOMS_GET_HEAD_(__VA_ARGS__)>::init();
120 #define PROP_INFO_(EffTypeTagName, PropKind, PropTagName, ...)
122 #define TTAG_INFO_(EffTypeTagName, ...)
123 #define SPLICE_INFO_(EffTypeTagName, ...)
137 #define TTAG(TypeTagName) Ewoms::Properties::TTag::TypeTagName
146 #define PTAG(PropTagName) Ewoms::Properties::PTag::PropTagName
168 #define NEW_TYPE_TAG(...) \
170 struct EWOMS_GET_HEAD_(__VA_ARGS__, blubb) \
171 : public TypeTag<__VA_ARGS__> \
173 TTAG_INFO_(__VA_ARGS__, void) \
175 extern int semicolonHack_
212 #define SET_SPLICES(TypeTagName, ...) \
215 struct Splices<TTAG(TypeTagName)> \
217 typedef RevertedTuple<__VA_ARGS__>::type tuple; \
219 SPLICE_INFO_(TTAG(TypeTagName), __VA_ARGS__) \
221 extern int semicolonHack_
229 #define INHERITS_FROM(...) __VA_ARGS__
246 #define NEW_PROP_TAG(PTagName) \
248 struct PTagName; } extern int semicolonHack_
251 #define SET_PROP_(EffTypeTagName, PropKind, PropTagName, ...) \
252 template <class TypeTag> \
253 struct Property<TypeTag, \
254 TTAG(EffTypeTagName), \
255 PTAG(PropTagName)>; \
256 PROP_INFO_(EffTypeTagName, \
260 template <class TypeTag> \
261 struct Property<TypeTag, \
262 TTAG(EffTypeTagName), \
296 #define SET_PROP(EffTypeTagName, PropTagName) \
297 template <class TypeTag> \
298 struct Property<TypeTag, \
299 TTAG(EffTypeTagName), \
300 PTAG(PropTagName)>; \
301 PROP_INFO_(EffTypeTagName, \
305 template <class TypeTag> \
306 struct Property<TypeTag, \
307 TTAG(EffTypeTagName), \
324 #define UNSET_PROP(EffTypeTagName, PropTagName) \
326 struct PropertyUnset<TTAG(EffTypeTagName), \
327 PTAG(PropTagName) >; \
328 PROP_INFO_(EffTypeTagName, \
333 struct PropertyUnset<TTAG(EffTypeTagName), \
334 PTAG(PropTagName) > \
335 : public PropertyExplicitlyUnset \
344 #define SET_INT_PROP(EffTypeTagName, PropTagName, ...) \
345 SET_PROP_(EffTypeTagName, \
351 static const int value = __VA_ARGS__; \
360 #define SET_BOOL_PROP(EffTypeTagName, PropTagName, ...) \
361 SET_PROP_(EffTypeTagName, \
367 static const bool value = __VA_ARGS__; \
376 #define SET_TYPE_PROP(EffTypeTagName, PropTagName, ...) \
377 SET_PROP_(EffTypeTagName, \
382 typedef __VA_ARGS__ type; \
393 #define SET_SCALAR_PROP(EffTypeTagName, PropTagName, ...) \
394 SET_PROP_(EffTypeTagName, \
399 typedef typename GET_PROP_TYPE(TypeTag, Scalar) Scalar; \
401 typedef Scalar type; \
402 static const Scalar value; \
404 template <class TypeTag> \
405 const typename Property<TypeTag, TTAG(EffTypeTagName), PTAG(PropTagName)>::type \
406 Property<TypeTag, TTAG(EffTypeTagName), PTAG(PropTagName)>::value(__VA_ARGS__)
415 #define SET_STRING_PROP(EffTypeTagName, PropTagName, ...) \
416 SET_PROP_(EffTypeTagName, \
422 typedef std::string type; \
423 static const std::string value; \
425 template <class TypeTag> \
426 const typename Property<TypeTag, TTAG(EffTypeTagName), PTAG(PropTagName)>::type \
427 Property<TypeTag, TTAG(EffTypeTagName), PTAG(PropTagName)>::value(__VA_ARGS__)
435 #define SET_TAG_PROP(EffTypeTagName, PropTagName, ValueTypeTagName) \
436 SET_PROP_(EffTypeTagName, \
439 TTAG(ValueTypeTagName)) \
441 typedef TTAG(ValueTypeTagName) type; \
453 #define GET_PROP(TypeTag, PropTagName) \
454 ::Ewoms::Properties::GetProperty<TypeTag, PTAG(PropTagName)>::p
455 #define GET_PROP_(TypeTag, PropTag) \
457 ::Ewoms::Properties::GetProperty<TypeTag, PropTag>::p
468 #define GET_PROP_VALUE(TypeTag, PropTagName) \
469 ::Ewoms::Properties::GetProperty<TypeTag, PTAG(PropTagName)>::p::value
470 #define GET_PROP_VALUE_(TypeTag, PropTag) \
472 ::Ewoms::Properties::GetProperty<TypeTag, PropTag>::p::value
485 #define GET_PROP_TYPE(TypeTag, PropTagName) \
486 ::Ewoms::Properties::GetProperty<TypeTag, PTAG(PropTagName)>::p::type
487 #define GET_PROP_TYPE_(TypeTag, PropTag) \
489 ::Ewoms::Properties::GetProperty<TypeTag, PropTag>::p::type
492 #if !defined NO_PROPERTY_INTROSPECTION
510 #define PROP_DIAGNOSTIC(TypeTag, PropTagName) \
511 ::Ewoms::Properties::getDiagnostic<TypeTag>(#PropTagName)
514 #define PROP_DIAGNOSTIC(TypeTag, PropTagName) "Property introspection disabled by macro NO_PROPERTY_INTROSPECTION."
527 #if !defined NO_PROPERTY_INTROSPECTION
531 template <
class EffTypeTag>
538 template <
class EffTypeTagName>
543 template <
class EffTypeTagName,
class PropTagName>
547 class PropertyRegistryKey
550 PropertyRegistryKey()
553 PropertyRegistryKey(
const std::string &effTypeTagName,
554 const std::string &propertyKind,
555 const std::string &propertyName,
556 const std::string &propertyValue,
557 const std::string &fileDefined,
559 : effTypeTagName_(effTypeTagName)
560 , propertyKind_(propertyKind)
561 , propertyName_(propertyName)
562 , propertyValue_(propertyValue)
563 , fileDefined_(fileDefined)
564 , lineDefined_(lineDefined)
569 PropertyRegistryKey(
const PropertyRegistryKey &v)
570 : effTypeTagName_(v.effTypeTagName_)
571 , propertyKind_(v.propertyKind_)
572 , propertyName_(v.propertyName_)
573 , propertyValue_(v.propertyValue_)
574 , fileDefined_(v.fileDefined_)
575 , lineDefined_(v.lineDefined_)
578 const std::string &effTypeTagName()
const
579 {
return effTypeTagName_; }
580 const std::string &propertyKind()
const
581 {
return propertyKind_; }
582 const std::string &propertyName()
const
583 {
return propertyName_; }
584 const std::string &propertyValue()
const
585 {
return propertyValue_; }
586 const std::string &fileDefined()
const
587 {
return fileDefined_; }
588 int lineDefined()
const
589 {
return lineDefined_; }
592 std::string effTypeTagName_;
593 std::string propertyKind_;
594 std::string propertyName_;
595 std::string propertyValue_;
596 std::string fileDefined_;
601 template <
class TypeTag,
class PropertyTag>
604 class TypeTagRegistry
607 struct SpliceRegistryEntryBase {
608 virtual ~SpliceRegistryEntryBase() {};
609 virtual std::string propertyName()
const = 0;
612 template <
class TypeTag,
class PropTag>
613 struct SpliceRegistryEntry :
public SpliceRegistryEntryBase
615 virtual std::string propertyName()
const
616 {
return PropertyInfo<typename GetProperty<TypeTag, PropTag>::template GetEffectiveTypeTag_<TypeTag>::type, PropTag>::propertyName; }
619 typedef std::list<SpliceRegistryEntryBase*> SpliceList;
620 typedef std::map<std::string, SpliceList> SpliceListMap;
622 typedef std::list<std::string> ChildrenList;
623 typedef std::map<std::string, ChildrenList> ChildrenListMap;
627 template <
class TypeTag,
class DummyChild>
628 static void addChildren()
633 template <
class TypeTag,
class Child1,
class Child2,
typename ... RemainingChildren>
634 static void addChildren()
636 std::string typeTagName = Opm::className<TypeTag>();
637 children_[typeTagName].push_front(Opm::className<Child1>());
638 addChildren<TypeTag, Child2, RemainingChildren...>();
643 template <
class TypeTag>
644 static void addSplices()
649 template <
class TypeTag,
class Splice1,
typename ... RemainingSplices>
650 static void addSplices()
652 std::string typeTagName = Opm::className<TypeTag>();
654 SpliceRegistryEntry<TypeTag, Splice1> *tmp =
new SpliceRegistryEntry<TypeTag, Splice1>;
656 splices_[typeTagName].push_front(tmp);
657 addSplices<TypeTag, RemainingSplices...>();
660 static const SpliceList &splices(
const std::string &typeTagName)
661 {
return splices_[typeTagName]; }
663 static const ChildrenList &children(
const std::string &typeTagName)
664 {
return children_[typeTagName]; }
667 static SpliceListMap splices_;
668 static ChildrenListMap children_;
671 TypeTagRegistry::SpliceListMap TypeTagRegistry::splices_;
672 TypeTagRegistry::ChildrenListMap TypeTagRegistry::children_;
674 class PropertyRegistry
677 typedef std::map<std::string, PropertyRegistryKey> KeyList;
678 typedef std::map<std::string, KeyList> KeyListMap;
680 static void addKey(
const PropertyRegistryKey &key)
682 keys_[key.effTypeTagName()][key.propertyName()] = key;
685 static const std::string &getSpliceTypeTagName(
const std::string &typeTagName,
686 const std::string &propertyName)
688 const auto &keyIt = keys_.find(typeTagName);
689 const auto &keyEndIt = keys_.end();
690 if (keyIt == keyEndIt)
691 OPM_THROW(std::runtime_error,
692 "Unknown type tag key '" << typeTagName <<
"'");
696 const auto &propIt = keyIt->second.find(propertyName);
697 const auto &propEndIt = keyIt->second.end();
698 if (propIt != propEndIt)
699 return propIt->second.propertyValue();
702 typedef TypeTagRegistry::ChildrenList ChildrenList;
703 const ChildrenList &children = TypeTagRegistry::children(typeTagName);
704 ChildrenList::const_iterator ttagIt = children.begin();
705 for (; ttagIt != children.end(); ++ttagIt) {
706 const auto &tmp = getSpliceTypeTagName(*ttagIt, propertyName);
713 static std::string tmp(
"");
717 static const PropertyRegistryKey &getKey(
const std::string &effTypeTagName,
718 const std::string &propertyName)
720 return keys_[effTypeTagName][propertyName];
723 static const KeyList &getKeys(
const std::string &effTypeTagName)
725 return keys_[effTypeTagName];
729 static KeyListMap keys_;
731 PropertyRegistry::KeyListMap PropertyRegistry::keys_;
733 #endif // !defined NO_PROPERTY_INTROSPECTION
735 struct PropertyUndefined { };
736 class PropertyExplicitlyUnset {};
738 template <
class RealTypeTag,
739 class EffectiveTypeTag,
741 struct Property :
public PropertyUndefined
744 template <
class EffectiveTypeTag,
746 struct PropertyUnset :
public PropertyUndefined
749 template <
class Tree,
class PropertyTag>
750 struct propertyExplicitlyUnset
752 const static bool value =
753 std::is_base_of<PropertyExplicitlyUnset,
754 PropertyUnset<
typename Tree::SelfType,
759 template <
class Tree,
class PropertyTag>
760 class propertyExplicitlyUnsetOnTree
762 static const bool explicitlyUnset = propertyExplicitlyUnset<Tree, PropertyTag>::value;
764 template <
class ChildTuple>
765 struct unsetOnAllChildren
766 {
static const bool value =
true; };
768 template <
class Child,
class ... RemainingChildren>
769 struct unsetOnAllChildren<
std::tuple<Child, RemainingChildren...> >
770 {
static const bool value =
771 propertyExplicitlyUnsetOnTree<Child, PropertyTag>::value
772 && unsetOnAllChildren<std::tuple<RemainingChildren...> >::value; };
775 static const bool value =
776 (explicitlyUnset || (!Tree::isLeaf && unsetOnAllChildren<typename Tree::ChildrenTuple>::value));
779 template <
class PropertyTag>
780 struct propertyExplicitlyUnsetOnTree<void, PropertyTag>
782 const static bool value = std::true_type::value;
785 template <
class RealTypeTag,
class Tree,
class PropertyTag>
786 struct propertyDefinedOnSelf
788 const static bool value =
789 ! std::is_base_of<PropertyUndefined,
790 Property<RealTypeTag,
791 typename Tree::SelfType,
792 PropertyTag> >::value;
799 template<
typename... Args>
803 template<
unsigned int N,
typename... All>
804 struct RevertedTupleOuter
806 template<
typename Head,
typename... Tail>
807 struct RevertedTupleInner: RevertedTupleOuter<N-1, Head, All...>::template RevertedTupleInner<Tail...> { };
810 template<
typename... All>
811 struct RevertedTupleOuter<0, All...>
813 template<
typename... Tail>
814 struct RevertedTupleInner {
815 typedef std::tuple<All...> type;
820 typedef typename RevertedTupleOuter<
sizeof...(Args)>::
template RevertedTupleInner<Args...>::type type;
823 template <
class SelfT,
824 typename ... Children>
828 typedef SelfT SelfType;
830 typedef typename RevertedTuple<Children...>::type ChildrenTuple;
831 static const bool isLeaf = std::is_same<ChildrenTuple, std::tuple<> >::value;
837 template <
class TypeTag>
840 typedef typename std::tuple<> tuple;
844 template <
class TypeTag,
class PropertyTag>
848 template <
class CurTree,
bool directlyDefined =
849 propertyDefinedOnSelf<TypeTag,
852 struct GetEffectiveTypeTag_
853 {
typedef typename CurTree::SelfType type; };
855 template <
class ...Elements>
856 struct SearchTypeTagList_;
858 template <
class EffectiveTypeTag,
class ...Elements>
859 struct SearchTypeTagList_FirstThenRemaining_;
861 template <
class ...SpliceList>
862 struct SearchSpliceList_;
864 template <
class EffectiveTypeTag,
class ...Splices>
865 struct SearchSpliceList_FirstThenRemaining_;
869 template <
class TypeTagTuple>
870 struct SearchTypeTagTuple_
871 {
typedef void type; };
873 template <
class ...TypeTagList>
874 struct SearchTypeTagTuple_<
std::tuple<TypeTagList...> >
875 {
typedef typename SearchTypeTagList_<TypeTagList...>::type type; };
877 template <
class ...Elements>
878 struct SearchTypeTagList_
879 {
typedef void type; };
881 template <
class FirstElement,
class ...RemainingElements>
882 struct SearchTypeTagList_<FirstElement, RemainingElements...>
884 typedef typename SearchTypeTagList_FirstThenRemaining_<
885 typename GetEffectiveTypeTag_<FirstElement>::type,
886 RemainingElements...>::type type;
889 template <
class EffectiveTypeTag,
class ...Elements>
890 struct SearchTypeTagList_FirstThenRemaining_
891 {
typedef EffectiveTypeTag type; };
893 template <
class ...RemainingElements>
894 struct SearchTypeTagList_FirstThenRemaining_<void, RemainingElements...>
895 {
typedef typename SearchTypeTagList_<RemainingElements...>::type type; };
899 template <
class SpliceTuple>
900 struct SearchSpliceTuple_
901 {
typedef void type; };
903 template <
class ...SpliceList>
904 struct SearchSpliceTuple_<
std::tuple<SpliceList...> >
905 {
typedef typename SearchSpliceList_<SpliceList...>::type type; };
907 template <
class ...SpliceList>
908 struct SearchSpliceList_
909 {
typedef void type; };
911 template <
class FirstSplice,
class ...RemainingSplices>
912 struct SearchSpliceList_<FirstSplice, RemainingSplices...>
914 typedef typename SearchSpliceList_FirstThenRemaining_<
915 typename GetEffectiveTypeTag_<typename GetProperty<TypeTag, FirstSplice>::p::type>::type,
916 RemainingSplices...>::type type;
919 template <
class EffectiveTypeTag,
class ...Splices>
920 struct SearchSpliceList_FirstThenRemaining_
921 {
typedef EffectiveTypeTag type; };
923 template <
class ...RemainingSplices>
924 struct SearchSpliceList_FirstThenRemaining_<void, RemainingSplices...>
925 {
typedef typename SearchSpliceList_<RemainingSplices...>::type type; };
928 template <
class CurTree,
929 class SpliceTypeTag =
typename SearchSpliceTuple_< typename PTag::Splices<CurTree>::tuple >::type >
930 struct SearchSplicesThenChildren_
931 {
typedef SpliceTypeTag type; };
933 template <
class CurTree>
934 struct SearchSplicesThenChildren_<CurTree, void>
935 {
typedef typename SearchTypeTagTuple_<typename CurTree::ChildrenTuple>::type type; };
937 template <
class CurTree>
938 struct GetEffectiveTypeTag_<CurTree, false>
939 {
typedef typename SearchSplicesThenChildren_<CurTree>::type type; };
942 typedef Property<TypeTag, typename GetEffectiveTypeTag_<TypeTag>::type, PropertyTag> p;
945 #if !defined NO_PROPERTY_INTROSPECTION
946 int myReplaceAll_(std::string &s,
947 const std::string &pattern,
948 const std::string &replacement)
952 while ( (pos = s.find(pattern)) != s.npos) {
953 s.replace(pos, pattern.size(), replacement);
959 std::string canonicalTypeTagNameToName_(
const std::string &canonicalName)
961 std::string result(canonicalName);
962 myReplaceAll_(result,
"Ewoms::Properties::TTag::",
"TTAG(");
963 myReplaceAll_(result,
"::",
"");
968 inline bool getDiagnostic_(
const std::string &typeTagName,
969 const std::string &propTagName,
971 const std::string indent)
973 const PropertyRegistryKey *key = 0;
975 const PropertyRegistry::KeyList &keys =
976 PropertyRegistry::getKeys(typeTagName);
977 PropertyRegistry::KeyList::const_iterator it = keys.begin();
978 for (; it != keys.end(); ++it) {
979 if (it->second.propertyName() == propTagName) {
986 std::ostringstream oss;
988 << key->propertyKind() <<
" "
989 << key->propertyName() <<
" defined on '"
990 << canonicalTypeTagNameToName_(key->effTypeTagName()) <<
"' at "
991 << key->fileDefined() <<
":" << key->lineDefined() <<
"\n";
997 typedef TypeTagRegistry::ChildrenList ChildrenList;
998 const ChildrenList &children = TypeTagRegistry::children(typeTagName);
999 ChildrenList::const_iterator ttagIt = children.begin();
1000 std::string newIndent = indent +
" ";
1001 for (; ttagIt != children.end(); ++ttagIt) {
1002 if (getDiagnostic_(*ttagIt, propTagName, result, newIndent)) {
1003 result.insert(0, indent +
"Inherited from " + canonicalTypeTagNameToName_(typeTagName) +
"\n");
1011 template <
class TypeTag>
1012 const std::string getDiagnostic(std::string propTagName)
1016 std::string TypeTagName(Opm::className<TypeTag>());
1018 propTagName.replace(0, strlen(
"PTag("),
"");
1019 int n = propTagName.length();
1020 propTagName.replace(n - 1, 1,
"");
1026 inline void print_(
const std::string &rootTypeTagName,
1027 const std::string &curTypeTagName,
1028 const std::string &splicePropName,
1030 const std::string indent,
1031 std::set<std::string> &printedProperties)
1034 os << indent <<
"###########\n";
1035 os << indent <<
"# Properties\n";
1036 os << indent <<
"###########\n";
1037 os << indent <<
"Properties for " << canonicalTypeTagNameToName_(curTypeTagName) <<
":";
1039 else if (splicePropName !=
"")
1040 os << indent <<
"Inherited from splice " << splicePropName <<
" (set to " << canonicalTypeTagNameToName_(curTypeTagName) <<
"):";
1042 os << indent <<
"Inherited from " << canonicalTypeTagNameToName_(curTypeTagName) <<
":";
1043 const PropertyRegistry::KeyList &keys =
1044 PropertyRegistry::getKeys(curTypeTagName);
1045 PropertyRegistry::KeyList::const_iterator it = keys.begin();
1046 bool somethingPrinted =
false;
1047 for (; it != keys.end(); ++it) {
1048 const PropertyRegistryKey &key = it->second;
1049 if (printedProperties.count(key.propertyName()) > 0)
1051 if (!somethingPrinted) {
1053 somethingPrinted =
true;
1056 << key.propertyKind() <<
" " << key.propertyName();
1057 if (key.propertyKind() !=
"opaque") {
1058 std::string s(key.propertyValue());
1059 myReplaceAll_(s,
"typename ",
"");
1060 if (myReplaceAll_(s,
"::Ewoms::Properties::TTag::",
"TTAG("))
1062 myReplaceAll_(s,
"::Ewoms::Properties::PTag::",
"");
1063 myReplaceAll_(s,
"::Ewoms::Properties::GetProperty<",
"GET_PROP(");
1064 myReplaceAll_(s,
">::p::",
")::");
1065 myReplaceAll_(s,
"GET_PROP(TypeTag, Scalar)::type",
"Scalar");
1067 os <<
" = '" << s <<
"'";
1069 os <<
" defined at " << key.fileDefined()
1070 <<
":" << key.lineDefined()
1072 printedProperties.insert(key.propertyName());
1074 if (!somethingPrinted)
1077 std::string newIndent = indent +
" ";
1080 typedef TypeTagRegistry::SpliceList SpliceList;
1081 const SpliceList &splices = TypeTagRegistry::splices(curTypeTagName);
1082 SpliceList::const_iterator spliceIt = splices.begin();
1083 for (; spliceIt != splices.end(); ++ spliceIt) {
1084 const auto &spliceTypeTagName = PropertyRegistry::getSpliceTypeTagName(rootTypeTagName,
1085 (*spliceIt)->propertyName());
1086 print_(rootTypeTagName, spliceTypeTagName, (*spliceIt)->propertyName(), os, newIndent, printedProperties);
1090 typedef TypeTagRegistry::ChildrenList ChildrenList;
1091 const ChildrenList &children = TypeTagRegistry::children(curTypeTagName);
1092 ChildrenList::const_iterator ttagIt = children.begin();
1093 for (; ttagIt != children.end(); ++ttagIt) {
1094 print_(rootTypeTagName, *ttagIt,
"", os, newIndent, printedProperties);
1098 template <
class TypeTag>
1101 std::set<std::string> printedProps;
1102 print_(Opm::className<TypeTag>(), Opm::className<TypeTag>(),
"", os,
"", printedProps);
1104 #else // !defined NO_PROPERTY_INTROSPECTION
1105 template <
class TypeTag>
1109 "The eWoms property system was compiled with the macro\n"
1110 "NO_PROPERTY_INTROSPECTION defined.\n"
1111 "No diagnostic messages this time, sorry.\n";
1114 template <
class TypeTag>
1115 const std::string getDiagnostic(std::string propTagName)
1119 "The eWoms property system was compiled with the macro\n"
1120 "NO_PROPERTY_INTROSPECTION defined.\n"
1121 "No diagnostic messages this time, sorry.\n";
1125 #endif // !defined NO_PROPERTY_INTROSPECTION
void printValues(std::ostream &os=std::cout)
Print values of the run-time parameters.
Definition: parametersystem.hh:543
Definition: baseauxiliarymodule.hh:35