Vectors.hpp

Go to the documentation of this file.

// @formatter:off
//
// Balau core C++ library
//
// Copyright (C) 2008 Bora Software (contact@borasoftware.com)
//
// Licensed under the Boost Software License - Version 1.0 - August 17th, 2003.
// See the LICENSE file for the full license text.
//


#ifndef COM_BORA_SOFTWARE__BALAU_UTIL__VECTORS
#define COM_BORA_SOFTWARE__BALAU_UTIL__VECTORS

#include <Balau/Type/ToString.hpp>

#include <cstring>
#include <memory>
#include <vector>

namespace Balau::Util {

struct Vectors final {

    template <typename T, typename ... PT>
    static void pushBack(std::vector<T> & vector, T && first, PT && ... remaining) {
        vector.emplace_back(std::forward<T>(first));
        pushBack(vector, std::forward<PT>(remaining) ...);
    }

    template <typename T>
    static void pushBack(std::vector<T> & ) {}

    template <typename T, typename ... PT>
    static std::vector<T> pushBack(T && first, PT && ... remaining) {
        std::vector<T> vector;
        vector.emplace_back(std::forward<T>(first));
        pushBack(vector, std::forward<PT>(remaining) ...);
        return vector;
    }

    template <typename T> static std::vector<T> pushBack() {
        return std::vector<T>();
    }


    template <typename T, typename T2, typename Compare = std::equal_to<T>, typename Replace = std::function<void (T &, T2 &&)>>
    static void pushBackOrReplace(std::vector<T> & dst, T2 && element, Compare compare = std::equal_to<T>(), Replace replace = DefaultReplace<T, T2>()) {
        auto existing = std::find_if(
            dst.begin(), dst.end(), [&element, &compare] (const auto & dstElement) { return compare(dstElement, element); }
        );

        if (existing != dst.end()) {
            replace(*existing, std::forward<T2>(element));
        } else {
            dst.push_back(std::forward<T2>(element));
        }
    }


    template <typename T> static void append(std::vector<T> & dst, const std::vector<T> & src) {
        dst.insert(std::end(dst), std::begin(src), std::end(src));
    }

    template <typename T> static void move(std::vector<T> & dst, const std::vector<T> & src) {
        std::move(src.begin(), src.end(), std::back_inserter(dst));
    }


    template <typename D, typename S>
    static std::vector<D> map(const std::vector<S> & input, std::function<D (const S &)> f) {
        std::vector<D> ret;
        std::transform(input.begin(), input.end(), std::back_inserter(ret), f);
        return ret;
    }


    static std::vector<char> toCharVector(const std::string & str) {
        std::vector<char> ret;
        ret.resize(str.length());
        std::memcpy(ret.data(), str.c_str(), str.length());
        return ret;
    }

    static std::vector<char32_t> toCharVector(const std::u32string & str) {
        std::vector<char32_t> ret;
        ret.resize(str.length());
        std::memcpy(ret.data(), str.c_str(), str.length() * sizeof(char32_t));
        return ret;
    }

    template <typename T> static std::vector<std::string> toStringVector(const std::vector<T> & vector) {
        std::vector<std::string> ret;
        ret.reserve(vector.size());

        using ::toString;

        for (size_t m = 0; m < vector.size(); m++) {
            ret.emplace_back(toString(vector[m]));
        }

        return ret;
    }

    template <typename T> static std::vector<std::u32string> toString32Vector(const std::vector<T> & vector) {
        std::vector<std::u32string> ret;
        ret.reserve(vector.size());

        for (size_t m = 0; m < vector.size(); m++) {
            ret.emplace_back(toString32(vector[m]));
        }

        return ret;
    }


    static std::string charsToString(const std::vector<char> & vector) {
        return std::string(vector.data(), vector.size());
    }

    static std::u16string charsToString(const std::vector<char16_t> & vector) {
        return std::u16string(vector.data(), vector.size());
    }

    static std::u32string charsToString(const std::vector<char32_t> & vector) {
        return std::u32string(vector.data(), vector.size());
    }


    // The default copy/move replace function used in pushBackOrReplace.
    private: template <typename T, typename T2> struct DefaultReplace {
        void operator () (T & lhs, T2 && rhs) {
            lhs = std::forward<T2>(rhs);
        }
    };

    Vectors() = delete;
    Vectors(const Vectors &) = delete;
    Vectors & operator = (const Vectors &) = delete;
};

} // namespace Balau::Util

#endif // COM_BORA_SOFTWARE__BALAU_UTIL__VECTORS