reference.h

Go to the documentation of this file.

/*
 * Copyright 2019 GridGain Systems, Inc. and Contributors.
 *
 * Licensed under the GridGain Community Edition License (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     https://www.gridgain.com/products/software/community-edition/gridgain-community-edition-license
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef _IGNITE_COMMON_REFERENCE
#define _IGNITE_COMMON_REFERENCE
 
#include <cstddef>
 
#include <ignite/common/common.h>
#include <ignite/common/concurrent.h>
#include <ignite/common/reference_impl.h>
 
namespace ignite
{
    template<typename T>
    class Reference;
 
    template<typename T>
    class ConstReference
    {
        template<typename>
        friend class ConstReference;
 
        template<typename>
        friend class Reference;
 
    public:
        ConstReference() :
            ptr(),
            offset(0)
        {
            // No-op.
        }
 
        explicit ConstReference(common::ConstReferenceImplBase* ptr, ptrdiff_t offset = 0) :
            ptr(ptr),
            offset(offset)
        {
            // No-op.
        }
 
        ConstReference(const ConstReference& other) :
            ptr(other.ptr),
            offset(other.offset)
        {
            // No-op.
        }
 
        template<typename T2>
        ConstReference(const ConstReference<T2>& other) :
            ptr(other.ptr),
            offset(other.offset)
        {
            T2* p0 = reinterpret_cast<T2*>(common::POINTER_CAST_MAGIC_NUMBER);
            T* p1 = static_cast<T*>(p0);
 
            ptrdiff_t diff = reinterpret_cast<ptrdiff_t>(p1) - reinterpret_cast<ptrdiff_t>(p0);
            offset += diff;
        }
 
        ConstReference& operator=(const ConstReference& other)
        {
            ptr = other.ptr;
            offset = other.offset;
 
            return *this;
        }
        
        template<typename T2>
        ConstReference& operator=(const ConstReference<T2>& other)
        {
            ptr = other.ptr;
            offset = other.offset;
 
            T2* p0 = reinterpret_cast<T2*>(common::POINTER_CAST_MAGIC_NUMBER);
            T* p1 = static_cast<T*>(p0);
 
            ptrdiff_t diff = reinterpret_cast<ptrdiff_t>(p1) - reinterpret_cast<ptrdiff_t>(p0);
            offset += diff;
 
            return *this;
        }
 
        ~ConstReference()
        {
            // No-op.
        }
 
        const T* Get() const
        {
            return reinterpret_cast<const T*>(reinterpret_cast<ptrdiff_t>(ptr.Get()->Get()) + offset);
        }
 
        bool IsNull() const
        {
            const common::ConstReferenceImplBase* raw = ptr.Get();
 
            return !raw || !raw->Get();
        }
 
    private:
        common::concurrent::SharedPointer<common::ConstReferenceImplBase> ptr;
 
        ptrdiff_t offset;
    };
 
    template<typename T>
    class Reference
    {
        template<typename>
        friend class Reference;
    public:
        Reference() :
            ptr(),
            offset(0)
        {
            // No-op.
        }
 
        explicit Reference(common::ReferenceImplBase* ptr, ptrdiff_t offset = 0) :
            ptr(ptr),
            offset(offset)
        {
            // No-op.
        }
 
        Reference(const Reference& other) :
            ptr(other.ptr),
            offset(other.offset)
        {
            // No-op.
        }
 
        template<typename T2>
        Reference(const Reference<T2>& other) :
            ptr(other.ptr),
            offset(other.offset)
        {
            T2* p0 = reinterpret_cast<T2*>(common::POINTER_CAST_MAGIC_NUMBER);
            T* p1 = static_cast<T*>(p0);
 
            ptrdiff_t diff = reinterpret_cast<ptrdiff_t>(p1) - reinterpret_cast<ptrdiff_t>(p0);
            offset += diff;
        }
 
        Reference& operator=(const Reference& other)
        {
            ptr = other.ptr;
            offset = other.offset;
 
            return *this;
        }
        
        template<typename T2>
        Reference& operator=(const Reference<T2>& other)
        {
            ptr = other.ptr;
            offset = other.offset;
 
            T2* p0 = reinterpret_cast<T2*>(common::POINTER_CAST_MAGIC_NUMBER);
            T* p1 = static_cast<T*>(p0);
 
            ptrdiff_t diff = reinterpret_cast<ptrdiff_t>(p1) - reinterpret_cast<ptrdiff_t>(p0);
            offset += diff;
 
            return *this;
        }
 
        ~Reference()
        {
            // No-op.
        }
 
        template<typename T2>
        operator ConstReference<T2>()
        {
            ConstReference<T2> cr;
 
            cr.ptr = ptr;
            cr.offset = offset;
 
            T2* p0 = reinterpret_cast<T2*>(common::POINTER_CAST_MAGIC_NUMBER);
            const T* p1 = static_cast<T*>(p0);
 
            ptrdiff_t diff = reinterpret_cast<ptrdiff_t>(p1) - reinterpret_cast<ptrdiff_t>(p0);
            cr.offset -= diff;
 
            return cr;
        }
 
        const T* Get() const
        {
            return reinterpret_cast<const T*>(reinterpret_cast<ptrdiff_t>(ptr.Get()->Get()) + offset);
        }
 
        T* Get()
        {
            return reinterpret_cast<T*>(reinterpret_cast<ptrdiff_t>(ptr.Get()->Get()) + offset);
        }
 
        bool IsNull() const
        {
            const common::ReferenceImplBase* raw = ptr.Get();
 
            return !raw || !raw->Get();
        }
 
    private:
        common::concurrent::SharedPointer<common::ReferenceImplBase> ptr;
 
        ptrdiff_t offset;
    };
 
    template<typename T>
    Reference<typename T::element_type> MakeReferenceFromSmartPointer(T ptr)
    {
        common::ReferenceSmartPointer<T>* impl = new common::ReferenceSmartPointer<T>();
 
        Reference<typename T::element_type> res(impl);
 
        impl->Swap(ptr);
 
        return res;
    }
 
    template<typename T>
    ConstReference<typename T::element_type> MakeConstReferenceFromSmartPointer(T ptr)
    {
        common::ReferenceSmartPointer<T>* impl = new common::ReferenceSmartPointer<T>();
 
        ConstReference<typename T::element_type> res(impl);
 
        impl->Swap(ptr);
 
        return res;
    }
 
    template<typename T>
    Reference<T> MakeReferenceFromCopy(const T& val)
    {
        common::ReferenceOwningRawPointer<T>* impl = new common::ReferenceOwningRawPointer<T>(new T(val));
 
        return Reference<T>(impl);
    }
 
    template<typename T>
    ConstReference<T> MakeConstReferenceFromCopy(const T& val)
    {
        common::ReferenceOwningRawPointer<T>* impl = new common::ReferenceOwningRawPointer<T>(new T(val));
 
        return ConstReference<T>(impl);
    }
 
    template<typename T>
    Reference<T> MakeReferenceFromOwningPointer(T* val)
    {
        common::ReferenceOwningRawPointer<T>* impl = new common::ReferenceOwningRawPointer<T>(val);
 
        return Reference<T>(impl);
    }
 
    template<typename T>
    ConstReference<T> MakeConstReferenceFromOwningPointer(T* val)
    {
        common::ReferenceOwningRawPointer<T>* impl = new common::ReferenceOwningRawPointer<T>(val);
 
        return ConstReference<T>(impl);
    }
 
    template<typename T>
    Reference<T> MakeReference(T& val)
    {
        common::ReferenceNonOwningRawPointer<T>* impl = new common::ReferenceNonOwningRawPointer<T>(&val);
 
        return Reference<T>(impl);
    }
 
    template<typename T>
    Reference<T> MakeReference(T* val)
    {
        common::ReferenceNonOwningRawPointer<T>* impl = new common::ReferenceNonOwningRawPointer<T>(val);
 
        return Reference<T>(impl);
    }
 
    template<typename T>
    ConstReference<T> MakeConstReference(const T& val)
    {
        common::ConstReferenceNonOwningRawPointer<T>* impl = new common::ConstReferenceNonOwningRawPointer<T>(&val);
 
        return ConstReference<T>(impl);
    }
 
    template<typename T>
    ConstReference<T> MakeConstReference(const T* val)
    {
        common::ConstReferenceNonOwningRawPointer<T>* impl = new common::ConstReferenceNonOwningRawPointer<T>(val);
 
        return ConstReference<T>(impl);
    }
}
 
#endif //_IGNITE_COMMON_REFERENCE