Memory.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 <OnixS/Euronext/MarketData/OptiqMdg/Compiler.h>
#include <OnixS/Euronext/MarketData/OptiqMdg/messaging/Integral.h>
#include <OnixS/Euronext/MarketData/OptiqMdg/messaging/Utils.h>
 
#include <cstddef>
#include <cstring>
#include <cassert>
#include <utility>
 
ONIXS_EURONEXT_OPTIQMDG_MESSAGING_NAMESPACE_BEGIN

typedef UInt8 Byte;

typedef UInt16 Word;

typedef UInt32 DWord;

typedef UInt64 QWord;

template
<
    typename Type
>
ONIXS_EURONEXT_OPTIQMDG_HOTPATH
ONIXS_EURONEXT_OPTIQMDG_PURE
void*
toOpaquePtr(Type* ptr)
    noexcept
{
    assert(ptr);
    return static_cast<void*>(ptr);
}

template
<
    typename Type
>
ONIXS_EURONEXT_OPTIQMDG_HOTPATH
ONIXS_EURONEXT_OPTIQMDG_PURE
const void*
toOpaquePtr(const Type* ptr)
    noexcept
{
    assert(ptr);
    return static_cast<const void*>(ptr);
}

template
<
    typename Type
>
ONIXS_EURONEXT_OPTIQMDG_HOTPATH
ONIXS_EURONEXT_OPTIQMDG_PURE
Byte*
toByteBlock(Type* ptr)
    noexcept
{
    assert(ptr);
 
    return
        static_cast
        <Byte*>
        (toOpaquePtr(ptr));
}

template
<
    typename Type
>
ONIXS_EURONEXT_OPTIQMDG_HOTPATH
ONIXS_EURONEXT_OPTIQMDG_PURE
const Byte*
toByteBlock(const Type* ptr)
    noexcept
{
    assert(ptr);
 
    return
        static_cast
        <const Byte*>
        (toOpaquePtr(ptr));
}

template
<
    typename Type
>
ONIXS_EURONEXT_OPTIQMDG_HOTPATH
ONIXS_EURONEXT_OPTIQMDG_PURE
Type* advanceByBytes(Type* pointer, ptrdiff_t distance) noexcept
{
    assert(pointer);
 
    return reinterpret_cast<Type*>(toByteBlock(pointer) + distance);
}

template
<
    typename Type
>
ONIXS_EURONEXT_OPTIQMDG_HOTPATH
ONIXS_EURONEXT_OPTIQMDG_PURE
Type*
advanceBackByBytes(
    Type* pointer,
    ptrdiff_t distance)
    noexcept
{
    assert(pointer);
 
    return
        reinterpret_cast<Type*>
        (
            toByteBlock(pointer) - distance
        );
}

template
<
    typename Left,
    typename Right
>
ONIXS_EURONEXT_OPTIQMDG_HOTPATH
ONIXS_EURONEXT_OPTIQMDG_PURE
ptrdiff_t
byteDistance(
    Left* left,
    Right* right)
    noexcept
{
    assert(left);
    assert(right);
 
    return (
        toByteBlock(left) -
        toByteBlock(right)
    );
}

template
<
    class Value
>
ONIXS_EURONEXT_OPTIQMDG_HOTPATH
Value
extractValue(const void* location) noexcept
{
    assert(location);
 
    CHECK_TYPE_INTEGRAL(Value);
 
    Value result;
 
    std::memcpy(
        &result,
        location,
        sizeof(Value));
 
    return result;
}

template <unsigned ArgsCount>
struct CompositeExtractor;

template <>
struct CompositeExtractor<1>
{
    template <class Value>
    static
    Value extract(const void* location) noexcept
    {
 
        static_assert(
            noexcept(
                Value(
                    std::declval<typename Value::MemberTraits::FirstArgType>()
                )
            ) ,
            "must be noexcept");
 
        assert(location);
 
        return
            Value(
                extractValue<typename Value::MemberTraits::FirstArgType>(location)
            );
    }
};

template <>
struct CompositeExtractor<2>
{
    template <class Value>
    static
    Value extract(const void* location) noexcept
    {
        typedef typename Value::MemberTraits::FirstArgType FirstArgType;
        typedef typename Value::MemberTraits::SecondArgType SecondArgType;
 
        static_assert(
            noexcept(
                Value(
                    std::declval<FirstArgType>(),
                    std::declval<SecondArgType>()
                )
            ) ,
            "must be noexcept");
 
        assert(location);
 
        return
            Value(
                extractValue<FirstArgType>(location),
                extractValue<SecondArgType>(
                    advanceByBytes(location, sizeof(FirstArgType)))
            );
    }
};

template <>
struct CompositeExtractor<4>
{
    template <class Value>
    static
    Value extract(const void* location) noexcept
    {
        typedef typename Value::MemberTraits::FirstArgType FirstArgType;
        typedef typename Value::MemberTraits::SecondArgType SecondArgType;
        typedef typename Value::MemberTraits::ThirdArgType ThirdArgType;
        typedef typename Value::MemberTraits::FourthArgType FourthArgType;
 
        static_assert(
            noexcept(
                Value(
                    std::declval<FirstArgType>(),
                    std::declval<SecondArgType>(),
                    std::declval<ThirdArgType>(),
                    std::declval<FourthArgType>()
                )
            ) ,
            "must be noexcept");
 
        assert(location);
 
        return
            Value(
                extractValue<FirstArgType>(location),
                extractValue<SecondArgType>(
                    advanceByBytes(location, sizeof(FirstArgType))),
                extractValue<ThirdArgType>(
                    advanceByBytes(location, sizeof(FirstArgType) + sizeof(SecondArgType))),
                extractValue<FourthArgType>(
                    advanceByBytes(location, sizeof(FirstArgType) + sizeof(SecondArgType) + sizeof(ThirdArgType)))
            );
    }
};

template
<
    class Value
>
ONIXS_EURONEXT_OPTIQMDG_HOTPATH
typename EnableIf<details::HasMemberTraits<Value>::value, Value>::type
getValue(const void* location) noexcept
{
    assert(location);
    return CompositeExtractor<Value::MemberTraits::Count>:: template extract<Value>(location);
}

template
<
    class Value
>
ONIXS_EURONEXT_OPTIQMDG_HOTPATH
typename EnableIf<!details::HasMemberTraits<Value>::value, Value>::type
getValue(const void* location) noexcept
{
    assert(location);
    return extractValue<Value>(location);
}

template
<
    class Value
>
constexpr
typename EnableIf<!details::HasMemberTraits<Value>::value, size_t>::type
size() noexcept
{
    return sizeof(Value);
}

template
<
    class Value
>
constexpr
typename EnableIf<details::HasMemberTraits<Value>::value, size_t>::type
size() noexcept
{
    return Value::Size;
}

template
<
    class Value
>
ONIXS_EURONEXT_OPTIQMDG_HOTPATH
typename EnableIf<!details::HasSerializeMember<Value>::value>::type
commitValue(void* location, Value value)
    noexcept
{
    assert(location);
    std::memcpy(
        location,
        &value,
        sizeof(Value));
}

template
<
    class Value
>
ONIXS_EURONEXT_OPTIQMDG_HOTPATH
typename EnableIf<details::HasSerializeMember<Value>::value>::type
commitValue(void* location, Value value)
    noexcept
{
    assert(location);
    value.serialize(location);
}

template
<
    class Value
>
ONIXS_EURONEXT_OPTIQMDG_HOTPATH
typename EnableIf<!details::HasValueStaticMember<Value>::value>::type
setValue(void* location, Value value)
    noexcept
{
    assert(location);
    commitValue(location, value);
}

template
<
    class Value
>
ONIXS_EURONEXT_OPTIQMDG_HOTPATH
typename EnableIf<details::HasValueStaticMember<Value>::value>::type
setValue(void* location, Value)
    noexcept
{
    assert(location);
    commitValue(location, Value::value());
}
 
ONIXS_EURONEXT_OPTIQMDG_MESSAGING_NAMESPACE_END