error.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <system_error>
#include <promeki/namespace.h>
#include <promeki/platform.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class String;
 
class Error {
        public:
                enum Code {
                        Ok = 0,                  
                        UnsupportedSystemError,  
                        LibraryFailure,          
                        SingularMatrix,          
                        NotImplemented,          
                        PixelFormatNotSupported, 
                        OutOfRange,              
                        PermissionDenied,        
                        TryAgain,                
                        BadFileDesc,             
                        Busy,                    
                        Exists,                  
                        BadAddress,              
                        TooLarge,                
                        Interrupt,               
                        Invalid,                 
                        IOError,                 
                        IsDir,                   
                        TooManyOpenFiles,        
                        TooManyOpenSysFiles,     
                        NotExist,                
                        NoMem,                   
                        NoSpace,                 
                        NotDir,                  
                        NoPermission,            
                        ReadOnly,                
                        IllegalSeek,             
                        Timeout,                 
                        CrossDeviceLink,         
                        NoFrameRate,             
                        AlreadyOpen,             
                        NotSupported,            
                        OpenFailed,              
                        NotOpen,                 
                        EndOfFile,               
                        InvalidArgument,         
                        InvalidDimension,        
                        NotHostAccessible,       
                        BufferTooSmall,          
                        IdNotFound,              
                        ConversionFailed,        
                        Stopped,                 
                        Cancelled,               
                        DecodeFailed,            
                        EncodeFailed,            
                        CorruptData,             
                        DeviceError,             
                        DeviceNotFound,          
                        FormatMismatch,          
                        FontUnavailable,         
                        BrokenPipe,              
                        ConnectionReset,     
                        ConnectionRefused,   
                        HostNotFound,        
                        ParseFailed,         
                        ClockDomainMismatch, 
                        ObjectGone,          
                        ClockPaused,         
                        DurationUnknown,     
                        FrameRangeInfinite, 
                        NotAdjacent,        
                        PipelineBuildFailed, 
                        PipelineRuntimeError, 
                        InspectorDiscontinuityDetected, 
                        Empty,                          
                        NotFound, 
                        BuildIdentMismatch, 
                        NotReady, 
                        AuthenticationRequired, 
                        ProtocolError, 
                        SignalLoss, 
                        ProtectedAncCode, 
                        InsufficientContext, 
                        InvalidChecksum 
                };
 
                static Error syserr();
 
                static Error syserr(int errnum);
 
#if defined(PROMEKI_PLATFORM_WINDOWS)
                static Error syserr(DWORD winErr);
#endif
 
                static Error syserr(const std::error_code &ec);
 
                Error(Code code = Ok) : _code(code) {}
 
                ~Error() {}
 
                bool operator==(const Error &other) const { return _code == other._code; }
                bool operator!=(const Error &other) const { return _code != other._code; }
                bool operator<(const Error &other) const { return _code < other._code; }
                bool operator<=(const Error &other) const { return _code <= other._code; }
                bool operator>(const Error &other) const { return _code > other._code; }
                bool operator>=(const Error &other) const { return _code >= other._code; }
 
                Code code() const { return _code; }
 
                bool isOk() const { return _code == 0; }
 
                bool isError() const { return _code != 0; }
 
                const String &name() const;
 
                const String &desc() const;
 
                const String &systemErrorName() const;
 
                int systemError() const;
 
        private:
                Code _code;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_CORE