EncodingTraits.hpp

Go to the documentation of this file.

 
#ifndef LLU_WSTP_ENCODINGTRAITS_HPP_
#define LLU_WSTP_ENCODINGTRAITS_HPP_
 
#include <cstdint>
#include <string>
#include <type_traits>
#include <utility>
 
namespace LLU::WS {
 
    enum class Encoding : std::uint8_t {
        Undefined,    
        Native,       
        Byte,         
        UTF8,         
        UTF16,        
        UCS2,         
        UTF32         
    };
 
    template<Encoding E>
    struct CharTypeStruct {
        static_assert(E != Encoding::Undefined, "Trying to deduce character type for undefined encoding");
        using type = char;
    };
 
    template<>
    struct CharTypeStruct<Encoding::Native> {
        using type = char;
    };
    template<>
    struct CharTypeStruct<Encoding::Byte> {
        using type = unsigned char;
    };
    template<>
    struct CharTypeStruct<Encoding::UTF8> {
        using type = unsigned char;
    };
    template<>
    struct CharTypeStruct<Encoding::UTF16> {
        using type = unsigned short;
    };
    template<>
    struct CharTypeStruct<Encoding::UCS2> {
        using type = unsigned short;
    };
    template<>
    struct CharTypeStruct<Encoding::UTF32> {
        using type = unsigned int;
    };
 
    template<Encoding E>
    using CharType = typename CharTypeStruct<E>::type;
 
    template<Encoding E, typename T>
    inline constexpr bool CharacterTypesCompatible = (sizeof(T) == sizeof(CharType<E>));
 
    template<Encoding E>
    struct StringTypeStruct {
        using type = std::basic_string<CharType<E>>;
    };
 
    template<Encoding E>
    using StringType = typename StringTypeStruct<E>::type;
 
    constexpr const char* getEncodingName(Encoding e) {
        switch (e) {
            case Encoding::Undefined: return "Undefined";
            case Encoding::Native: return "Native";
            case Encoding::Byte: return "Byte";
            case Encoding::UTF8: return "UTF8";
            case Encoding::UTF16: return "UTF16";
            case Encoding::UCS2: return "UCS2";
            case Encoding::UTF32: return "UTF32";
        }
    }
 
    template<Encoding E, typename T, bool = std::is_lvalue_reference<T>::value>
    struct PutAs;
 
    template<Encoding E, typename T>
    struct PutAs<E, T, true> {
 
        explicit PutAs(const T& o) : obj(o) {}
 
        const T& obj;
    };
 
    template<Encoding E, typename T>
    struct PutAs<E, T, false> {
 
        explicit PutAs(T&& o) : obj(std::move(o)) {}
 
        T obj;
    };
 
    template<Encoding E, typename T>
    PutAs<E, T> putAs(T&& obj) {
        return PutAs<E, T>(std::forward<T>(obj));
    }
 
    template<Encoding E, typename T>
    struct GetAs {
 
        explicit GetAs(T& o) : obj(o) {}
 
        T& obj;
    };
 
    template<Encoding E, typename T>
    GetAs<E, T> getAs(T& obj) {
        return GetAs<E, T>(obj);
    }
} /* namespace LLU::WS */
 
#endif /* LLU_WSTP_ENCODINGTRAITS_HPP_ */