utils.hpp

Go to the documentation of this file.

#ifndef IV_SRC_CONTAINERS_UTILS_HPP_
#define IV_SRC_CONTAINERS_UTILS_HPP_
 
#include <cstdint>
#include <fmt/format.h>
#include <memory>
#include <numeric>
#include <string>
#include <vector>
 
namespace iv::utils
{
 
namespace map
{
 
}
 
namespace vector
{
 
template<typename T>
void concatenate(std::vector<T> *v, const std::vector<T> &other)
{
    v->insert(v->end(), other.begin(), other.end());
}
 
void createData(std::vector<bool> *bytes, const unsigned char *data, uint32_t numBytesData);
 
void createDataInOrder(std::vector<bool> *bytes, const unsigned char *data, uint32_t numBytesData);
 
template<typename T>
T summatory(std::vector<T> &v)
{
    static_assert(std::is_arithmetic_v<T>, "T must be arithmetic type");
    return std::accumulate(v.begin(), v.end(), T {0});
}
 
template<typename T>
std::string toString(char separator, const std::vector<T> &v)
{
 
    if (v.empty())
    {
        return "{}";
    }
 
    std::string result = "{";
 
    for (const auto &item: v)
    {
        result += fmt::format("{}{}", item, separator);
    }
 
    // Remove the last separator
    result.pop_back();
    result += "}";
 
    return result;
}
 
template<typename T>
std::unique_ptr<uint32_t[]> getUIntPointer(std::vector<T> v)
{
    static_assert(std::is_arithmetic<T>::value, "T must be an arithmetic type");
 
    uint64_t numPoints = v.size();
 
    if (numPoints > 0)
    {
        auto points = std::make_unique<uint32_t[]>(numPoints);
 
        for (uint64_t indPoint = 0; indPoint < numPoints; indPoint++)
        {
            points[indPoint] = static_cast<uint32_t>(v.at(indPoint));
        }
 
        return points;
    }
 
    return nullptr;
}
 
}// namespace vector
 
}// namespace iv::utils
 
#endif//IV_SRC_CONTAINERS_UTILS_HPP_