FSDKError.h

Go to the documentation of this file.

 
#pragma once
 
#include <fsdk/Types/Result.h>
 
namespace fsdk {
 
    enum class FSDKError : uint32_t {
        Ok,           
        Internal,     
        InvalidInput, 
        InvalidImage, 
 
        InvalidRect,             
        InvalidImageFormat,      
        InvalidImageSize,        
        InvalidDetection,        
        InvalidLandmarks5,       
        InvalidLandmarks68,      
        InvalidTransformation,   
        InvalidDescriptor,       
        InvalidDescriptorBatch,  
        InvalidSettingsProvider, 
        InvalidDescriptorId,     
        InvalidPath,             
        InvalidSerializedObject, 
 
        ModuleNotInitialized, 
        ModuleNotReady,       
        LicenseError,         
 
        BufferIsNull,      
        BufferIsFull,      
        BufferIsEmpty,     
        InvalidBufferSize, 
        InvalidSpanSize,   
        InvalidBatch,      
 
        IncompatibleDescriptors, 
        EnableJustInBetaMode,    
 
        FiltredAggregationError, 
 
        BatchedInternalError, 
        UnsupportedFunctionality, // !< was requested unsupported functionality for this type of descroptor or for
                                                            // this model version
 
        HighMemoryUsage, // !< Operation required a lot of memory. Batch size if too big for example.
 
        IncompatibleModelVersions,      
        ModelNotLoaded,                 
        InvalidConfig,                  
        LicenseIsNotActivated,          
        LicenseActivationLimitExceeded, 
        FeatureNotAvailable,            
        FeatureExpired,                 
        FingerprintError,               
        FingerprintInternalMismatch,    
        ValidationFailed,               
        CudaError,                      
 
        NotImplemented, 
    };
 
    template <>
    struct ErrorTraits<FSDKError> {
 
        static bool isOk(FSDKError error) noexcept {
            return error == FSDKError::Ok;
        }
 
        static const char* toString(FSDKError error) noexcept {
            switch(error) {
            case FSDKError::Ok:
                return "Ok";
            case FSDKError::Internal:
                return "Internal error";
            case FSDKError::InvalidInput:
                return "Invalid input";
            case FSDKError::InvalidImage:
                return "Invalid image";
            case FSDKError::InvalidRect:
                return "Invalid rectangle";
            case FSDKError::InvalidImageFormat:
                return "Invalid image format";
            case FSDKError::InvalidImageSize:
                return "Invalid image size";
            case FSDKError::InvalidDetection:
                return "Invalid detection";
            case FSDKError::InvalidLandmarks5:
                return "Invalid landmarks 5";
            case FSDKError::InvalidLandmarks68:
                return "Invalid landmarks 68";
            case FSDKError::InvalidTransformation:
                return "Invalid transformation.";
            case FSDKError::InvalidDescriptor:
                return "Invalid descriptor";
            case FSDKError::InvalidDescriptorBatch:
                return "Invalid descriptor batch.";
            case FSDKError::InvalidSettingsProvider:
                return "Invalid settings provider..";
            case FSDKError::InvalidDescriptorId:
                return "Invalid descriptor id.";
            case FSDKError::InvalidPath:
                return "Invalid path.";
            case FSDKError::InvalidSerializedObject:
                return "Invalid serialized object.";
            case FSDKError::ModuleNotInitialized:
                return "Module is not initialized";
            case FSDKError::ModuleNotReady:
                return "Module is not ready";
            case FSDKError::LicenseError:
                return "Licensing issue";
            case FSDKError::BufferIsNull:
                return "Buffer is null";
            case FSDKError::BufferIsFull:
                return "Buffer is full";
            case FSDKError::BufferIsEmpty:
                return "Buffer is empty";
            case FSDKError::InvalidBufferSize:
                return "Invalid buffer size";
            case FSDKError::InvalidSpanSize:
                return "Invalid span size";
            case FSDKError::InvalidBatch:
                return "Invalid Batch";
            case FSDKError::IncompatibleDescriptors:
                return "Descriptors are incompatible";
            case FSDKError::EnableJustInBetaMode:
                return "Attempt to create feature while betaMode is turned off";
            case FSDKError::FiltredAggregationError:
                return "Cant aggregate descriptors - all images'a GSs are less the threashold";
            case FSDKError::BatchedInternalError:
                return "Something gone wrong in batched query";
            case FSDKError::UnsupportedFunctionality:
                return "Was requested unsupported functionality";
            case FSDKError::HighMemoryUsage:
                return "Operation required a lot of memory";
            case FSDKError::IncompatibleModelVersions:
                return "Incompatible model versions";
            case FSDKError::ModelNotLoaded:
                return "Model not loaded";
            case FSDKError::InvalidConfig:
                return "Invalid config";
            case FSDKError::LicenseIsNotActivated:
                return "License is not activated!";
            case FSDKError::LicenseActivationLimitExceeded:
                return "License activation limit exceeded.";
            case FSDKError::FeatureNotAvailable:
                return "Requested Feature not available.";
            case FSDKError::FeatureExpired:
                return "Feature is expired.";
            case FSDKError::FingerprintError:
                return "Failed to get device fingerprint.";
            case FSDKError::FingerprintInternalMismatch:
                return "Fingerprint mismatch.";
            case FSDKError::ValidationFailed:
                return "Failed validation.";
            case FSDKError::CudaError:
                return "CUDA Error";
            case FSDKError::NotImplemented:
                return "Not implemented.";
            default:
                return "Unknown error";
            }
        }
    };
 
} // namespace fsdk