ResultsDef.h

#pragma once
 
namespace FLImaging
{
    enum EResult
    {
        EResult_UnknownError = -1,
 
        EResult_OK = 0,
 
        EResult_PartialOK,
 
        EResult_FailedToInitialize,
 
        EResult_FailedToTerminate,
 
        EResult_NeedToInitialize,
 
        EResult_NeedToTerminate,
 
        EResult_FailedToCreateThread,
 
        EResult_FailedToSuspendThread,
 
        EResult_FailedToResumeThread,
 
        EResult_FailedToCreateDevice,
 
        EResult_FailedToCreateKernelObject,
 
        EResult_FailedToCreateObject,
 
        EResult_InvalidParameter,
 
        EResult_NullPointer,
 
        EResult_NotEnoughMemory,
 
        EResult_BufferDoesNotExist,
 
        EResult_NoData,
 
        EResult_OutOfRange,
 
        EResult_NoResult,
 
        EResult_EmptyElement,
 
        EResult_InvalidHandle,
 
        EResult_FailedToModify,
 
        EResult_InvalidItem,
 
        EResult_LackOfBasicData,
 
        EResult_ZeroSize,
 
        EResult_CountMismatch,
 
        EResult_InvalidData,
 
        EResult_FailedToOpen,
 
        EResult_FailedToRead,
 
        EResult_FailedToWrite,
 
        EResult_InvalidFile,
 
        EResult_FailedToSend,
 
        EResult_FailedToReceive,
 
        EResult_FailedToBind,
 
        EResult_FailedToListen,
 
        EResult_FailedToConnect,
 
        EResult_FailedToSetParam,
 
        EResult_FailedToProcess,
 
        EResult_UnsupportedDepth,
 
        EResult_UnsupportedChannels,
 
        EResult_Timeout,
 
        EResult_UnsupportedVersion,
 
        EResult_InvalidObject,
 
        EResult_DifferentChannel,
 
        EResult_DifferentDepth,
 
        EResult_UnsupportedRegionOfInterest,
 
        EResult_DidNotImplement,
 
        EResult_UnsupportedFormat,
 
        EResult_FileNotFound,
 
        EResult_ClassTypeDoesNotMatch,
 
        EResult_CouldNotFindLicense,
 
        EResult_DifferentType,
 
        EResult_CouldNotFind,
 
        EResult_UnsupportedFunction,
 
        EResult_TooSmall,
 
        EResult_NotEnoughMappingData,
 
        EResult_CanBeInaccurate,
 
        EResult_FailedToExecute,
 
        EResult_FailedToCalculate,
 
        EResult_UnsupportedType,
 
        EResult_DifferentTemplate,
 
        EResult_InvalidElement,
 
        EResult_NoCollision,
 
 
        EResult_FailedToFind,
 
        EResult_FailedToLoad,
 
        EResult_FailedToCreate,
 
        EResult_FailedToSearch,
 
        EResult_FailedToStop,
 
        EResult_LearnedImageDoesNotExist,
 
        EResult_UnsupportedTypeOfROI,
 
        EResult_ImageDoesNotExist,
 
        EResult_InvalidROI,
 
        EResult_DoesNotIntersect,
 
        EResult_FailedToCreateAlgorithm,
 
        EResult_FailedToCreateImage,
 
        EResult_FailedToCopyImage,
 
        EResult_FailedToLearn,
 
        EResult_FailedToDecode,
 
        EResult_FailedToEncode,
 
        EResult_DifferentFormat,
 
        EResult_FailedToAutoDetect,
 
        EResult_NeedToStop,
 
        EResult_NeedToLoadDLL,
 
        EResult_NeedToGrabOrLive,
 
        EResult_FailedToReadFromDevice,
 
        EResult_FailedToReadParameter,
 
        EResult_FailedToWriteToDevice,
 
        EResult_FailedToWriteToParameter,
 
        EResult_LiveStatus,
 
        EResult_FailedToGrab,
 
        EResult_FailedToLive,
 
        EResult_CouldNotFindModules,
 
        EResult_GdiObjectCapacityIsFull,
 
        EResult_AlreadyCreated,
 
        EResult_DifferentSize,
 
        EResult_CouldNotFindFunction,
 
        EResult_CouldNotFindVariable,
 
        EResult_SyntaxError,
 
        EResult_InvalidVariable,
 
        EResult_UnsupportedProcessingUnit,
 
        EResult_HigherLicenseRequired,
 
        EResult_CudaVersionMismatched,
 
        EResult_Cancel,
 
        EResult_BrokenData,
 
        EResult_NotCompressedData,
            
        EResult_NotPlainData,
 
        EResult_UnsupportedOperatingSystem,
 
        EResult_Undefined,
 
        EResult_InvalidLabel,
 
        EResult_ThereIsNoRegion,    
 
        EResult_FailedToFindView,
 
        EResult_Stop,
 
        EResult_Abort,
 
        EResult_InvalidSize,
 
        EResult_NeedToLearn,
 
        EResult_CouldNotFindDevice,
 
        EResult_NotSquareImage,
 
 
        EResult_AlreadyRunning,
 
 
        EResult_BroadcastFailure,
 
        EResult_InvalidShape,
 
        EResult_ShapeMismatched,
 
        EResult_InvalidDevice,
 
        EResult_InvalidComputationalGraph,
 
        EResult_FailedToMeasure,
 
        EResult_Busy,
 
        EResult_FailedToLogIn,
 
        EResult_DoesNotExist,
 
        EResult_PermissionDenied,
 
        EResult_InvalidKey,
 
        EResult_AlreadyExistence,
 
        EResult_UndefinedCudaErrorCode,
 
        EResult_UnsupportedFigure,
 
        EResult_InvalidFigure,
 
        EResult_NeedToUpdate,
    
        EResult_CudaFailure,
 
        EResult_UnsupportedDevice,
 
        EResult_AlreadyInitialized,
 
        EResult_NeedToRun,
 
        EResult_NeedToExecute,
        
        EResult_NeedToConnect,
        
        EResult_NeedToDisconnect,
        
        EResult_NeedToLoad,
        
        EResult_NeedToSave,
        
        EResult_NeedToModify,
        
        EResult_NeedToValidate,
        
        EResult_NeedToLogIn,
        
        EResult_NeedToLogOut,
 
        EResult_NoUpdate,
 
        EResult_NotEmpty,
 
        EResult_NotReady,
 
        EResult_FailedToDelete,
 
 
        EResult_COUNT,
    };
 
    static const wchar_t* g_arrWcsResultMessage[] =
    {
        L"[UnknownError]",
        L"[OK]",
        L"[PartialOK]",
        L"[FailedToInitialize]",
        L"[FailedToTerminate]",
        L"[NeedToInitialize]",
        L"[NeedToTerminate]",
        L"[FailedToCreateThread]",
        L"[FailedToSuspendThread]",
        L"[FailedToResumeThread]",
        L"[FailedToCreateDevice]",
        L"[FailedToCreateKernelObject]",
        L"[FailedToCreateObject]",
        L"[InvalidParameter]",
        L"[NullPointer]",
        L"[NotEnoughMemory]",
        L"[BufferDoesNotExist]",
        L"[NoData]",
        L"[OutOfRange]",
        L"[NoResult]",
        L"[EmptyElement]",
        L"[InvalidHandle]",
        L"[FailedToModify]",
        L"[InvalidItem]",
        L"[LackOfBasicData]",
        L"[ZeroSize]",
        L"[CountMismatch]",
        L"[InvalidData]",
        L"[FailedToOpen]",
        L"[FailedToRead]",
        L"[FailedToWrite]",
        L"[InvalidFile]",
        L"[FailedToSend]",
        L"[FailedToReceive]",
        L"[FailedToBind]",
        L"[FailedToListen]",
        L"[FailedToConnect]",
        L"[FailedToSetParam]",
        L"[FailedToProcess]",
        L"[UnsupportedDepth]",
        L"[UnsupportedChannels]",
        L"[Timeout]",
        L"[UnsupportedVersion]",
        L"[InvalidObject]",
        L"[DifferentChannel]",
        L"[DifferentDepth]",
        L"[UnsupportedRegionOfInterest]",
        L"[DidNotImplement]",
        L"[UnsupportedFormat]",
        L"[FileNotFound]",
        L"[ClassTypeDoesNotMatch]",
        L"[CouldNotFindLicense]",
        L"[DifferentType]",
        L"[CouldNotFind]",
        L"[UnsupportedFunction]",
        L"[TooSmall]",
        L"[NotEnoughMappingData]",
        L"[CanBeInaccurate]",
        L"[FailedToExecute]",
        L"[FailedToCalculate]",
        L"[UnsupportedType]",
        L"[DifferentTemplate]",
        L"[InvalidElement]",
        L"[NoCollision]",
        L"[FailedToFind]",
        L"[FailedToLoad]",
        L"[FailedToCreate]",
        L"[FailedToSearch]",
        L"[FailedToStop]",
        L"[LearnedImageDoesNotExist]",
        L"[UnsupportedTypeOfROI]",
        L"[ImageDoesNotExist]",
        L"[InvalidROI]",
        L"[DoesNotIntersect]",
        L"[FailedToCreateAlgorithm]",
        L"[FailedToCreateImage]",
        L"[FailedToCopyImage]",
        L"[FailedToLearn]",
        L"[FailedToDecode]",
        L"[FailedToEncode]",
        L"[DifferentFormat]",
        L"[FailedToAutoDetect]",
        L"[NeedToStop]",
        L"[NeedToLoadDLL]",
        L"[NeedToGrabOrLive]",
        L"[FailedToReadFromDevice]",
        L"[FailedToReadFromParameter]",
        L"[FailedToWriteToDevice]",
        L"[FailedToWriteToParameter]",
        L"[LiveStatus]",
        L"[FailedToGrab]",
        L"[FailedToLive]",
        L"[CouldNotFindModules]",
        L"[GdiObjectCapacityIsFull]",
        L"[AlreadyCreated]",
        L"[DifferentSize]",
        L"[CouldNotFindFunction]",
        L"[CouldNotFindVariable]",
        L"[SyntaxError]",
        L"[InvalidVariable]",
        L"[UnsupportedProcessingUnit]",
        L"[HigherLicenseRequired]",
        L"[CudaVersionMismatched]",
        L"[Cancel]",
        L"[BrokenData]",
        L"[NotCompressedData]",
        L"[NotPlainData]",
        L"[UnsupportedOperatingSystem]",
        L"[Undefined]",
        L"[InvalidLabel]",
        L"[ThereIsNoRegion]",
        L"[FailedToFindView]",
        L"[Stop]",
        L"[Abort]",
        L"[InvalidSize]",
        L"[NeedToLearn]",
        L"[CouldNotFindDevice]",
        L"[NotSquareImage]",
        L"[AlreadyRunning]",
        L"[BroadcastFailure]",
        L"[InvalidShape]",
        L"[ShapeMismatched]",
        L"[InvalidDevice]",
        L"[InvalidComputationalGraph]",
        L"[FailedToMeasure]",
        L"[Busy]",
        L"[FailedToLogIn]",
        L"[DoesNotExist]",
        L"[PermissionDenied]",
        L"[InvalidKey]",
        L"[AlreadyExistence]",
        L"[UndefinedCudaErrorCode]",
        L"[UnsupportedFigure]",
        L"[InvalidFigure]",
        L"[NeedToUpdate]",
        L"[CudaFailure]",
        L"[UnsupportedDevice]",
        L"[AlreadyInitialized]",
        L"[NeedToRun]",
        L"[NeedToExecute]",
        L"[NeedToConnect]",
        L"[NeedToDisconnect]",
        L"[NeedToLoad]",
        L"[NeedToSave]",
        L"[NeedToModify]",
        L"[NeedToValidate]",
        L"[NeedToLogIn]",
        L"[NeedToLogOut]",
        L"[NoUpdate]",
        L"[NotEmpty]",
        L"[NotReady]",
        L"[FailedToDelete]",
    };
 
    static_assert((sizeof(g_arrWcsResultMessage) / sizeof(wchar_t*)) == ((int32_t)EResult_COUNT + 1), "Count mismatched between enumeration and string array.");
 
    inline bool IsOK(const EResult eResult)
    {
        return EResult_OK == eResult || eResult == EResult_PartialOK;
    }
 
    inline bool IsStrictOK(const EResult eResult)
    {
        return EResult_OK == eResult;
    }
 
    inline bool IsFail(const EResult eResult)
    {
        return EResult_OK != eResult && eResult != EResult_PartialOK;
    }
 
    inline bool IsStrictFail(const EResult eResult)
    {
        return EResult_OK != eResult;
    }
 
    inline const wchar_t* GetResultString(const EResult eResult)
    {
        return ((int32_t)eResult >= -1 && eResult < EResult_COUNT) ? (g_arrWcsResultMessage[((int32_t)eResult) + 1]) : nullptr;
    }
 
 
    class FL_EXPORT CResult
    {
    public:
        CResult()
        {
            m_eResult = EResult_UnknownError;
        }
 
        CResult(const CResult& res)
        {
            m_eResult = res.m_eResult;
        }
 
        CResult(const EResult eResult)
        {
            m_eResult = eResult;
        }
 
        const CResult& operator=(const CResult& res)
        {
            Assign(res);
            return *this;
        }
 
        const CResult& operator=(const EResult eResult)
        {
            Assign(eResult);
            return *this;
        }
 
        bool operator==(const CResult& res) const
        {
            return Equal(res.m_eResult);
        }
 
        bool operator==(const EResult eResult) const
        {
            return Equal(eResult);
        }
 
        bool operator!=(const CResult& res) const
        {
            return !Equal(res.m_eResult);
        }
 
        bool operator!=(const EResult eResult) const
        {
            return !Equal(eResult);
        }
 
        operator EResult() const
        {
            return m_eResult;
        }
 
        operator bool() const
        {
            return IsOK();
        }
 
        operator int32_t() const
        {
            return (int32_t)m_eResult;
        }
 
        operator uint32_t() const
        {
            return (uint32_t)m_eResult;
        }
 
        operator int64_t() const
        {
            return (int64_t)m_eResult;
        }
 
        operator uint64_t() const
        {
            return (uint64_t)m_eResult;
        }
 
        bool Assign(const CResult& res)
        {
            m_eResult = res.m_eResult;
            return true;
        }
 
        bool Assign(const EResult eResult)
        {
            m_eResult = eResult;
            return true;
        }
 
        bool Equal(const CResult& res) const
        {
            return m_eResult == res.m_eResult;
        }
 
        bool Equal(const EResult eResult) const
        {
            return m_eResult == eResult;
        }
 
        virtual bool IsOK() const
        {
            return EResult_OK == m_eResult || m_eResult == EResult_PartialOK;
        }
 
        virtual bool IsStrictOK() const
        {
            return EResult_OK == m_eResult;
        }
 
        virtual bool IsFail() const
        {
            return EResult_OK != m_eResult && m_eResult != EResult_PartialOK;
        }
 
        virtual bool IsStrictFail() const
        {
            return EResult_OK != m_eResult;
        }
 
        virtual int32_t GetResultCode() const
        {
            return (int32_t)m_eResult;
        }
 
        virtual const wchar_t* GetString() const
        {
            return ((int32_t)m_eResult >= -1 && m_eResult < EResult_COUNT) ? (g_arrWcsResultMessage[((int32_t)m_eResult) + 1]) : nullptr;
        }
 
        virtual EResult GetResult() const
        {
            return m_eResult;
        }
 
        friend bool operator==(const EResult eResult, const CResult& res)
        {
            return res.Equal(eResult);
        }
 
        friend bool operator!=(const EResult eResult, const CResult& res)
        {
            return !res.Equal(eResult);
        }
 
    protected:
        EResult m_eResult;
    };
}
 
#pragma make_public(FLImaging::CResult)
#pragma make_public(FLImaging::EResult)