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/CME/MDH/Compiler.h>
#include <OnixS/CME/MDH/messaging/Integral.h>
#include <OnixS/CME/MDH/messaging/Utils.h>
 
#include <cstddef>
#include <cstring>
#include <cassert>
#include <memory>
#include <new>
 
ONIXS_CMEMDH_MESSAGING_NAMESPACE_BEGIN

typedef UInt8 Byte;

typedef UInt16 Word;

typedef UInt32 DWord;

typedef UInt64 QWord;

template<class T>
ONIXS_CMEMDH_FORCEINLINE T* fromExistingBytes(void* storage) noexcept
{
    static_assert(IsTriviallyCopyable<T>::value, "T must be trivially copiable");
    static_assert(IsTriviallyDefaultConstructible<T>::value, "T must be trivially default-constructible");
 
    assert(storage);
    assert(reinterpret_cast<std::uintptr_t>(storage) % alignof(T) == 0);
 
#if defined(ONIXS_CMEMDH_HAS_START_LIFETIME_AS)
    return std::start_lifetime_as<T>(storage);
#else
    return static_cast<T*>(storage);
#endif
}

template<class T>
ONIXS_CMEMDH_FORCEINLINE T* fromEmptyStorage(void* storage) noexcept
{
    static_assert(IsTriviallyCopyable<T>::value, "T must be trivially copiable");
    static_assert(IsTriviallyDefaultConstructible<T>::value, "T must be trivially default-constructible");
 
    assert(storage);
    assert(reinterpret_cast<std::uintptr_t>(storage) % alignof(T) == 0);
 
    return ::new (storage) T;
}

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

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

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

template <typename Type>
ONIXS_CMEMDH_FORCEINLINE Type* toMutableType(const Type* ptr) noexcept
{
    assert(ptr);
    return const_cast<Type*>(ptr);
}

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

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

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

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

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

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

template <class Value>
ONIXS_CMEMDH_FORCEINLINE Value extractValue(const void* location) noexcept
{
    assert(location);
 
    ONIXS_CMEMDH_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_CMEMDH_FORCEINLINE
    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>
    ONIXS_CMEMDH_FORCEINLINE
    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>
    ONIXS_CMEMDH_FORCEINLINE
    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_CMEMDH_FORCEINLINE typename std::enable_if<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_CMEMDH_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>
ONIXS_CMEMDH_FORCEINLINE
constexpr typename std::enable_if<!details::HasMemberTraits<Value>::value, size_t>::type size() noexcept
{
    return sizeof(Value);
}

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

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

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

template <class Value>
ONIXS_CMEMDH_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_CMEMDH_FORCEINLINE typename std::enable_if<details::HasValueStaticMember<Value>::value>::type
setValue(void* location, Value) noexcept
{
    assert(location);
    commitValue(location, Value::value());
}
 
ONIXS_CMEMDH_MESSAGING_NAMESPACE_END