result_description.h

Go to the documentation of this file.

 
#ifndef _A_UTILS_CORE_RESULT_DESCRIPTION_H_
#define _A_UTILS_CORE_RESULT_DESCRIPTION_H_
 
#include <cstdint>
 
namespace A_UTILS_NS
{
 
namespace detail
{
 
template<typename DescriptionType>
struct result_description_traits
{
    using description_type = DescriptionType;                  
    using reference_counted_object_type = ireference_counted_object<DescriptionType>;
 
    static constexpr std::uint64_t error_code_bit = (std::uint64_t)1 << 63;
    static constexpr std::uint64_t error_code_bitmask = ~error_code_bit;
 
    static tBool is_detailed_description_set(const std::uint64_t i_pDescription) noexcept
    {
        //if the error code bit is not set, but other bits, detailed result was allocated
        return 0 == (i_pDescription & error_code_bit)
            && 0 != (i_pDescription & error_code_bitmask);
    }
 
    static tBool is_error_code_set(const std::uint64_t i_pDescription) noexcept
    {   
        //the error code bit indicates whether only the error code is set
        return error_code_bit == (i_pDescription & error_code_bit);
    }
};//struct result_description_traits
 
 
template<typename DescriptionType>
struct result_description
{
    using self_type   = result_description<DescriptionType>;        
    using desc_type   = DescriptionType;                            
    using traits_type = result_description_traits<DescriptionType>; 
 
    result_description() : m_pDetailedResult(0)
    {}
 
    result_description(const result_description& oOther): result_description()
    {
        *this = oOther;
    }
 
    result_description& operator=(const result_description& oOther)
    {
        using reference_counted_impl_type =
            typename traits_type::reference_counted_object_type;
 
        if (&oOther != this)
        {
            if (traits_type::is_detailed_description_set(m_pDetailedResult))
            {
                reinterpret_cast<reference_counted_impl_type*>(m_pDetailedResult)->RemoveReference();
            }
            m_pDetailedResult = oOther.m_pDetailedResult;
            if (traits_type::is_detailed_description_set(m_pDetailedResult))
            {
                reinterpret_cast<reference_counted_impl_type*>(m_pDetailedResult)->AddReference();
            }
        }
        return *this;
    }
 
    ~result_description()
    {
        if (traits_type::is_detailed_description_set(m_pDetailedResult))
        {
            using reference_counted_impl_type= typename traits_type::reference_counted_object_type;
            reinterpret_cast<reference_counted_impl_type*>(m_pDetailedResult)->RemoveReference();
        }
    }
 
    template<typename Implementation, typename... Args>
    static self_type make_result_description(const tErrorCode& i_oErrorCode, Args&&... args) noexcept;
 
    static self_type make_result_description(const tErrorCode& i_oErrorCode) noexcept
    {
        //use the entire pointer for the error code and set the error code bit appropriately
        //the user doesn't want to allocate space by calling this function, so just DON'T!
        return self_type(i_oErrorCode.value);
    }
 
    desc_type const* get_detailed_description() const noexcept
    {   
        //make sure, detailed description instead of error code is set
        if (traits_type::is_detailed_description_set(m_pDetailedResult))
        {
            return &reinterpret_cast<typename traits_type::reference_counted_object_type*>(m_pDetailedResult)->GetObject();
        }
        return nullptr;
    }
 
    tErrorCode get_error_code() const noexcept
    {
        //only return the error code if only the error code was set!
        if (traits_type::is_error_code_set(m_pDetailedResult))
        {
            return tErrorCode{
                static_cast<tErrorCode::error_code_type>(
                    (m_pDetailedResult | 0xFFFFFFFF00000000)
                    & traits_type::error_code_bitmask)
            };
        }
        return tErrorCode{ 0 };
    }
 
private:
    // On all systems, a 64Bit variable for storage
    // the most significant bits are used for user flags
    // size of pointer part is system dependent, lower bits
    std::uint64_t m_pDetailedResult;
 
    result_description(std::uint64_t nErrorCode) :
        //highly optimized code to bypass the cast on negative error codes...
        m_pDetailedResult(((nErrorCode & 0xFFFFFFFF) | traits_type::error_code_bit))
    {
    }
};//struct result_description
 
template<typename T>
inline tBool operator==(const result_description<T>& i_oLHS,
                        const result_description<T>& i_oRHS) noexcept
{   
    //we put the tests inside this function so it will be available for all specializations
    
    static_assert(sizeof(std::uintptr_t) <= 8,
                         "result_description pointers must always have a size of 8 Byte or less!");
    static_assert(sizeof(result_description<T>) == 8,
                        "Description type unsupported size!");
    static_assert(std::is_standard_layout<result_description<T>>::value,
                        "Description type is not of standard layout!");
 
    return i_oLHS.get_error_code() == i_oRHS.get_error_code()
        && i_oLHS.get_detailed_description() == i_oRHS.get_detailed_description();
}
 
template<typename T>
inline tBool operator!=(const result_description<T>& i_oLHS,
                        const result_description<T>& i_oRHS) noexcept
{
    return !(i_oLHS == i_oRHS);
}
 
}
 
}//ns A_UTILS_NS
 
#endif // _A_UTILS_CORE_RESULT_DESCRIPTION_H_