FRC.h

/*
 * Copyright (c) 2014, killerbee13
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 *
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * * Redistributions in binary form must reproduce the above
 *   copyright notice, this list of conditions and the following disclaimer
 *   in the documentation and/or other materials provided with the
 *   distribution.
 * * Neither the name of the copyright holder nor the names of its
 *   contributors may be used to endorse or promote products derived from
 *   this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */

#ifndef SIMPLE_ALGORITHMS_H_INCLUDED
#define SIMPLE_ALGORITHMS_H_INCLUDED

// Header containing frequently reused code that is not as easily done without
// helper functions

#include <algorithm>
#include <array>
#include <cctype>
#include <cmath>
#include <complex>
#include <fstream>
#include <istream>
#include <limits>
#include <tuple>
#include <utility>

#include <exception>
#include <stdexcept>
#include <typeinfo>

#if __has_cpp_attribute(fallthrough)
#define fallthrough fallthrough
#elif __has_cpp_attribute(clang::fallthrough)
#define fallthrough clang::fallthrough
#elif __has_cpp_attribute(gnu::fallthrough)
#define fallthrough gnu::fallthrough
#else
#define fallthrough fallthrough
#endif

#if __has_cpp_attribute(maybe_unused)
#define maybe_unused maybe_unused
#elif __has_cpp_attribute(gnu::unused)
#define maybe_unused gnu::unused
#else // Just let the compiler show the warning
#define maybe_unused maybe_unused
#endif

#if !FRC_NO_CONVERT
#include <sstream>
#include <string>
// This is the only one that should throw an exception
template <typename T>
inline T fromStr(const std::string& val) {
    std::stringstream ss(val);
    T ret;
    if (!(ss >> ret).fail())
        return ret;
    else
        throw std::runtime_error("\"" + val + "\" is not a " + typeid(T).name());
}
template <>
inline std::string fromStr(const std::string& val) {
    return val;
}

template <typename T>
inline T fromStr(const std::string& val, const char* type) {
    std::stringstream ss(val);
    T ret;
    if (!(ss >> ret).fail())
        return ret;
    else
        throw std::runtime_error("\"" + val + "\" is not a " + type);
}
template <>
inline std::string fromStr(const std::string& val,
                           [[maybe_unused]] const char* type) {
    return val;
}
#define pFromStr(type, val) fromStr<type>((val), #type)

template <typename T>
inline std::string toStr(T val) {
    std::stringstream ss;
    ss << val;
    return ss.str();
}
#endif

#if !FRC_NO_ICU
#include <unicode/unistr.h>
// For elegance
template <typename string = std::string>
inline string toUTF8(const icu::UnicodeString& s) {
    string res;
    return s.toUTF8String(res);
}
// For consistency
template <typename string>
inline icu::UnicodeString fromUTF8(string s) {
    return icu::UnicodeString::fromUTF8(s);
}
// For elegance
template <typename string = std::u32string>
inline string toUTF32(const icu::UnicodeString& s) {
    string res(s.countChar32(), '\0');
    UErrorCode ec{U_ZERO_ERROR};
    s.toUTF32(reinterpret_cast<UChar32*>(&res[0]), res.size(), ec);
    if (U_FAILURE(ec)) {
        throw ec;
    }
    return res;
}
// For consistency
template <typename string>
inline icu::UnicodeString fromUTF32(string s) {
    return icu::UnicodeString::fromUTF32(s.data(), s.length());
}

inline std::ostream& operator<<(std::ostream& os,
                                const icu::UnicodeString& str) {
    return os << toUTF8(str);
}

// ICU basically provides a + so I might as well translate it
inline std::string operator+(std::string lhs, const icu::UnicodeString& str) {
    return str.toUTF8String(lhs);
}

#if !FRC_NO_CONVERT

// For debugging
std::string d_toUTF8(const icu::UnicodeString& s);
icu::UnicodeString d_fromUTF8(std::string s);

template <typename T>
inline T fromStr(const icu::UnicodeString& val, const char* type) {
    return fromStr<T>(toUTF8(val), type);
}

template <typename T>
inline T fromStr(const icu::UnicodeString& val) {
    return fromStr<T>(toUTF8(val));
}
#endif
#endif

#include <numeric>
template <typename string, typename vector>
inline string join(const vector& in, const string& joiner = {}) {
    if (in.size() == 0) {
        return {};
    } else if (in.size() == 1) {
        return *in.begin();
    } else {
        return std::accumulate(
            std::next(std::begin(in)), std::end(in), *in.begin(),
            [&joiner](const string& a, const string& b) -> string {
                return a + joiner + b;
            });
    }
}

template <typename string>
inline string reverseStr(string val) {
    std::reverse(val.begin(), val.end());
    return val;
}

template <typename string>
inline string toLower(string str) {
    std::transform(str.begin(), str.end(), str.begin(), ::tolower);
    return str;
}

template <typename string>
inline string toUpper(string str) {
    std::transform(str.begin(), str.end(), str.begin(), ::toupper);
    return str;
}

#include <sstream>
#include <string>
#include <vector>
template <typename T>
inline std::vector<T> listToVec(std::string list) {
    std::vector<T> ret;
    std::stringstream ss(list);
    std::string tmp;
    while (!(ss >> tmp).fail()) {
        ret.push_back(fromStr<T>(tmp));
    }
    /*
    while(list.find_first_of(" ,") != std::string::npos) {
     std::string entry = list.substr(0, list.find_first_of(" ,"));
     ret.push_back(fromStr<T>(entry));
     list = list.substr(entry.size());
     if (list.find_first_of(" ,") == std::string::npos) {
        entry = list.substr(0, list.find_first_of(" ,"));
        ret.push_back(fromStr<T>(entry));
        list = list.substr(entry.size());
     }
    }*/
    return ret;
}

template <typename string>
inline string repeat(string val, int count) {
    string tmp;
    for (int i = 0; i < count; ++i) {
        tmp += val;
    }
    return tmp;
}

inline std::string repeat(char val, int count) {
    return std::string(count, val);
}

#if !FRC_NO_BUILD
#include <algorithm>
#include <iterator>
template <typename Container, typename InputIt, typename UnaryFunction>
inline Container build(InputIt first, InputIt last, UnaryFunction f) {
    Container out;
    std::transform(first, last, std::back_inserter(out), f);
    return out;
}

template <typename Container, typename InputIt, typename InputIt2,
          typename BinaryFunction>
inline Container build(InputIt first, InputIt last, InputIt2 first2,
                       BinaryFunction f) {
    Container out;
    std::transform(first, last, first2, std::back_inserter(out), f);
    return out;
}

template <typename Container, typename ExecutionPolicy, typename InputIt,
          typename UnaryFunction>
inline Container build(ExecutionPolicy&& policy, InputIt first, InputIt last,
                       UnaryFunction f) {
    Container out;
    std::transform(policy, first, last, std::back_inserter(out), f);
    return out;
}

template <typename Container, typename ExecutionPolicy, typename InputIt,
          typename InputIt2, typename BinaryFunction>
inline Container build(ExecutionPolicy&& policy, InputIt first, InputIt last,
                       InputIt2 first2, BinaryFunction f) {
    Container out;
    std::transform(policy, first, last, first2, std::back_inserter(out), f);
    return out;
}
#endif

template <typename Number>
constexpr inline int digitsOf(Number val) {
    return std::ceil(std::log10(val));
}

template <typename Number>
constexpr inline int digitsOf(Number val, int base) {
    return std::ceil(std::log(val) / std::log(base));
}

template <typename ForwardIterator>
inline int digitsList(ForwardIterator first, ForwardIterator last) {
    return digitsOf(*std::max_element(first, last));
}

template <typename ForwardIterator>
inline int digitsList(ForwardIterator first, ForwardIterator last, int base) {
    return digitsOf(*std::max_element(first, last), base);
}

#include <iomanip>
// Not working
template <typename ostream_type, typename ForwardIterator>
inline ostream_type& padList(ostream_type& os, ForwardIterator first,
                             ForwardIterator last, char fill = ' ',
                             int base = 10) {
    // os<<std::setw(std::ceil(std::log(*std::max_element(first,
    // last))/std::log(base)))<<std::setfill(fill);

    // save state of os
    char fills = os.fill();
    std::streamsize widths = os.width();

    os << std::setw(digitsList(first, last, base)) << std::setfill(fill);

    for (ForwardIterator it = first; it != last; ++it) {
        os << ' ' << *it;
    }
    // restore state of os
    os << std::setw(widths) << std::setfill(fills);
    return os;
}

// Consume all non-spaces to first break, then eat that, too
inline std::istream& eatWord(std::istream& is) {
    do {
        is.get();
    } while (!isspace(is.peek()));
    return is;
}

// Eat spaces, don't eat an extra
inline std::istream& eatSpace(std::istream& is) {
    while (isspace(is.peek()))
        is.get();
    return is;
}

inline std::string url_encode(const std::string& value) {
    std::ostringstream escaped;
    escaped.fill('0');
    escaped << std::hex;

    for (std::string::const_iterator i = value.begin(), n = value.end(); i != n;
         ++i) {
        std::string::value_type c = (*i);

        // Keep alphanumeric and other accepted characters intact
        if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') {
            escaped << c;
            continue;
        }

        // Any other characters are percent-encoded
        escaped << std::uppercase;
        escaped << '%' << std::setw(2) << int((unsigned char)c);
        escaped << std::nouppercase;
    }

    return escaped.str();
}

template <typename string>
inline std::string get_file_contents(string filename) {
    std::ifstream in{};
    in.exceptions(std::ios::badbit);
    in.open(filename, std::ios::in | std::ios::binary);
    std::string contents;
    std::array<char, 128> buf;
    while (in) {
        in.read(buf.begin(), buf.size());
        contents.append(buf.begin(), in.gcount());
    }
    return contents;
}

template <typename T, typename F>
inline constexpr T quantizeRange(F min, F delta, F val) {
    return static_cast<T>((val - min) * std::numeric_limits<T>::max() * delta);
}

// Memnonic aids

template <typename T>
using Ptr = T*;

template <typename T>
using PtrToConst = T const*;

template <typename T>
using ConstPtr = T* const;

template <typename T>
using ConstPtrToConst = T const* const;

#endif // SIMPLE_ALGORITHMS_H_INCLUDED