Result.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2021 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
JPH_NAMESPACE_BEGIN
 
// GCC doesn't properly detect that mState is used to ensure that mResult is initialized
JPH_GCC_SUPPRESS_WARNING("-Wmaybe-uninitialized")
 
 
template <class Type>
class Result
{
public:
                        Result()                                    { }
 
                        Result(const Result<Type> &inRHS) :
        mState(inRHS.mState)
    {
        switch (inRHS.mState)
        {
        case EState::Valid:
            ::new (&mResult) Type (inRHS.mResult);
            break;
 
        case EState::Error:
            ::new (&mError) String(inRHS.mError);
            break;
 
        case EState::Invalid:
            break;
        }
    }
 
                        Result(Result<Type> &&inRHS) noexcept :
        mState(inRHS.mState)
    {
        switch (inRHS.mState)
        {
        case EState::Valid:
            ::new (&mResult) Type (std::move(inRHS.mResult));
            break;
 
        case EState::Error:
            ::new (&mError) String(std::move(inRHS.mError));
            break;
 
        case EState::Invalid:
            break;
        }
 
        // Don't reset the state of inRHS, the destructors still need to be called after a move operation
    }
 
                        ~Result()                                   { Clear(); }
 
    Result<Type> &      operator = (const Result<Type> &inRHS)
    {
        Clear();
 
        mState = inRHS.mState;
 
        switch (inRHS.mState)
        {
        case EState::Valid:
            ::new (&mResult) Type (inRHS.mResult);
            break;
 
        case EState::Error:
            ::new (&mError) String(inRHS.mError);
            break;
 
        case EState::Invalid:
            break;
        }
 
        return *this;
    }
 
    Result<Type> &      operator = (Result<Type> &&inRHS) noexcept
    {
        Clear();
 
        mState = inRHS.mState;
 
        switch (inRHS.mState)
        {
        case EState::Valid:
            ::new (&mResult) Type (std::move(inRHS.mResult));
            break;
 
        case EState::Error:
            ::new (&mError) String(std::move(inRHS.mError));
            break;
 
        case EState::Invalid:
            break;
        }
 
        // Don't reset the state of inRHS, the destructors still need to be called after a move operation
 
        return *this;
    }
 
    void                Clear()
    {
        switch (mState)
        {
        case EState::Valid:
            mResult.~Type();
            break;
 
        case EState::Error:
            mError.~String();
            break;
 
        case EState::Invalid:
            break;
        }
 
        mState = EState::Invalid;
    }
 
    bool                IsEmpty() const                             { return mState == EState::Invalid; }
 
    bool                IsValid() const                             { return mState == EState::Valid; }
 
    const Type &        Get() const                                 { JPH_ASSERT(IsValid()); return mResult; }
 
    void                Set(const Type &inResult)                   { Clear(); ::new (&mResult) Type(inResult); mState = EState::Valid; }
 
    void                Set(Type &&inResult)                        { Clear(); ::new (&mResult) Type(std::move(inResult)); mState = EState::Valid; }
 
    bool                HasError() const                            { return mState == EState::Error; }
 
    const String &      GetError() const                            { JPH_ASSERT(HasError()); return mError; }
 
    void                SetError(const char *inError)               { Clear(); ::new (&mError) String(inError); mState = EState::Error; }
    void                SetError(const string_view &inError)        { Clear(); ::new (&mError) String(inError); mState = EState::Error; }
    void                SetError(String &&inError)                  { Clear(); ::new (&mError) String(std::move(inError)); mState = EState::Error; }
 
private:
    union
    {
        Type            mResult;                                    
        String          mError;                                     
    };
 
    enum class EState : uint8
    {
        Invalid,
        Valid,
        Error
    };
 
    EState              mState = EState::Invalid;
};
 
JPH_NAMESPACE_END