be_framework_enumeration.h

Go to the documentation of this file.

/*
 * This software was developed at the National Institute of Standards and
 * Technology (NIST) by employees of the Federal Government in the course
 * of their official duties. Pursuant to title 17 Section 105 of the
 * United States Code, this software is not subject to copyright protection
 * and is in the public domain. NIST assumes no responsibility whatsoever for
 * its use by other parties, and makes no guarantees, expressed or implied,
 * about its quality, reliability, or any other characteristic.
 */
 
#ifndef BE_FRAMEWORK_ENUMERATION_H_
#define BE_FRAMEWORK_ENUMERATION_H_
 
#include <map>
#include <string>
#include <ostream>
#include <type_traits>
 
#include <be_error_exception.h>
 
/*
 * These empty namespaces are here so that you can issue
 *      using namespace BiometricEvaluation::Framework::Enumeration;
 * after including this file.
 */
namespace BiometricEvaluation
{
        namespace Framework
        {
                namespace Enumeration
                {
 
                }
        }
}
 
#define BE_FRAMEWORK_ENUMERATION_DECLARATIONS(BE_ENUMERATED_TYPE_, \
    BE_ENUMERATED_TYPE_ENUM_TO_STRING_MAP_) \
extern const \
std::map<BE_ENUMERATED_TYPE_, std::string> \
BE_ENUMERATED_TYPE_ENUM_TO_STRING_MAP_;\
\
namespace BiometricEvaluation \
{ \
        namespace Framework \
        { \
                namespace Enumeration \
                { \
 \
                        bool \
                        operator==( \
                            const std::string &strVal, \
                            const BE_ENUMERATED_TYPE_ &enumVal); \
\
 \
                        bool \
                        operator==( \
                            const BE_ENUMERATED_TYPE_ &enumVal, \
                            const std::string &strVal); \
\
 \
                        bool \
                        operator!=( \
                            const std::string &strVal, \
                            const BE_ENUMERATED_TYPE_ &enumVal); \
\
 \
                        bool \
                        operator!=( \
                            const BE_ENUMERATED_TYPE_ &enumVal, \
                            const std::string &strVal); \
\
 \
                        std::ostream& \
                        operator<<( \
                            std::ostream &stream, \
                            const BE_ENUMERATED_TYPE_ &enumVal); \
\
 \
                        std::string \
                        operator+( \
                            const std::string &strVal, \
                            const BE_ENUMERATED_TYPE_ &enumVal); \
\
 \
                        std::string \
                        operator+( \
                            const BE_ENUMERATED_TYPE_ &enumVal, \
                            const std::string &strVal); \
\
 \
                        std::underlying_type<BE_ENUMERATED_TYPE_>::type \
                        to_int_type( \
                                const BE_ENUMERATED_TYPE_ &enumVal) \
                                noexcept; \
\
 \
                        std::string \
                        to_string( \
                            const BE_ENUMERATED_TYPE_ &enumVal); \
\
 \
                        template<typename T> \
                        T \
                        to_enum( \
                            const typename \
                            std::underlying_type<T>::type &iVal); \
\
 \
                        template<typename T> \
                        T \
                        to_enum( \
                            const std::string &strVal); \
                } \
        } \
}\
/* This is here to require a semicolon after macro instantation */\
static_assert(true, "")
 
 
#define BE_FRAMEWORK_ENUMERATION_DEFINITIONS(BE_ENUMERATED_TYPE_, \
    BE_ENUMERATED_TYPE_ENUM_TO_STRING_MAP_) \
/* \
 * Template specializations for to_enum() must come before they are used, \
 * or functions that rely on them, like operator==, will implicitly \
 * instantiate them, disallowing the later specialization. \
 *
 * Additional, a long-standing g++ bug originating from a defect in the \
 * standard requires that the template specializations be enclosed in the same \
 * namespace: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=56480 \
 */ \
namespace BiometricEvaluation{ \
        namespace Framework { \
                namespace Enumeration{ \
                        template<> \
                        BE_ENUMERATED_TYPE_ \
                        to_enum( \
                            const typename std::underlying_type<\
                                BE_ENUMERATED_TYPE_>::type &iVal) \
                        { \
                                for (const auto &i : \
                                    BE_ENUMERATED_TYPE_ENUM_TO_STRING_MAP_) \
                                        if (static_cast<std::underlying_type<\
                                            BE_ENUMERATED_TYPE_>::type>(\
                                            i.first) == iVal) \
                                                return (i.first); \
                        \
                                throw BiometricEvaluation::Error::\
                                    ObjectDoesNotExist(std::to_string(iVal)); \
                        } \
\
                        template<> \
                        BE_ENUMERATED_TYPE_ \
                        to_enum ( \
                            const std::string &strVal) \
                        { \
                                for (const auto &i : \
                                    BE_ENUMERATED_TYPE_ENUM_TO_STRING_MAP_) \
                                        if (i.second == strVal) \
                                                return (i.first); \
                        \
                                throw BiometricEvaluation::Error::\
                                    ObjectDoesNotExist(strVal); \
                        } \
                } \
        } \
} \
\
bool \
BiometricEvaluation::Framework::Enumeration::operator==( \
    const std::string &strVal, \
    const BE_ENUMERATED_TYPE_ &enumVal) \
{ \
        return (to_enum<BE_ENUMERATED_TYPE_>(strVal) == enumVal); \
} \
\
bool \
BiometricEvaluation::Framework::Enumeration::operator==( \
    const BE_ENUMERATED_TYPE_ &enumVal, \
    const std::string &strVal) \
{ \
        return (strVal == enumVal); \
} \
\
bool \
BiometricEvaluation::Framework::Enumeration::operator!=( \
    const std::string &strVal, \
    const BE_ENUMERATED_TYPE_ &enumVal) \
{ \
        return (!(strVal == enumVal)); \
} \
\
bool \
BiometricEvaluation::Framework::Enumeration::operator!=( \
    const BE_ENUMERATED_TYPE_ &enumVal, \
    const std::string &strVal) \
{ \
        return (!(strVal == enumVal)); \
} \
\
std::ostream& \
BiometricEvaluation::Framework::Enumeration::operator<<( \
    std::ostream &stream, \
    const BE_ENUMERATED_TYPE_ &enumVal) \
{ \
        return (stream << to_string(enumVal)); \
} \
\
std::string \
BiometricEvaluation::Framework::Enumeration::operator+( \
    const std::string &strVal, \
    const BE_ENUMERATED_TYPE_ &enumVal) \
{ \
        return (strVal + to_string(enumVal)); \
} \
\
std::string \
BiometricEvaluation::Framework::Enumeration::operator+( \
    const BE_ENUMERATED_TYPE_ &enumVal, \
    const std::string &strVal) \
{ \
        return (to_string(enumVal) + strVal); \
} \
\
std::string \
BiometricEvaluation::Framework::Enumeration::to_string( \
    const BE_ENUMERATED_TYPE_ &enumVal) \
{ \
        return (BE_ENUMERATED_TYPE_ENUM_TO_STRING_MAP_.at(enumVal)); \
} \
\
std::underlying_type<BE_ENUMERATED_TYPE_>::type \
BiometricEvaluation::Framework::Enumeration::to_int_type( \
    const BE_ENUMERATED_TYPE_ &enumVal) \
    noexcept \
{ \
        return (static_cast<typename std::underlying_type< \
            BE_ENUMERATED_TYPE_>::type>(enumVal)); \
}\
/* This is here to require a semicolon after macro instantation */\
static_assert(true, "")
 
#endif /* BE_FRAMEWORK_ENUMERATION_H_ */