Translator.h

#pragma once

#include <iostream>
#include <vector>
#include <string>

#include <Poco/SharedPtr.h>
#include <Poco/Dynamic/Var.h>

namespace BeeeOn {

class Locale;

class Translator {
public:
        typedef Poco::SharedPtr<Translator> Ptr;

        virtual ~Translator();

        template <typename... Rest>
        std::string formatSure(
                const std::string &key,
                const Rest & ... rest)
        {
                std::vector<Poco::Dynamic::Var> tmp;
                formatCollect(tmp, rest...);
                const auto &result = formatImpl(key, tmp);
                return result.empty()? key : result;
        }

        template <typename... Rest>
        std::string format(
                const std::string &key,
                const std::string &def,
                const Rest & ... rest)
        {
                std::vector<Poco::Dynamic::Var> tmp;
                formatCollect(tmp, rest...);
                const auto &result = formatImpl(key, tmp);
                return result.empty() ?
                        formatFallback(def, tmp) : result;
        }

        std::string vformat(
                const std::string &key,
                const std::string &def,
                const std::vector<Poco::Dynamic::Var> &args)
        {
                const auto &result = formatImpl(key, args);
                return result.empty() ?
                        formatFallback(def, args) : result;
        }

protected:
        void prepareArg(std::vector<Poco::Dynamic::Var> &tmp, const char *first)
        {
                tmp.push_back(std::string(first));
        }

        template <typename Type>
        void prepareArg(std::vector<Poco::Dynamic::Var> &tmp, const Type &value)
        {
                tmp.push_back(value);
        }

        void formatCollect(std::vector<Poco::Dynamic::Var> &)
        {
        }

        template <typename First, typename... Rest>
        void formatCollect(std::vector<Poco::Dynamic::Var> &tmp,
                const First &first,
                const Rest & ... rest)
        {
                prepareArg(tmp, first);
                formatCollect(tmp, rest...);
        }

        virtual std::string formatImpl(
                const std::string &key,
                const std::vector<Poco::Dynamic::Var> &args) = 0;

        std::string formatFallback(
                const std::string &def,
                const std::vector<Poco::Dynamic::Var> &args) const;
};

class TranslatorFactory {
public:
        typedef Poco::SharedPtr<TranslatorFactory> Ptr;

        virtual ~TranslatorFactory();

        virtual Translator *create(
                        const Locale &locale,
                        const std::string &name = "") = 0;
};

}