How bees use pheromones - PerfectBeePerfectBeeBees have one of the most sophisticated pheromone-driven communication systems in all of nature, used by workers, drones and the queen.
- `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); } };