FLImagingBase/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_AlreadyExists,

        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_NumberExceeded,

        EResult_ParameterMissing,

        EResult_NotEnoughSpace,

        EResult_UnsupportedHardware,

        EResult_UnsupportedModule,

        EResult_Mismatched,

        EResult_PositiveNotAllowed,

        EResult_NegativeNotAllowed,

        EResult_ZeroNotAllowed,

        EResult_IncorrectPassword,

        EResult_InvalidView,

        EResult_AlreadyInUse,

        EResult_DeviceAlreadyInUse,

        EResult_DataFileNotFound,

        EResult_NeedToCalibrate,

        EResult_FailedToCalibrate,

        EResult_FullOfCapacity,

        EResult_IncompatibleMode,

        EResult_HipVersionMismatched,

        EResult_UndefinedHipErrorCode,
            
        EResult_HipFailure,
 


        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"[AlreadyExists]",
        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]",
        L"[NumberExceeded]",
        L"[ParameterMissing]",
        L"[NotEnoughSpace]",
        L"[UnsupportedHardware]",
        L"[UnsupportedModule]",
        L"[Mismatched]",
        L"[PositiveNotAllowed]",
        L"[NegativeNotAllowed]",
        L"[ZeroNotAllowed]",
        L"[IncorrectPassword]",
        L"[InvalidView]",
        L"[AlreadyInUse]",
        L"[DeviceAlreadyInUse]",
        L"[DataFileNotFound]",
        L"[NeedToCalibrate]",
        L"[FailedToCalibrate]",
        L"[FullOfCapacity]",
        L"[IncompatibleMode]",
        L"[HipVersionMismatched]",
        L"[UndefinedHipErrorCode]",
        L"[HipFailure]",
    };
 
    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;
    };
}
 
#if !defined(__clang__)
    #pragma make_public(FLImaging::CResult)
    #pragma make_public(FLImaging::EResult)
#endif