packet_storage.h

Go to the documentation of this file.

#pragma once
 
#include "bcnp/static_vector.h"
#include <cstddef>
#include <type_traits>
#include <vector>
 
namespace bcnp {
 
namespace detail {
 
// Detection idiom helpers
template<typename, typename = void>
struct has_push_back : std::false_type {};
 
template<typename T>
struct has_push_back<T, std::void_t<decltype(std::declval<T>().push_back(std::declval<typename T::value_type>()))>> 
    : std::true_type {};
 
template<typename, typename = void>
struct has_size : std::false_type {};
 
template<typename T>
struct has_size<T, std::void_t<decltype(std::declval<T>().size())>> 
    : std::true_type {};
 
template<typename, typename = void>
struct has_clear : std::false_type {};
 
template<typename T>
struct has_clear<T, std::void_t<decltype(std::declval<T>().clear())>> 
    : std::true_type {};
 
template<typename, typename = void>
struct has_reserve : std::false_type {};
 
template<typename T>
struct has_reserve<T, std::void_t<decltype(std::declval<T>().reserve(std::size_t{}))>> 
    : std::true_type {};
 
template<typename, typename = void>
struct has_begin_end : std::false_type {};
 
template<typename T>
struct has_begin_end<T, std::void_t<decltype(std::declval<T>().begin()), decltype(std::declval<T>().end())>> 
    : std::true_type {};
 
template<typename, typename = void>
struct has_subscript : std::false_type {};
 
template<typename T>
struct has_subscript<T, std::void_t<decltype(std::declval<T>()[std::size_t{}])>> 
    : std::true_type {};
 
} // namespace detail
 
template<typename Container>
struct IsValidPacketStorage {
    static constexpr bool value = 
        detail::has_push_back<Container>::value &&
        detail::has_size<Container>::value &&
        detail::has_clear<Container>::value &&
        detail::has_reserve<Container>::value &&
        detail::has_begin_end<Container>::value &&
        detail::has_subscript<Container>::value;
};
 
template<typename Container>
inline constexpr bool IsValidPacketStorage_v = IsValidPacketStorage<Container>::value;
 
template<typename T>
using DynamicPacketStorage = std::vector<T>;
 
template<typename T, std::size_t Capacity = 64>
using StaticPacketStorage = StaticVector<T, Capacity>;
 
template<typename T>
using DefaultRealtimeStorage = StaticPacketStorage<T, 64>;
 
template<typename Container>
void ReserveIfPossible(Container& container, std::size_t capacity) {
    if constexpr (detail::has_reserve<Container>::value) {
        container.reserve(capacity);
    }
}
 
} // namespace bcnp