Helper.h

Go to the documentation of this file.

#pragma once
 
#include <initializer_list>
#include <numeric>
#include <span>
#include <vector>
 
#include "Number.h"
 
namespace faker::helper
{
template <class T>
T arrayElement(std::span<const T> data)
{
    if (data.empty())
    {
        throw std::invalid_argument{"Data is empty."};
    }
 
    const auto index = number::integer<size_t>(data.size() - 1);
 
    return data[index];
}
 
template <typename T, std::size_t N>
T arrayElement(const std::array<T, N>& data)
{
    if (data.empty())
    {
        throw std::invalid_argument{"Data is empty."};
    }
 
    const auto index = number::integer<size_t>(data.size() - 1);
 
    return data[index];
}
 
template <typename It>
auto arrayElement(It start, It end) -> decltype(*::std::declval<It>())
{
    auto size = static_cast<size_t>(end - start);
 
    if (size == 0)
    {
        throw std::invalid_argument{"Range [start,end) is empty."};
    }
 
    const std::integral auto index = number::integer<size_t>(size - 1);
 
    return start[index];
}
 
template <class T>
T arrayElement(const std::vector<T>& data)
{
    if (data.empty())
    {
        throw std::invalid_argument{"Data is empty."};
    }
 
    const auto index = number::integer<size_t>(data.size() - 1);
 
    return data[index];
}
 
template <class T>
T arrayElement(const std::initializer_list<T>& data)
{
    if (data.size() == 0)
    {
        throw std::invalid_argument{"Data is empty."};
    }
 
    const auto index = number::integer<size_t>(data.size() - 1);
 
    return *(data.begin() + index);
}
 
template <class T>
struct WeightedElement
{
    unsigned weight;
    T value;
};
 
template <class T>
T weightedArrayElement(const std::vector<WeightedElement<T>>& data)
{
    if (data.empty())
    {
        throw std::invalid_argument{"Data is empty."};
    }
 
    const auto sumOfWeights =
        std::accumulate(data.begin(), data.end(), 0u,
                        [](unsigned sum, const WeightedElement<T>& element) { return sum + element.weight; });
 
    if (sumOfWeights == 0u)
    {
        throw std::invalid_argument{"Sum of weights is zero."};
    }
 
    const std::integral auto targetWeightValue = number::integer<unsigned>(1, sumOfWeights);
 
    unsigned currentSum = 0;
    for (const auto& elem : data)
    {
        currentSum += elem.weight;
        if (currentSum >= targetWeightValue)
        {
            return elem.value;
        }
    }
 
    return data.back().value;
}
 
}