propertysystem.hh

Go to the documentation of this file.

// -*- mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
// vi: set et ts=4 sw=4 sts=4:
/*
  Copyright (C) 2010-2014 by Andreas Lauser

  This file is part of the Open Porous Media project (OPM).

  OPM is free software: you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation, either version 2 of the License, or
  (at your option) any later version.

  OPM is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with OPM.  If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef EWOMS_PROPERTIES_HH
#define EWOMS_PROPERTIES_HH

#include <opm/material/common/ClassName.hpp>
#include <opm/common/ErrorMacros.hpp>
#include <opm/common/Exceptions.hpp>

#include <type_traits> // required for 'is_base_of<A, B>'

#include <map>
#include <set>
#include <list>
#include <string>
#include <iostream>
#include <sstream>
#include <cstring>
#include <tuple>


namespace Ewoms {
namespace Properties {

#define EWOMS_GET_HEAD_(Arg1, ...) Arg1

#if !defined NO_PROPERTY_INTROSPECTION

#define PROP_INFO_(EffTypeTagName, PropKind, PropTagName, ...)          \
    template <>                                                         \
    struct PropertyInfo<TTAG(EffTypeTagName), PTAG(PropTagName)>        \
    {                                                                   \
        static int init() {                                             \
            propertyName = #PropTagName;                                \
            PropertyRegistryKey key(                                    \
                /*effTypeTagName=*/ Opm::className<TTAG(EffTypeTagName)>(), \
                /*kind=*/PropKind,                                      \
                /*name=*/#PropTagName,                                  \
                /*value=*/#__VA_ARGS__,                                 \
                /*file=*/__FILE__,                                      \
                /*line=*/__LINE__);                                     \
            PropertyRegistry::addKey(key);                              \
            return 0;                                                   \
        }                                                               \
        static std::string propertyName;                                \
        static int foo;                                                 \
    };                                                                  \
    std::string PropertyInfo<TTAG(EffTypeTagName), PTAG(PropTagName)>::propertyName; \
    int PropertyInfo<TTAG(EffTypeTagName), PTAG(PropTagName)>::foo =    \
        PropertyInfo<TTAG(EffTypeTagName), PTAG(PropTagName)>::init();

#define TTAG_INFO_(...)                                     \
    template <>                                             \
    struct TypeTagInfo<EWOMS_GET_HEAD_(__VA_ARGS__)>        \
    {                                                       \
        static int init() {                                 \
            TypeTagRegistry::addChildren<__VA_ARGS__>();    \
            return 0;                                       \
        }                                                   \
        static int foo;                                     \
    };                                                      \
    int TypeTagInfo<EWOMS_GET_HEAD_(__VA_ARGS__)>::foo =    \
        TypeTagInfo<EWOMS_GET_HEAD_(__VA_ARGS__)>::init();

#define SPLICE_INFO_(...)                                   \
    template <>                                             \
    struct SpliceInfo<EWOMS_GET_HEAD_(__VA_ARGS__)>         \
    {                                                       \
        static int init() {                                 \
            TypeTagRegistry::addSplices<__VA_ARGS__>();     \
            return 0;                                       \
        }                                                   \
        static int foo;                                     \
    };                                                      \
    int SpliceInfo<EWOMS_GET_HEAD_(__VA_ARGS__)>::foo =     \
    SpliceInfo<EWOMS_GET_HEAD_(__VA_ARGS__)>::init();

#else
#define PROP_INFO_(EffTypeTagName, PropKind, PropTagName, ...)
#define TTAG_INFO_(EffTypeTagName, ...)
#define SPLICE_INFO_(EffTypeTagName, ...)
#endif

// some macros for simplification


#define TTAG(TypeTagName) Ewoms::Properties::TTag::TypeTagName

#define PTAG(PropTagName) Ewoms::Properties::PTag::PropTagName

#define NEW_TYPE_TAG(...)                       \
    namespace TTag {                            \
    struct EWOMS_GET_HEAD_(__VA_ARGS__, blubb)  \
        : public TypeTag<__VA_ARGS__>           \
    { };                                        \
    TTAG_INFO_(__VA_ARGS__, void)               \
    }                                           \
    extern int semicolonHack_

#define SET_SPLICES(TypeTagName, ...)                               \
    namespace PTag {                                                \
    template<>                                                      \
    struct Splices<TTAG(TypeTagName)>                               \
    {                                                               \
        typedef RevertedTuple<__VA_ARGS__>::type tuple;             \
    };                                                              \
    SPLICE_INFO_(TTAG(TypeTagName), __VA_ARGS__)                    \
    }                                                               \
    extern int semicolonHack_

#define INHERITS_FROM(...) __VA_ARGS__

#define NEW_PROP_TAG(PTagName)                      \
    namespace PTag {                                \
    struct PTagName; } extern int semicolonHack_

#define SET_PROP_(EffTypeTagName, PropKind, PropTagName, ...)   \
    template <class TypeTag>                                    \
    struct Property<TypeTag,                                    \
                    TTAG(EffTypeTagName),                       \
                    PTAG(PropTagName)>;                         \
    PROP_INFO_(EffTypeTagName,                                  \
               /*kind=*/PropKind,                               \
               PropTagName,                                     \
               /*value=*/__VA_ARGS__)                           \
    template <class TypeTag>                                    \
    struct Property<TypeTag,                                    \
                    TTAG(EffTypeTagName),                       \
                    PTAG(PropTagName) >

#define SET_PROP(EffTypeTagName, PropTagName)   \
    template <class TypeTag>                    \
    struct Property<TypeTag,                    \
                    TTAG(EffTypeTagName),       \
                    PTAG(PropTagName)>;         \
    PROP_INFO_(EffTypeTagName,                  \
               /*kind=*/"opaque",               \
               PropTagName,                     \
               /*value=*/"<opaque>")            \
    template <class TypeTag>                    \
    struct Property<TypeTag,                    \
                    TTAG(EffTypeTagName),       \
                    PTAG(PropTagName) >

#define UNSET_PROP(EffTypeTagName, PropTagName) \
    template <>                                 \
    struct PropertyUnset<TTAG(EffTypeTagName),  \
                         PTAG(PropTagName) >;   \
    PROP_INFO_(EffTypeTagName,                  \
               /*kind=*/"withdraw",             \
               PropTagName,                     \
               /*value=*/<none>)                \
    template <>                                 \
    struct PropertyUnset<TTAG(EffTypeTagName),  \
                         PTAG(PropTagName) >    \
            : public PropertyExplicitlyUnset    \
    {}

#define SET_INT_PROP(EffTypeTagName, PropTagName, /*Value*/...) \
    SET_PROP_(EffTypeTagName,                                   \
              /*kind=*/"int   ",                                \
              PropTagName,                                      \
              /*value=*/__VA_ARGS__)                            \
    {                                                           \
        typedef int type;                                       \
        static const int value = __VA_ARGS__;                   \
    }

#define SET_BOOL_PROP(EffTypeTagName, PropTagName, /*Value*/...)    \
    SET_PROP_(EffTypeTagName,                                       \
              /*kind=*/"bool  ",                                    \
              PropTagName,                                          \
              /*value=*/__VA_ARGS__)                                \
    {                                                               \
        typedef bool type;                                          \
        static const bool value = __VA_ARGS__;                      \
    }

#define SET_TYPE_PROP(EffTypeTagName, PropTagName, /*Value*/...)  \
    SET_PROP_(EffTypeTagName,                                     \
              /*kind=*/"type  ",                                  \
              PropTagName,                                        \
              /*value=*/__VA_ARGS__)                              \
    {                                                             \
        typedef __VA_ARGS__ type;                                 \
    }

#define SET_SCALAR_PROP(EffTypeTagName, PropTagName, ...)               \
    SET_PROP_(EffTypeTagName,                                           \
              /*kind=*/"scalar",                                        \
              PropTagName,                                              \
              /*value=*/__VA_ARGS__)                                    \
    {                                                                   \
        typedef typename GET_PROP_TYPE(TypeTag, Scalar) Scalar;         \
    public:                                                             \
        typedef Scalar type;                                            \
        static const Scalar value;                                      \
    };                                                                  \
    template <class TypeTag>                                            \
    const typename Property<TypeTag, TTAG(EffTypeTagName), PTAG(PropTagName)>::type \
    Property<TypeTag, TTAG(EffTypeTagName), PTAG(PropTagName)>::value(__VA_ARGS__)

#define SET_STRING_PROP(EffTypeTagName, PropTagName, ...)               \
    SET_PROP_(EffTypeTagName,                                           \
              /*kind=*/"string",                                        \
              PropTagName,                                              \
              /*value=*/__VA_ARGS__)                                    \
    {                                                                   \
    public:                                                             \
        typedef std::string type;                                       \
        static const std::string value;                                 \
    };                                                                  \
    template <class TypeTag>                                            \
    const typename Property<TypeTag, TTAG(EffTypeTagName), PTAG(PropTagName)>::type \
    Property<TypeTag, TTAG(EffTypeTagName), PTAG(PropTagName)>::value(__VA_ARGS__)

#define SET_TAG_PROP(EffTypeTagName, PropTagName, ValueTypeTagName) \
    SET_PROP_(EffTypeTagName,                                     \
              /*kind=*/"tag   ",                                  \
              PropTagName,                                        \
              /*value=*/TTAG(ValueTypeTagName))                   \
    {                                                             \
        typedef TTAG(ValueTypeTagName) type;                      \
    }


#define GET_PROP(TypeTag, PropTagName) \
    ::Ewoms::Properties::GetProperty<TypeTag, PTAG(PropTagName)>::p
#define GET_PROP_(TypeTag, PropTag) \
    ::Ewoms::Properties::GetProperty<TypeTag, PropTag>::p

#define GET_PROP_VALUE(TypeTag, PropTagName)                            \
    ::Ewoms::Properties::GetProperty<TypeTag, PTAG(PropTagName)>::p::value
#define GET_PROP_VALUE_(TypeTag, PropTag)                               \
    ::Ewoms::Properties::GetProperty<TypeTag, PropTag>::p::value

#define GET_PROP_TYPE(TypeTag, PropTagName) \
    ::Ewoms::Properties::GetProperty<TypeTag, PTAG(PropTagName)>::p::type
#define GET_PROP_TYPE_(TypeTag, PropTag) \
    ::Ewoms::Properties::GetProperty<TypeTag, PropTag>::p::type

#if !defined NO_PROPERTY_INTROSPECTION

#define PROP_DIAGNOSTIC(TypeTag, PropTagName) \
    ::Ewoms::Properties::getDiagnostic<TypeTag>(#PropTagName)

#else
#define PROP_DIAGNOSTIC(TypeTag, PropTagName) "Property introspection disabled by macro NO_PROPERTY_INTROSPECTION."
#endif

// some serious template kung fu. Don't look at it too closely, it
// might damage your brain!


namespace PTag {}
namespace TTag {}

#if !defined NO_PROPERTY_INTROSPECTION

namespace TTag
{
template <class EffTypeTag>
struct TypeTagInfo
{};
}

namespace PTag
{
template <class EffTypeTagName>
struct SpliceInfo
{};
}

template <class EffTypeTagName, class PropTagName>
struct PropertyInfo
{};

class PropertyRegistryKey
{
public:
    PropertyRegistryKey()
    {}

    PropertyRegistryKey(const std::string &effTypeTagName,
                        const std::string &propertyKind,
                        const std::string &propertyName,
                        const std::string &propertyValue,
                        const std::string &fileDefined,
                        int lineDefined)
        : effTypeTagName_(effTypeTagName)
        , propertyKind_(propertyKind)
        , propertyName_(propertyName)
        , propertyValue_(propertyValue)
        , fileDefined_(fileDefined)
        , lineDefined_(lineDefined)
    {
    }

    // copy constructor
    PropertyRegistryKey(const PropertyRegistryKey &v)
        : effTypeTagName_(v.effTypeTagName_)
        , propertyKind_(v.propertyKind_)
        , propertyName_(v.propertyName_)
        , propertyValue_(v.propertyValue_)
        , fileDefined_(v.fileDefined_)
        , lineDefined_(v.lineDefined_)
    {}

    const std::string &effTypeTagName() const
    { return effTypeTagName_; }
    const std::string &propertyKind() const
    { return propertyKind_; }
    const std::string &propertyName() const
    { return propertyName_; }
    const std::string &propertyValue() const
    { return propertyValue_; }
    const std::string &fileDefined() const
    { return fileDefined_; }
    int lineDefined() const
    { return lineDefined_; }

private:
    std::string effTypeTagName_;
    std::string propertyKind_;
    std::string propertyName_;
    std::string propertyValue_;
    std::string fileDefined_;
    int lineDefined_;
};


template <class TypeTag, class PropertyTag>
struct GetProperty;

class TypeTagRegistry
{
public:
    struct SpliceRegistryEntryBase {
        virtual ~SpliceRegistryEntryBase() {};
        virtual std::string propertyName() const = 0;
    };

    template <class TypeTag, class PropTag>
    struct SpliceRegistryEntry : public SpliceRegistryEntryBase
    {
        virtual std::string propertyName() const
        { return PropertyInfo<typename GetProperty<TypeTag, PropTag>::template GetEffectiveTypeTag_<TypeTag>::type, PropTag>::propertyName; }
    };

    typedef std::list<SpliceRegistryEntryBase*> SpliceList;
    typedef std::map<std::string, SpliceList> SpliceListMap;

    typedef std::list<std::string> ChildrenList;
    typedef std::map<std::string, ChildrenList> ChildrenListMap;

    // end of recursion. the last argument is not a child, but 'void'
    // which is required for the macro magic...
    template <class TypeTag, class DummyChild>
    static void addChildren()
    {}

    // the last argument is not a child, but 'void' which is required
    // for the macro magic...
    template <class TypeTag, class Child1, class Child2, typename ... RemainingChildren>
    static void addChildren()
    {
        std::string typeTagName = Opm::className<TypeTag>();
        children_[typeTagName].push_front(Opm::className<Child1>());
        addChildren<TypeTag, Child2, RemainingChildren...>();
    }

    // end of recursion. the last argument is not a child, but 'void'
    // which is required for the macro magic...
    template <class TypeTag>
    static void addSplices()
    { }

    // the last argument is not a child, but 'void' which is required
    // for the macro magic...
    template <class TypeTag, class Splice1, typename ... RemainingSplices>
    static void addSplices()
    {
        std::string typeTagName = Opm::className<TypeTag>();

        SpliceRegistryEntry<TypeTag, Splice1> *tmp = new SpliceRegistryEntry<TypeTag, Splice1>;

        splices_[typeTagName].push_front(tmp);
        addSplices<TypeTag, RemainingSplices...>();
    }

    static const SpliceList &splices(const std::string &typeTagName)
    { return splices_[typeTagName]; }

    static const ChildrenList &children(const std::string &typeTagName)
    { return children_[typeTagName]; }

private:
    static SpliceListMap splices_;
    static ChildrenListMap children_;
};

TypeTagRegistry::SpliceListMap TypeTagRegistry::splices_;
TypeTagRegistry::ChildrenListMap TypeTagRegistry::children_;

class PropertyRegistry
{
public:
    typedef std::map<std::string, PropertyRegistryKey> KeyList;
    typedef std::map<std::string, KeyList> KeyListMap;

    static void addKey(const PropertyRegistryKey &key)
    {
        keys_[key.effTypeTagName()][key.propertyName()] = key;
    }

    static const std::string &getSpliceTypeTagName(const std::string &typeTagName,
                                                   const std::string &propertyName)
    {
        const auto &keyIt = keys_.find(typeTagName);
        const auto &keyEndIt = keys_.end();
        if (keyIt == keyEndIt)
            OPM_THROW(std::runtime_error,
                      "Unknown type tag key '" << typeTagName << "'");

        // check whether the propery is defined for the type tag
        // currently checked
        const auto &propIt = keyIt->second.find(propertyName);
        const auto &propEndIt = keyIt->second.end();
        if (propIt != propEndIt)
            return propIt->second.propertyValue();

        // if not, check all children
        typedef TypeTagRegistry::ChildrenList ChildrenList;
        const ChildrenList &children = TypeTagRegistry::children(typeTagName);
        ChildrenList::const_iterator ttagIt = children.begin();
        for (; ttagIt != children.end(); ++ttagIt) {
            const auto &tmp = getSpliceTypeTagName(*ttagIt, propertyName);
            if (tmp != "")
                return tmp;
        }

        // if the property was not defined on a given type tag, return
        // the empty string.
        static std::string tmp("");
        return tmp;
    }

    static const PropertyRegistryKey &getKey(const std::string &effTypeTagName,
                                             const std::string &propertyName)
    {
        return keys_[effTypeTagName][propertyName];
    }

    static const KeyList &getKeys(const std::string &effTypeTagName)
    {
        return keys_[effTypeTagName];
    }

private:
    static KeyListMap keys_;
};
PropertyRegistry::KeyListMap PropertyRegistry::keys_;

#endif // !defined NO_PROPERTY_INTROSPECTION

struct PropertyUndefined { };
class PropertyExplicitlyUnset {};

template <class RealTypeTag,
          class EffectiveTypeTag,
          class PropertyTag>
struct Property : public PropertyUndefined
{};

template <class EffectiveTypeTag,
          class PropertyTag>
struct PropertyUnset : public PropertyUndefined
{};

template <class Tree, class PropertyTag>
struct propertyExplicitlyUnset
{
    const static bool value =
        std::is_base_of<PropertyExplicitlyUnset,
                        PropertyUnset<typename Tree::SelfType,
                                      PropertyTag>
                        >::value;
};

template <class Tree, class PropertyTag>
class propertyExplicitlyUnsetOnTree
{
    static const bool explicitlyUnset = propertyExplicitlyUnset<Tree, PropertyTag>::value;

    template <class ChildTuple>
    struct unsetOnAllChildren
    { static const bool value = true; };

    template <class Child, class ... RemainingChildren>
    struct unsetOnAllChildren<std::tuple<Child, RemainingChildren...> >
    { static const bool value =
            propertyExplicitlyUnsetOnTree<Child, PropertyTag>::value
            && unsetOnAllChildren<std::tuple<RemainingChildren...> >::value; };

public:
    static const bool value =
        (explicitlyUnset || (!Tree::isLeaf && unsetOnAllChildren<typename Tree::ChildrenTuple>::value));
};

template <class PropertyTag>
struct propertyExplicitlyUnsetOnTree<void, PropertyTag>
{
    const static bool value = std::true_type::value;
};

template <class RealTypeTag, class Tree, class PropertyTag>
struct propertyDefinedOnSelf
{
    const static bool value =
        ! std::is_base_of<PropertyUndefined,
                          Property<RealTypeTag,
                                   typename Tree::SelfType,
                                   PropertyTag> >::value;
};

// template class to revert the order or a std::tuple's
// arguments. This is required to make the properties of children
// defined on the right overwrite the properties of the previous
// children. See https://sydius.me/2011/07/reverse-tuple-in-c/
template<typename... Args>
class RevertedTuple
{
private:
    template<unsigned int N, typename... All>
    struct RevertedTupleOuter
    {
        template<typename Head, typename... Tail>
        struct RevertedTupleInner: RevertedTupleOuter<N-1, Head, All...>::template RevertedTupleInner<Tail...> { };
    };

    template<typename... All>
    struct RevertedTupleOuter<0, All...>
    {
        template<typename... Tail>
        struct RevertedTupleInner {
            typedef std::tuple<All...> type;
        };
    };

public:
    typedef typename RevertedTupleOuter<sizeof...(Args)>::template RevertedTupleInner<Args...>::type type;
};

template <class SelfT,
          typename ... Children>
class TypeTag
{
public:
    typedef SelfT SelfType;

    typedef typename RevertedTuple<Children...>::type ChildrenTuple;
    static const bool isLeaf = std::is_same<ChildrenTuple, std::tuple<> >::value;
};

namespace PTag {
// this class needs to be located in the PTag namespace for reasons
// you don't really want to know...
template <class TypeTag>
struct Splices
{
    typedef typename std::tuple<> tuple;
};
} // namespace PTag

template <class TypeTag, class PropertyTag>
struct GetProperty
{
    // find the type tag for which the property is defined
    template <class CurTree, bool directlyDefined =
                  propertyDefinedOnSelf<TypeTag,
                                        CurTree,
                                        PropertyTag>::value>
    struct GetEffectiveTypeTag_
    { typedef typename CurTree::SelfType type; };

    template <class ...Elements>
    struct SearchTypeTagList_;

    template <class EffectiveTypeTag, class ...Elements>
    struct SearchTypeTagList_FirstThenRemaining_;

    template <class ...SpliceList>
    struct SearchSpliceList_;

    template <class EffectiveTypeTag, class ...Splices>
    struct SearchSpliceList_FirstThenRemaining_;

    // find the first type tag in a tuple for which the property is
    // defined
    template <class TypeTagTuple>
    struct SearchTypeTagTuple_
    { typedef void type; };

    template <class ...TypeTagList>
    struct SearchTypeTagTuple_<std::tuple<TypeTagList...> >
    { typedef typename SearchTypeTagList_<TypeTagList...>::type type; };

    template <class ...Elements>
    struct SearchTypeTagList_
    { typedef void type; };

    template <class FirstElement, class ...RemainingElements>
    struct SearchTypeTagList_<FirstElement, RemainingElements...>
    {
        typedef typename SearchTypeTagList_FirstThenRemaining_<
            typename GetEffectiveTypeTag_<FirstElement>::type,
            RemainingElements...>::type type;
    };

    template <class EffectiveTypeTag, class ...Elements>
    struct SearchTypeTagList_FirstThenRemaining_
    { typedef EffectiveTypeTag type; };

    template <class ...RemainingElements>
    struct SearchTypeTagList_FirstThenRemaining_<void, RemainingElements...>
    { typedef typename SearchTypeTagList_<RemainingElements...>::type type; };

    // find the first type tag in a tuple of splices for which the
    // property is defined
    template <class SpliceTuple>
    struct SearchSpliceTuple_
    { typedef void type; };

    template <class ...SpliceList>
    struct SearchSpliceTuple_<std::tuple<SpliceList...> >
    { typedef typename SearchSpliceList_<SpliceList...>::type type; };

    template <class ...SpliceList>
    struct SearchSpliceList_
    { typedef void type; };

    template <class FirstSplice, class ...RemainingSplices>
    struct SearchSpliceList_<FirstSplice, RemainingSplices...>
    {
        typedef typename SearchSpliceList_FirstThenRemaining_<
            typename GetEffectiveTypeTag_<typename GetProperty<TypeTag, FirstSplice>::p::type>::type,
            RemainingSplices...>::type type;
    };

    template <class EffectiveTypeTag, class ...Splices>
    struct SearchSpliceList_FirstThenRemaining_
    { typedef EffectiveTypeTag type; };

    template <class ...RemainingSplices>
    struct SearchSpliceList_FirstThenRemaining_<void, RemainingSplices...>
    { typedef typename SearchSpliceList_<RemainingSplices...>::type type; };

    // find the splice or the child type tag for which the property is defined
    template <class CurTree,
              class SpliceTypeTag = typename SearchSpliceTuple_< typename PTag::Splices<CurTree>::tuple >::type >
    struct SearchSplicesThenChildren_
    { typedef SpliceTypeTag type; };

    template <class CurTree>
    struct SearchSplicesThenChildren_<CurTree, void>
    { typedef typename SearchTypeTagTuple_<typename CurTree::ChildrenTuple>::type type; };

    template <class CurTree>
    struct GetEffectiveTypeTag_<CurTree, /*directlyDefined = */false>
    { typedef typename SearchSplicesThenChildren_<CurTree>::type type; };

public:
    typedef Property<TypeTag, typename GetEffectiveTypeTag_<TypeTag>::type, PropertyTag> p;
};

#if !defined NO_PROPERTY_INTROSPECTION
int myReplaceAll_(std::string &s,
                   const std::string &pattern,
                   const std::string &replacement)
{
    size_t pos;
    int i = 0;
    while ( (pos = s.find(pattern)) != s.npos) {
        s.replace(pos, pattern.size(), replacement);
        ++i;
    };
    return i;
}

std::string canonicalTypeTagNameToName_(const std::string &canonicalName)
{
    std::string result(canonicalName);
    myReplaceAll_(result, "Ewoms::Properties::TTag::", "TTAG(");
    myReplaceAll_(result, "::", "");
    result += ")";
    return result;
}

inline bool getDiagnostic_(const std::string &typeTagName,
                           const std::string &propTagName,
                           std::string &result,
                           const std::string indent)
{
    const PropertyRegistryKey *key = 0;

    const PropertyRegistry::KeyList &keys =
        PropertyRegistry::getKeys(typeTagName);
    PropertyRegistry::KeyList::const_iterator it = keys.begin();
    for (; it != keys.end(); ++it) {
        if (it->second.propertyName() == propTagName) {
            key = &it->second;
            break;
        };
    }

    if (key) {
        std::ostringstream oss;
        oss << indent
            << key->propertyKind() << " "
            << key->propertyName() << " defined on '"
            << canonicalTypeTagNameToName_(key->effTypeTagName()) << "' at "
            << key->fileDefined() << ":" << key->lineDefined() << "\n";
        result = oss.str();
        return true;
    }

    // print properties defined on children
    typedef TypeTagRegistry::ChildrenList ChildrenList;
    const ChildrenList &children = TypeTagRegistry::children(typeTagName);
    ChildrenList::const_iterator ttagIt = children.begin();
    std::string newIndent = indent + "  ";
    for (; ttagIt != children.end(); ++ttagIt) {
        if (getDiagnostic_(*ttagIt, propTagName, result, newIndent)) {
            result.insert(0, indent + "Inherited from " + canonicalTypeTagNameToName_(typeTagName) + "\n");
            return true;
        }
    }

    return false;
}

template <class TypeTag>
const std::string getDiagnostic(std::string propTagName)
{
    std::string result;

    std::string TypeTagName(Opm::className<TypeTag>());

    propTagName.replace(0, strlen("PTag("), "");
    int n = propTagName.length();
    propTagName.replace(n - 1, 1, "");
    //TypeTagName.replace(0, strlen("Ewoms::Properties::TTag::"), "");

    return result;
}

inline void print_(const std::string &rootTypeTagName,
                   const std::string &curTypeTagName,
                   const std::string &splicePropName,
                   std::ostream &os,
                   const std::string indent,
                   std::set<std::string> &printedProperties)
{
    if (indent == "") {
        os << indent << "###########\n";
        os << indent << "# Properties\n";
        os << indent << "###########\n";
        os << indent << "Properties for " << canonicalTypeTagNameToName_(curTypeTagName) << ":";
    }
    else if (splicePropName != "")
        os << indent << "Inherited from splice " << splicePropName << " (set to " << canonicalTypeTagNameToName_(curTypeTagName) << "):";
    else
        os << indent << "Inherited from " << canonicalTypeTagNameToName_(curTypeTagName) << ":";
    const PropertyRegistry::KeyList &keys =
        PropertyRegistry::getKeys(curTypeTagName);
    PropertyRegistry::KeyList::const_iterator it = keys.begin();
    bool somethingPrinted = false;
    for (; it != keys.end(); ++it) {
        const PropertyRegistryKey &key = it->second;
        if (printedProperties.count(key.propertyName()) > 0)
            continue; // property already printed
        if (!somethingPrinted) {
            os << "\n";
            somethingPrinted = true;
        }
        os << indent << "  "
           << key.propertyKind() << " " << key.propertyName();
        if (key.propertyKind() != "opaque") {
            std::string s(key.propertyValue());
            myReplaceAll_(s, "typename ", "");
            if (myReplaceAll_(s, "::Ewoms::Properties::TTag::", "TTAG("))
                s += ')';
            myReplaceAll_(s, "::Ewoms::Properties::PTag::", "");
            myReplaceAll_(s, "::Ewoms::Properties::GetProperty<", "GET_PROP(");
            myReplaceAll_(s, ">::p::", ")::");
            myReplaceAll_(s, "GET_PROP(TypeTag, Scalar)::type", "Scalar");

            os << " = '" << s << "'";
        }
        os << " defined at " << key.fileDefined()
           << ":" << key.lineDefined()
           << "\n";
        printedProperties.insert(key.propertyName());
    };
    if (!somethingPrinted)
        os << " (none)\n";
    // print properties defined on splices or children
    std::string newIndent = indent + "  ";

    // first, iterate over the splices, ...
    typedef TypeTagRegistry::SpliceList SpliceList;
    const SpliceList &splices = TypeTagRegistry::splices(curTypeTagName);
    SpliceList::const_iterator spliceIt = splices.begin();
    for (; spliceIt != splices.end(); ++ spliceIt) {
        const auto &spliceTypeTagName = PropertyRegistry::getSpliceTypeTagName(rootTypeTagName,
                                                                               (*spliceIt)->propertyName());
        print_(rootTypeTagName, spliceTypeTagName, (*spliceIt)->propertyName(), os, newIndent, printedProperties);
    }

    // ... then, over the children
    typedef TypeTagRegistry::ChildrenList ChildrenList;
    const ChildrenList &children = TypeTagRegistry::children(curTypeTagName);
    ChildrenList::const_iterator ttagIt = children.begin();
    for (; ttagIt != children.end(); ++ttagIt) {
        print_(rootTypeTagName, *ttagIt, /*splicePropName=*/"", os, newIndent, printedProperties);
    }
}

template <class TypeTag>
void printValues(std::ostream &os = std::cout)
{
    std::set<std::string> printedProps;
    print_(Opm::className<TypeTag>(), Opm::className<TypeTag>(), /*splicePropertyName=*/"", os, /*indent=*/"", printedProps);
}
#else // !defined NO_PROPERTY_INTROSPECTION
template <class TypeTag>
void printValues(std::ostream &os = std::cout)
{
    std::cout <<
        "The eWoms property system was compiled with the macro\n"
        "NO_PROPERTY_INTROSPECTION defined.\n"
        "No diagnostic messages this time, sorry.\n";
}

template <class TypeTag>
const std::string getDiagnostic(std::string propTagName)
{
    std::string result;
    result =
        "The eWoms property system was compiled with the macro\n"
        "NO_PROPERTY_INTROSPECTION defined.\n"
        "No diagnostic messages this time, sorry.\n";
    return result;
}

#endif // !defined NO_PROPERTY_INTROSPECTION


} // namespace Properties
} // namespace Ewoms

#endif