Jeu Videz votre presse-papier - Page 1154

- `internationalUsKeyboardForFrench`: enables easy access to latin-international characters on top of an English (US) keyboard. Aimed at coders, and in its current implementation for French-speakers by providing a couple of shortcuts for mostly used accented characters. Useful since the MS KLC is not really supported anymore and doesn't create touch keyboards. It does this:
	- Right Alt + E = é (or É with Shift when pressing E)
	- Right Alt + C = ç
	- Right Alt + A = à
	- Right Alt + U = ` (dead key; then press another key like A to get à, E to get è, etc. or space to insert the ` char)
	- Right Alt + I = ^ (dead key; A=â, E=ê, I=î, O=ô, U=û, space=^)
	- Right Alt + O = ¨ (dead key; A=ä, E=ë, I=ï, O=ö, U=ü, space=¨)
	- Right Alt + P = ´ (dead key; A=á, E=é, I=í, O=ó, U=ú, space=´)
	- Right Alt + N = ~ (dead key; N=ñ, space=~)
	- Right Alt + ; (semi-colon) = … (horizontal ellipsis)
	- Note that you may create your own layouts or customize it. Look at layoutTranslatorsRegister.

template <typename Field, size_t Arity = 1, bool I = false>
        struct field_t
        {
            static_assert(Arity > 0 && Arity <= 200, "Invalid cardinality");
            static_assert(I ? (Arity == 1) : true, "Arrays can't be keys");

            constexpr static const size_t size = sizeof(Field) * Arity;
            constexpr static const size_t element_size = sizeof(Field);
            constexpr static const size_t arity = Arity;

            using element_type = Field;

            constexpr static const bool is_index  = I;
            constexpr static const bool is_array  = arity > 1;
            constexpr static const bool is_string = std::is_same<element_type, const char*>::value;

            using member_type            = typename std::conditional<is_array, std::array<element_type, arity>, element_type>::type;
            using const_member_type      = typename std::add_const<member_type>::type;
            using lref_member_type       = typename std::add_lvalue_reference<member_type>::type;
            using const_lref_member_type = typename std::add_const<lref_member_type>::type;
            using rref_member_type       = typename std::add_rvalue_reference<member_type>::type;

            field_t(const field_t& other) {
                value = other.value;
            }

            field_t(field_t&& other) {
                value = std::move(other.value);
            }

            field_t() {
            }

            explicit field_t(member_type value_)
            {
                value = value_;
            }

            field_t(rref_member_type value_)
            {
                value = std::move(value_);
            }

            field_t(const_lref_member_type value_)
            {
                value = value_;
            }

            field_t& operator = (const_lref_member_type value_)
            {
                value = value_;
                return *this;
            }

            field_t& operator = (rref_member_type value_)
            {
                value = std::move(value_);
                return *this;
            }

            inline operator member_type() const
            {
                return value;
            }

            //inline auto operator [] (size_t index) const -> typename std::enable_if<arity != 1, const element_type&>::type
            //{
            //    return value[index];
            //}

            //inline auto operator [] (size_t index) -> typename std::enable_if<arity != 1, element_type&>::type
            //{
            //    return value[index];
            //}
        private:
            member_type value;
        };

        template <size_t N = 1>
        using string_t = field_t<const char*, N, false>;

        using index_t = field_t<std::uint32_t, 1, true>;
        using locstring_t = string_t<16>;

        using u64_t    = field_t<std::uint64_t>;
        using u32_t    = field_t<std::uint32_t>;
        using u16_t    = field_t<std::uint16_t>;
        using u8_t     = field_t<std::uint8_t>;
        using i64_t    = field_t<std::int64_t>;
        using i32_t    = field_t<std::int32_t>;
        using i16_t    = field_t<std::int16_t>;
        using i8_t     = field_t<std::int8_t>;
        using single_t = field_t<float>;

        template <typename Enum, typename... Members>
        struct record_t : private std::tuple<Members...>
        {
        private:
            using is_scoped_enum = std::integral_constant<bool, std::is_enum<Enum>::value && !std::is_convertible<Enum, int>::value>;

        public:

            static_assert(is_scoped_enum::value, "Must use get<>() with scoped enums");
            static_assert(sizeof...(Members) > 0, "Can't have an empty structure.");

            constexpr static const size_t size = sizeof...(Members);

            template <size_t Idx>
            using member = typename details::nth_element<Idx, Members...>;

            template <Enum Idx>
            inline auto get()
            {
                typedef typename std::underlying_type<Enum>::type enum_underlying_type;

                return std::get<static_cast<enum_underlying_type>(Idx)>(*this);
            }
        };