propertysystemmacros.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:
/*****************************************************************************
 *   See the file COPYING for full copying permissions.                      *
 *                                                                           *
 *   This program 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 3 of the License, or       *
 *   (at your option) any later version.                                     *
 *                                                                           *
 *   This program is distributed in the hope that it will be useful,         *
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
 *   MERCHANTBILITY 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 this program.  If not, see <http://www.gnu.org/licenses/>.   *
 *****************************************************************************/
#ifndef DUMUX_PROPERTY_SYSTEM_MACROS_HH
#define DUMUX_PROPERTY_SYSTEM_MACROS_HH
#warning "Property macros are deprecated and will be removed after release 3.2. \
If you are not using property macros you can disable this warning by \
setting DUMUX_ENABLE_OLD_PROPERTY_MACROS to 0 (false) when configuring DuMux. \
DUMUX_ENABLE_OLD_PROPERTY_MACROS defaults to 1 (true) until release 3.1. \
After release 3.1 it will default to 0 (false) so you will have to manually \
enable property macros in order to use them."
 
#include <cstddef>
 
#include <dumux/common/properties/propertysystem.hh>
 
namespace Dumux {
namespace Properties {
 
namespace TTag {}
 
#define TTAG(TypeTagName) ::Dumux::Properties::TTag::TypeTagName
 
//#define PTAG(PropTagName) PropTagName
 
#define PTAG_(PropTagName) ::Dumux::Properties::PropTagName
 
 
// in the old property system the order in inherit_from was the other way around
// this flips the order of a tuple to restore old behaviour when using the macro.
// when you are using non-macro version make sure to flip the order.
template<class Tuple, class IndexSequence>
struct ReverseTupleImpl;
 
template<class Tuple, size_t... I>
struct ReverseTupleImpl<Tuple, std::index_sequence<I...>>
{
  using type = std::tuple<std::tuple_element_t<sizeof...(I) - 1 - I, Tuple>...>;
};
 
// revert tuple argument order
template<class Tuple>
using ReverseTuple = typename ReverseTupleImpl<Tuple, std::make_index_sequence<std::tuple_size<Tuple>::value>>::type;
 
// a temporary hack to make the macro still work, we set using InheritsFrom = void,
// which gets picked up by the new property as non inheritance, this can be removed
// once all macros are gone
namespace Detail {
template<class TypeTagTuple>
struct GetTypeTagInheritance;
 
template<class OneTypeTag>
struct GetTypeTagInheritance<std::tuple<OneTypeTag>>
{
    using type = void;
};
 
template<class FirstTypeTag, class ...OtherTypeTags>
struct GetTypeTagInheritance<std::tuple<FirstTypeTag, OtherTypeTags...>>
{
    // reverse order to restore old behaviour
    using type = ReverseTuple<std::tuple<OtherTypeTags...>>;
};
} // end namespace Detail
 
#define DUMUX_GET_HEAD_(Arg1, ...) Arg1
 
#define NEW_TYPE_TAG(...)                                                          \
    namespace TTag {                                                               \
    struct DUMUX_GET_HEAD_(__VA_ARGS__)                                            \
    { using InheritsFrom = Detail::GetTypeTagInheritance<std::tuple<__VA_ARGS__>>::type; };   \
    } extern int semicolonHack_
 
#define INHERITS_FROM(...) __VA_ARGS__
 
#define NEW_PROP_TAG(PTagName)                             \
    template<class TypeTag, class MyTypeTag>               \
    struct PTagName { using type = UndefinedProperty; };   \
    extern int semicolonHack_
 
#define SET_PROP(EffTypeTagName, PropTagName)                   \
    template <class TypeTag>                                    \
    struct PropTagName<TypeTag, TTAG(EffTypeTagName)>
 
#define SET_INT_PROP(EffTypeTagName, PropTagName, /*Value*/...)    \
    template <class TypeTag>                                    \
    struct PropTagName<TypeTag, TTAG(EffTypeTagName)>     \
    {                                                           \
        using type = int;                                       \
        static constexpr int value = __VA_ARGS__;               \
    }
 
#define SET_BOOL_PROP(EffTypeTagName, PropTagName, /*Value*/...)    \
    template <class TypeTag>                                    \
    struct PropTagName<TypeTag, TTAG(EffTypeTagName)>     \
    {                                                           \
        using type = bool;                                       \
        static constexpr bool value = __VA_ARGS__;               \
    }
 
#define SET_TYPE_PROP(EffTypeTagName, PropTagName, /*Value*/...)  \
    template <class TypeTag>                                      \
    struct PropTagName<TypeTag, TTAG(EffTypeTagName)>             \
    {                                                             \
        using type = __VA_ARGS__;                                 \
    }
 
#define SET_SCALAR_PROP(EffTypeTagName, PropTagName, ...)               \
    template <class TypeTag>                                    \
    struct PropTagName<TypeTag, TTAG(EffTypeTagName)>     \
    {                                                           \
        using Scalar = Dumux::GetPropType<TypeTag, Scalar>;            \
    public:                                                             \
        using type = Scalar;                                            \
        static const Scalar value;                                      \
    };                                                                  \
    template <class TypeTag>                                            \
    const typename PropTagName<TypeTag, TTAG(EffTypeTagName)>::type   \
    PropTagName<TypeTag, TTAG(EffTypeTagName)>::value(__VA_ARGS__)
 
#define SET_STRING_PROP(EffTypeTagName, PropTagName, ...)               \
    template <class TypeTag>                                    \
    struct PropTagName<TypeTag, TTAG(EffTypeTagName)>     \
    {                                                           \
    public:                                                             \
        using type = std::string;                                            \
        static const std::string value;                                      \
    };                                                                  \
    template <class TypeTag>                                            \
    const typename PropTagName<TypeTag, TTAG(EffTypeTagName)>::type   \
    PropTagName<TypeTag, TTAG(EffTypeTagName)>::value(__VA_ARGS__)
 
 
// getters
#define GET_PROP(TypeTag, PropTagName) ::Dumux::Properties::Detail::GetPropImpl<TypeTag, PTAG_(PropTagName)>::type
#define GET_PROP_VALUE(TypeTag, PropTagName) ::Dumux::Properties::Detail::GetPropImpl<TypeTag, PTAG_(PropTagName)>::type::value
#define GET_PROP_TYPE(TypeTag, PropTagName) ::Dumux::Properties::Detail::GetPropImpl<TypeTag, PTAG_(PropTagName)>::type::type
 
} // namespace Properties
} // namespace Dumux
 
#endif // DUMUX_PROPERTY_SYSTEM_HH