ConversionTool.h

Go to the documentation of this file.

#ifndef __KOME_CORE_CONVERSION_TOOL_H__
#define __KOME_CORE_CONVERSION_TOOL_H__


#include <string>


// macro
#define GET_ID_NAME( id, idArray )                          \
    kome::core::ConversionTool::getIdName(                  \
        id,                                                 \
        idArray,                                            \
        sizeof( idArray ) / sizeof( kome::core::IDInfo )    \
    );

#define CONVERT_FROM_ARRAY( key, defaultValue, conversionArray )    \
    kome::core::ConversionTool::convert(                            \
        key,                                                        \
        defaultValue,                                               \
        conversionArray,                                            \
        sizeof( conversionArray ) / sizeof( conversionArray[ 0 ] )  \
    );

#define INVERT_FROM_ARRAY( key, defaultValue, conversionArray )     \
    kome::core::ConversionTool::invert(                             \
        key,                                                        \
        defaultValue,                                               \
        conversionArray,                                            \
        sizeof( conversionArray ) / sizeof( conversionArray[ 0 ] )  \
    );

// class
namespace kome {
    namespace core {

        struct IDInfo {
            int id;
            const char* name;
        };


        template< typename S, typename T > struct ConversionElement {
            S key;
            T value;
        };

        class CORE_TOOLKITS_CLASS ConversionTool {
        public:
            static std::string getIdName(
                const int id,
                IDInfo* idInfoArray,
                const unsigned int arraySize
            );

            template< typename S, typename T >
            static T convert(
                    const S key,
                    const T dfVal,
                    ConversionElement< S, T >* elementArray,
                    int arraySize
            ) {
                // check arguments
                if( elementArray == NULL || arraySize <= 0 ) {
                    return dfVal;
                }

                // search
                for( int i = 0; i < arraySize; i++ ) {
                    if( key == elementArray[ i ].key ) {
                        return elementArray[ i ].value;
                    }
                }

                return dfVal;
            }

            template< typename S, typename T >
            static S invert(
                    const T key,
                    const S dfVal,
                    ConversionElement< S, T >* elementArray,
                    int arraySize
            ) {
                // check arguments
                if( elementArray == NULL || arraySize <= 0 ) {
                    return dfVal;
                }

                // search
                for( int i = 0; i < arraySize; i++ ) {
                    if( key == elementArray[ i ].value ) {
                        return elementArray[ i ].key;
                    }
                }

                return dfVal;
            }
        };
    }
}

#endif  // __KOME_CORE_CONVERSION_TOOL_H__