misc.hpp

#ifndef NOOS_MISC
#define NOOS_MISC
#include "includes.ihh"
namespace noos {
namespace misc {

inline std::string decode64(const std::string &val)
{
    if (val.empty()) {
        throw std::runtime_error("empty string param");
    }
    using namespace boost::archive::iterators;
    using It = transform_width<binary_from_base64<std::string::const_iterator>, 8, 6>;
    return boost::algorithm::trim_right_copy_if(std::string(It(std::begin(val)), 
                                                            It(std::end(val))), 
                                                            [](char c) {return c == '\0';});
}

inline std::string encode64(const std::string &val)
{
    if (val.empty()) {
        throw std::runtime_error("empty string param");
    }
    using namespace boost::archive::iterators;
    using It = base64_from_binary<transform_width<std::string::const_iterator, 6, 8>>;
    auto tmp = std::string(It(std::begin(val)), It(std::end(val)));
    return tmp.append((3 - val.size() % 3) % 3, '=');
}

inline std::string random_boundary()
{
    std::string chars("abcdefghijklmnopqrstuvwxyz"
                      "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
                      "1234567890");
    std::random_device rng;
    std::mt19937 gen(rng());
    std::string uid;

    // Randomly chose 16 characters
    std::uniform_int_distribution<> index_dist(0, (chars.size() - 1));
    for (int i = 0; i < 16; ++i){
        uid.push_back(chars[index_dist(rng)]);
    }
    return uid;
}

inline std::string escape_string(const std::string & str)
{
    if (str.empty()) {
        throw std::runtime_error("empty string param");
    }
    std::ostringstream ss;
    for (auto iter = str.cbegin(); iter != str.cend(); iter++) {
        switch (*iter) {
            case '\\': ss << "\\\\"; break;
            case '"': ss << "\\\""; break;
            case '/': ss << "\\/"; break;
            case '\b': ss << "\\b"; break;
            case '\f': ss << "\\f"; break;
            case '\n': ss << "\\n"; break;
            case '\r': ss << "\\r"; break;
            case '\t': ss << "\\t"; break;
            default: ss << *iter; break;
        }
    }
    return ss.str();
} 

template <class F, class... Args>
void for_each_arg(F&& f, Args&&... args) 
{
    using swallow = int[];
    (void)swallow{0, (void(f(std::forward<Args>(args))), 0)...};
}

template<typename T>
T get_json_value(const std::string key, const nlohmann::json & json_f)
{
    auto it = json_f.find(key);
    if (it == json_f.end()) {
        throw std::runtime_error("key " + key + " not found");    
    }
    return it->get<T>();
}

inline bool check_json(
                         nlohmann::json & json,
                         const std::string json_str
                      )
{
    try {
        json = nlohmann::json::parse(json_str);
    }
    catch (std::exception & e) {
        std::cerr << e.what() << std::endl;
        return false;
    }
    return true;
} 

//         the platform
inline bool check_error(
                         const nlohmann::json json,
                         const std::string error_str = "error"
                       )
{
    auto error = misc::get_json_value<std::string>(error_str, json);
    if (!error.empty()) {
        std::cerr << "error JSON: " << error <<std::endl;
        return false;
    }
    return true;
}

inline bool save_dec_image(std::string data,
                           std::string filename)
{
    std::string temporary = "tmp";
    std::ofstream tmp(temporary);
    tmp << misc::decode64(data);
    tmp.close();
    noos::object::picture result(temporary);
    std::remove(temporary.c_str());
    return result.save(filename);
}

}
}

// c++11 - add `std::make_unique`
#if __cplusplus==201103L
namespace std {
template<typename T, typename... Args>
std::unique_ptr<T> make_unique(Args&&... args)
{
    return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
}
}
#endif

//
#endif