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/ICE/BOE/Compiler.h>
#include <OnixS/ICE/BOE/messaging/Integral.h>
#include <OnixS/ICE/BOE/messaging/Utils.h>
 
#include <cstddef>
#include <cstring>
#include <cassert>
 
ONIXS_ICEBOE_MESSAGING_NAMESPACE_BEGIN

typedef UInt8 Byte;

typedef UInt16 Word;

typedef UInt32 DWord;

typedef UInt64 QWord;

 
template<typename Type>
ONIXS_ICEBOE_HOTPATH
ONIXS_ICEBOE_PURE
ONIXS_ICEBOE_FORCEINLINE
void* toOpaquePtr(Type* ptr) noexcept
{
    assert(ptr);
    return static_cast<void*>(ptr);
}

 
template <typename Type>
ONIXS_ICEBOE_HOTPATH
ONIXS_ICEBOE_PURE
ONIXS_ICEBOE_FORCEINLINE
const void* toOpaquePtr(const Type* ptr) noexcept
{
    assert(ptr);
    return static_cast<const void*>(ptr);
}
 
 
template <typename Type>
ONIXS_ICEBOE_HOTPATH
ONIXS_ICEBOE_PURE
ONIXS_ICEBOE_FORCEINLINE
void* toMutable(const Type* ptr) noexcept
{
    assert(ptr);
    return const_cast<void*>(static_cast<const void*>(ptr));
}

 
template<typename Type>
ONIXS_ICEBOE_HOTPATH
ONIXS_ICEBOE_PURE
ONIXS_ICEBOE_FORCEINLINE
Byte* toByteBlock(Type* ptr) noexcept
{
    assert(ptr);
    return static_cast<Byte*>(toOpaquePtr(ptr));
}

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

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

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

 
template<typename Left, typename Right>
ONIXS_ICEBOE_HOTPATH
ONIXS_ICEBOE_PURE
ONIXS_ICEBOE_FORCEINLINE
ptrdiff_t byteDistance(Left* left, Right* right) noexcept
{
    assert(left);
    assert(right);
 
    return (toByteBlock(left) - toByteBlock(right));
}
 
 
template<class Value>
ONIXS_ICEBOE_FORCEINLINE
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>
    ONIXS_ICEBOE_FORCEINLINE
    static std::tuple<typename Value::MemberTraits::FirstArgType>
        extractAsTuple(const void* location) noexcept
    {
        typedef typename Value::MemberTraits::FirstArgType  FirstArgType;
 
        static_assert(std::is_nothrow_constructible<Value, FirstArgType>::value,
                      "Value must be nothrow-constructible from its member types");
 
        assert(location);
 
        return std::tuple<FirstArgType>(extractValue<FirstArgType>(location));
    }
};
 
 
template <>
struct CompositeExtractor<2>
{
    template <class Value>
    static std::tuple
        <
            typename Value::MemberTraits::FirstArgType,
            typename Value::MemberTraits::SecondArgType
        >
    ONIXS_ICEBOE_FORCEINLINE
    extractAsTuple(const void* location) noexcept
    {
        typedef typename Value::MemberTraits::FirstArgType  FirstArgType;
        typedef typename Value::MemberTraits::SecondArgType SecondArgType;
 
        static_assert(std::is_nothrow_constructible<
                              Value,
                              FirstArgType, SecondArgType>::value,
                      "Value must be nothrow-constructible from its member types");
 
        assert(location);
 
        return std::tuple<FirstArgType, SecondArgType>(
                extractValue<FirstArgType>(location),
                extractValue<SecondArgType>(advanceByBytes(location, sizeof(FirstArgType)))
        );
    }
};
 
 
template <>
struct CompositeExtractor<3>
{
    template <class Value>
    ONIXS_ICEBOE_FORCEINLINE
    static std::tuple
        <
            typename Value::MemberTraits::FirstArgType,
            typename Value::MemberTraits::SecondArgType,
            typename Value::MemberTraits::ThirdArgType
        >
        extractAsTuple(const void* location) noexcept
    {
        typedef typename Value::MemberTraits::FirstArgType  FirstArgType;
        typedef typename Value::MemberTraits::SecondArgType SecondArgType;
        typedef typename Value::MemberTraits::ThirdArgType  ThirdArgType;
 
        static_assert(std::is_nothrow_constructible<
                              Value,
                              FirstArgType, SecondArgType, ThirdArgType>::value,
                      "Value must be nothrow-constructible from its member types");
 
        assert(location);
 
        return std::tuple<FirstArgType, SecondArgType, ThirdArgType>(
                extractValue<FirstArgType>(location),
                extractValue<SecondArgType>(advanceByBytes(location, sizeof(FirstArgType))),
                extractValue<ThirdArgType>(advanceByBytes(location, sizeof(FirstArgType) + sizeof(SecondArgType)))
        );
    }
};
 
 
 
template <>
struct CompositeExtractor<4>
{
    template <class Value>
    ONIXS_ICEBOE_FORCEINLINE
    static std::tuple
        <
            typename Value::MemberTraits::FirstArgType,
            typename Value::MemberTraits::SecondArgType,
            typename Value::MemberTraits::ThirdArgType,
            typename Value::MemberTraits::FourthArgType
        >
    extractAsTuple(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(std::is_nothrow_constructible<
                              Value,
                              FirstArgType, SecondArgType, ThirdArgType, FourthArgType>::value,
                      "Value must be nothrow-constructible from its member types");
 
        assert(location);
 
        return std::tuple<FirstArgType, SecondArgType, ThirdArgType, FourthArgType>(
                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_ICEBOE_FORCEINLINE
typename std::enable_if<details::HasMemberTraits<Value>::value, Value>::type
getValue(const void* location) noexcept(noexcept(makeFromTuple<Value>(CompositeExtractor<Value::MemberTraits::Count>:: template extractAsTuple<Value>(location))))
{
    assert(location);
    return makeFromTuple<Value>(CompositeExtractor<Value::MemberTraits::Count>:: template extractAsTuple<Value>(location));
}
 
 
template <class Value>
ONIXS_ICEBOE_FORCEINLINE
typename std::enable_if<!details::HasMemberTraits<Value>::value, Value>::type
getValue(const void* location) noexcept
{
    assert(location);
    return extractValue<Value>(location);
}
 
 
template <class Value>
constexpr typename std::enable_if<!details::HasMemberTraits<Value>::value, size_t>::type
size() noexcept
{
    return sizeof(cleanType<Value>);
}
 
 
template <class Value>
constexpr typename std::enable_if<details::HasMemberTraits<Value>::value, size_t>::type
size() noexcept
{
    return Value::Size;
}
 
 
template <class Value>
ONIXS_ICEBOE_FORCEINLINE
typename std::enable_if<!details::HasSerializeMember<Value>::value>::type
commitValue(void* location, Value value) noexcept
{
    assert(location);
    static_assert(details::smallType<Value>::value, ONIXS_ICEBOE_TO_STR(Value));
    std::memcpy(location, &value, sizeof(Value));
}
 
 
template <class Value>
ONIXS_ICEBOE_HOTPATH
typename std::enable_if<details::HasSerializeMember<Value>::value>::type
ONIXS_ICEBOE_FORCEINLINE
commitValue(void* location, Value value) noexcept
{
    assert(location);
    value.serialize(location);
}
 
 
template <class Value>
ONIXS_ICEBOE_FORCEINLINE
typename std::enable_if<!details::HasValueStaticMember<Value>::value>::type
setValue(void* location, Value value) noexcept
{
    assert(location);
    commitValue(location, value);
}
 
 
template <class Value>
ONIXS_ICEBOE_FORCEINLINE
typename std::enable_if<details::HasValueStaticMember<Value>::value>::type
setValue(void* location, Value) noexcept
{
    assert(location);
    commitValue(location, Value::value());
}
 
ONIXS_ICEBOE_MESSAGING_NAMESPACE_END