Utils.h

Go to the documentation of this file.

// Copyright Onix Solutions Limited [OnixS]. All rights reserved.
//
// This software owned by Onix Solutions Limited [OnixS] and is
// protected by copyright law and international copyright treaties.
//
// Access to and use of the software is governed by the terms of the applicable
// OnixS Software Services Agreement (the Agreement) and Customer end user license
// agreements granting a non-assignable, non-transferable and non-exclusive license
// to use the software for it's own data processing purposes under the terms defined
// in the Agreement.
//
// Except as otherwise granted within the terms of the Agreement, copying or
// reproduction of any part of this source code or associated reference material
// to any other location for further reproduction or redistribution, and any
// amendments to this copyright notice, are expressly prohibited.
//
// Any reproduction or redistribution for sale or hiring of the Software not in
// accordance with the terms of the Agreement is a violation of copyright law.
//
 
#pragma once
 
#include <cstddef>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
 
#include <OnixS/CME/MDH/Utils.h>
#include <OnixS/CME/MDH/PacketTraits.h>
#include <OnixS/CME/MDH/testing/ByteSpan.h>
#include <OnixS/CME/MDH/testing/MessageHolder.h>
 
ONIXS_CME_MDH_TESTING_NAMESPACE_BEGIN

namespace details {
 
template <class Collection, class = void>
struct IsByteSpanCollection : std::false_type {};
 
template <class Collection>
struct IsByteSpanCollection<Collection,
        typename Utils::MakeVoid<decltype(std::declval<Collection&>().data()),decltype(std::declval<Collection&>().size())>::type>
    : std::integral_constant<bool,
        (std::is_same<decltype(std::declval<Collection&>().data()), ByteSpan*>::value
            || std::is_same<decltype(std::declval<Collection&>().data()), const ByteSpan*>::value)
        && std::is_integral<typename std::remove_cv<decltype(std::declval<Collection&>().size())>::type>::value
        && !std::is_same<typename std::remove_cv<decltype(std::declval<Collection&>().size())>::type, bool>::value>
{};
 
template <class Collection>
using EnableIfByteSpanCollection = typename std::enable_if<IsByteSpanCollection<Collection>::value, int>::type;
 
template <class Count>
void validateNonNegativeSpanCount(Count count, std::true_type)
{
    if(count < 0)
        throw std::runtime_error("Byte span collection count cannot be negative.");
}
 
template <class Count>
void validateNonNegativeSpanCount(Count, std::false_type) noexcept {}
 
template <class Count>
std::size_t checkedSpanCount(Count suppliedCount, std::size_t maxSpansCount, std::size_t minSpansCount = 0)
{
    typedef typename std::remove_cv<Count>::type CountType;
    validateNonNegativeSpanCount(suppliedCount, std::is_signed<CountType>{});
 
    typedef typename std::common_type<CountType, std::size_t>::type Comparison;
    const Comparison count = static_cast<Comparison>(suppliedCount);
 
    if(count < static_cast<Comparison>(minSpansCount))
        throw std::runtime_error(
            "Byte span collection count is less than the minimum of " + std::to_string(minSpansCount) + ".");
 
    if(count > static_cast<Comparison>(maxSpansCount))
        throw std::runtime_error(
            "Byte span collection count exceeds the maximum of " + std::to_string(maxSpansCount) + ".");
 
    return static_cast<std::size_t>(suppliedCount);
}
 
struct SpanRange { const ByteSpan* data; std::size_t count; };
 
inline void validateSpans(const ByteSpan spans[], std::size_t spansCount)
{
    if(spansCount != 0 && spans == nullptr)
        throw std::runtime_error("Byte span collection data cannot be null when count is nonzero.");
 
    for(std::size_t i = 0; i < spansCount; ++i)
        if(!spans[i].empty() && spans[i].data() == nullptr)
            throw std::runtime_error("Byte span at index " + std::to_string(i) + " has null data and nonzero size.");
}
 
template <class Collection>
SpanRange checkedSpans(Collection& spans, std::size_t maxSpansCount, std::size_t minSpansCount = 0)
{
    const auto count = checkedSpanCount(spans.size(), maxSpansCount, minSpansCount);
    const auto data = spans.data();
    validateSpans(data, count);
    return {data, count};
}
 
} // namespace details

inline ByteSpan asSpan(const PacketHeader& header) noexcept
{
    return ByteSpan(reinterpret_cast<const ByteSpan::value_type*>(&header), sizeof(header));
}

template <typename MessageType, size_t MaxMessageSize>
inline ByteSpan asSpan(MessageHolder<MessageType, MaxMessageSize>& holder) noexcept
{
    return holder.toNetworkBytes();
}

template <typename MessageType, size_t MaxMessageSize>
inline ByteSpan asSpan(MessageHolder<MessageType, MaxMessageSize>&& holder) noexcept
{
    return holder.toNetworkBytes();
}
 
ONIXS_CME_MDH_TESTING_NAMESPACE_END