I18n.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <string>
#include <memory>
#include <unordered_map>
#include <tuple>
#include <utility>
#include <type_traits>
 
#include "ILocale.hpp"
#include "TypeTraits.hpp"
 
#if defined(__APPLE__)
    #include <CoreFoundation/CoreFoundation.h>
#elif defined(__unix__) || defined(__linux__)
    #include <locale>
#endif
 
 
template<typename T, typename = typename std::enable_if<is_derived_from<T, ILocale>::value>::type>
class I18n {
 
    public:
 
        static I18n<T>& getInstance() {
            static I18n<T> instance;
            
            return instance;
        }
 
        I18n(const I18n&) = delete;
 
        I18n& operator=(const I18n&) = delete;
 
        template<typename... T_Child>
        typename std::enable_if<all_derived<T, T_Child...>::value, void>::type
        setSupportedLocales() {
            // C++11 pack expansion via initializer list trick
            auto l = { (setSupportedLocale<T_Child>(), 0)... }; 
            (void)l; //silence !
            if (!_locale) setDefault();
        }
 
 
        template<typename T_Tuple>
        typename std::enable_if<is_tuple<T_Tuple>::value, void>::type
        setSupportedLocales() {
            registerTupleLocales_using_index<T_Tuple>(
                typename make_index_sequence_impl<std::tuple_size<T_Tuple>::value>::type{}
            );
            if (!_locale) setDefault();
        }
 
        void setDefault() {
            if (_supportedLocales.empty())
                return;
            
            if (!_systemCode.empty() && setLocale(_systemCode))
                return;
            if (setLocale("en"))
                return;
 
            _locale = _supportedLocales.begin()->second.get();
        }
 
        bool setLocale(const std::string& code) {
            typename std::unordered_map<std::string, std::unique_ptr<T>>::iterator it = _supportedLocales.find(code);
 
            if (it != _supportedLocales.end()) {
                _locale = it->second.get();
                return true;
            }
            return false;
        }
        
        T* getLocale() const {
            return _locale;
        }
 
    private:
        std::string _systemCode;
        T* _locale = nullptr;
        std::unordered_map<std::string, std::unique_ptr<T>> _supportedLocales;
 
    private:
        I18n() {
            setSystemCode();
        }
 
        void setSystemCode() {
             #if defined(__APPLE__)
                // Use explicit casts and checks for C++11 compatibility
                CFLocaleRef locale = CFLocaleCopyCurrent();
                if (!locale) {
                    _systemCode = "en"; // fallback
                    return;
                }
 
                CFStringRef identifier = (CFStringRef)CFLocaleGetValue(locale, kCFLocaleIdentifier);
 
                char buffer[16] = {0};
                if (CFStringGetCString(identifier, buffer, sizeof(buffer), kCFStringEncodingUTF8)) {
                    _systemCode = std::string(buffer, 2); // first 2 letters
                } else {
                    _systemCode = "en"; // second fallback
                }
                CFRelease(locale);
            #elif defined(__unix__) || defined(__linux__)
                try {
                    // C++11 locale handling
                    std::locale loc(""); // system locale
                    std::string name = loc.name(); // e.g., "fr_FR.UTF-8"
                    if (!name.empty() && name != "C" && name != "POSIX")
                        _systemCode = name.substr(0, 2);
                } catch (...) {
                    _systemCode = "en"; // fallback on error
                }
            #else
                _systemCode = "en"; // fallback for other platforms
 
#endif
        }
 
        template <typename T_Child, typename = typename std::enable_if<is_derived_from<T_Child, T>::value>::type>
        void setSupportedLocale() {
            // C++11 replacement for std::make_unique (C++14)
            std::unique_ptr<T_Child> newInstance(new T_Child());
            std::string key = newInstance->languageCode();
            _supportedLocales[key] = std::move(newInstance);
        }
 
        template<typename Tuple, std::size_t... Is>
        void registerTupleLocales_using_index(index_sequence<Is...>) {
            // C++11 Pack Expansion via initializer list trick
            auto l = { (setSupportedLocale<typename std::tuple_element<Is, Tuple>::type>(), 0)... };
            (void)l;
        }
 
};