ExtensibleEnum.h

Go to the documentation of this file.

/*
 * Copyright (C) 2017 by
 *   MetraLabs GmbH (MLAB), GERMANY
 * and
 *   Neuroinformatics and Cognitive Robotics Labs (NICR) at TU Ilmenau, GERMANY
 * All rights reserved.
 *
 * Contact: info@mira-project.org
 *
 * Commercial Usage:
 *   Licensees holding valid commercial licenses may use this file in
 *   accordance with the commercial license agreement provided with the
 *   software or, alternatively, in accordance with the terms contained in
 *   a written agreement between you and MLAB or NICR.
 *
 * GNU General Public License Usage:
 *   Alternatively, this file may be used under the terms of the GNU
 *   General Public License version 3.0 as published by the Free Software
 *   Foundation and appearing in the file LICENSE.GPL3 included in the
 *   packaging of this file. Please review the following information to
 *   ensure the GNU General Public License version 3.0 requirements will be
 *   met: http://www.gnu.org/copyleft/gpl.html.
 *   Alternatively you may (at your option) use any later version of the GNU
 *   General Public License if such license has been publicly approved by
 *   MLAB and NICR (or its successors, if any).
 *
 * IN NO EVENT SHALL "MLAB" OR "NICR" BE LIABLE TO ANY PARTY FOR DIRECT,
 * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES ARISING OUT OF
 * THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF "MLAB" OR
 * "NICR" HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * "MLAB" AND "NICR" SPECIFICALLY DISCLAIM ANY WARRANTIES, INCLUDING,
 * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
 * FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS
 * ON AN "AS IS" BASIS, AND "MLAB" AND "NICR" HAVE NO OBLIGATION TO
 * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS OR MODIFICATIONS.
 */

#ifndef _MIRA_EXTENSIBLEENUM_H_
#define _MIRA_EXTENSIBLEENUM_H_

#include <type_traits>

#include <boost/preprocessor/tuple/to_seq.hpp>
#include <boost/preprocessor/seq/for_each.hpp>

#include <boost/thread/mutex.hpp>

#include <utils/VariadicMacro.h>

#include <serialization/SplitReflect.h>
#include <serialization/JSONSerializer.h>

namespace mira {


namespace detail {
// implementations of variants of extensible enum


// CRTP ensures we have no common base class between derived enum classes
// -> we can detect mixup at compile time
template<typename T>
struct NoValueEnum
{
public:
    bool operator==(const NoValueEnum<T>& other) const { return ref == other.ref; }
    bool operator!=(const NoValueEnum<T>& other) const { return ref != other.ref; }

protected:
    NoValueEnum<T>() : ref(this) {}

private:
    NoValueEnum<T> const * ref;
};


// we want one mutex per counter -> need all template parameters from
// AutoCountingEnum, even though we don't use all
template<typename T, typename CountType=int, bool UseMutex=false>
struct AutoCountingHelper
{
    static void count(CountType& i, CountType& counter)
    {
        i = counter++;
    }
};

template<typename T, typename CountType>
struct AutoCountingHelper<T, CountType, true>
{
    static void count(CountType& i, CountType& counter)
    {
        boost::mutex::scoped_lock lock(mutex);
        i = counter++;
    }

    static boost::mutex mutex;
};

template<typename T, typename CountType>
boost::mutex AutoCountingHelper<T, CountType, true>::mutex;

// CRTP additionally ensures we have one counter per direct subclass
template<typename T, typename CountType=int, bool UseMutex=false>
struct AutoCountingEnum
{
public:
    bool operator==(const AutoCountingEnum<T, CountType, UseMutex>& other) const { return i == other.i; }
    bool operator!=(const AutoCountingEnum<T, CountType, UseMutex>& other) const { return i != other.i; }

    static CountType count() { return counter; }

protected:
    AutoCountingEnum<T, CountType, UseMutex>()
    {
        AutoCountingHelper<T, CountType, UseMutex>::count(i, counter);
    }

protected:
    CountType i;
    static CountType counter;
};

template<typename T, typename CountType, bool UseMutex>
CountType AutoCountingEnum<T, CountType, UseMutex>::counter = CountType(0);


// for Counting = false it derives from NoValueEnum
template <typename T, bool Counting=false, typename CountType=int, bool UseMutex=false>
struct ExtensibleEnumBase : public NoValueEnum<T>
{
protected:
    ExtensibleEnumBase<T, Counting, CountType, UseMutex>() {}
};

// for Counting = true it derives from AutoCountingEnum
template <typename T, typename CountType, bool UseMutex>
struct ExtensibleEnumBase<T, true, CountType, UseMutex>
    : public AutoCountingEnum<T, CountType, UseMutex>
{
protected:
    ExtensibleEnumBase<T, true, CountType, UseMutex>()
    {
        static_assert(std::is_integral<CountType>::value, "Integral required for CountType template param.");
    }
};


} // namespace



template <typename T, bool UseID=false, bool Counting=false, typename CountType=int, bool UseMutex=false>
struct ExtensibleEnum : public detail::ExtensibleEnumBase<T, Counting, CountType, UseMutex>
{
protected:
    // we take the string param so we have a uniform interface, but ignore it
    ExtensibleEnum<T, UseID, Counting, CountType, UseMutex>(const std::string& = "") {}
};

template <typename T, bool Counting, typename CountType, bool UseMutex>
struct ExtensibleEnum<T, true, Counting, CountType, UseMutex>
    : public detail::ExtensibleEnumBase<T, Counting, CountType, UseMutex>
{
protected:
    ExtensibleEnum<T, true, Counting, CountType, UseMutex>(const std::string& id = "") : ID(id) {}

public:

    MIRA_SPLIT_REFLECT_MEMBER

    void reflectRead(JSONSerializer& r)
    {
        r.property("id", ID, "");
    }

    const std::string& id() const { return ID; }

private:
    std::string ID;
};


namespace detail {

// helper to remove brackets within macro
// (which are needed to use template typenames including ',' as macro params)
template<typename> struct ExtEnum_RemoveBrackets;
template<typename T> struct ExtEnum_RemoveBrackets<void (T)> {
    typedef T Result;
};

}

#define MIRA_EXTENUM_DECLARE_VALUE(R, ENUMNAME, VALUENAME)                                    \
    const static ENUMNAME VALUENAME;

#define MIRA_EXTENSIBLE_ENUM_DECLARE(NAME, BASE, VALUES...)                                   \
    struct NAME : public mira::detail::ExtEnum_RemoveBrackets<void (BASE)>::Result            \
    {                                                                                         \
    protected:                                                                                \
        NAME(const std::string& id = "")                                                      \
            : mira::detail::ExtEnum_RemoveBrackets<void (BASE)>::Result(id) {}                \
    public:                                                                                   \
        BOOST_PP_SEQ_FOR_EACH(MIRA_EXTENUM_DECLARE_VALUE, NAME,                               \
                              BOOST_PP_TUPLE_TO_SEQ(MIRA_VARIADIC_SIZE(VALUES), (VALUES)) )   \
    };

#define MIRA_EXTENUM_DEFINE_VALUE(R, ENUMNAME, VALUENAME)                                     \
    const ENUMNAME ENUMNAME::VALUENAME;

#define MIRA_EXTENSIBLE_ENUM_DEFINE(NAME, VALUES...)                                          \
        BOOST_PP_SEQ_FOR_EACH(MIRA_EXTENUM_DEFINE_VALUE, NAME,                                \
                              BOOST_PP_TUPLE_TO_SEQ(MIRA_VARIADIC_SIZE(VALUES), (VALUES)) )


}

#endif