libCZI_exceptions.h

// SPDX-FileCopyrightText: 2017-2022 Carl Zeiss Microscopy GmbH
//
// SPDX-License-Identifier: LGPL-3.0-or-later
 
#pragma once
 
#include <exception>
#include <stdexcept>
#include <cstdint>
 
namespace libCZI
{
    class LibCZIException : public std::runtime_error
    {
    public:
        explicit LibCZIException(const char* szErrMsg)
            : std::runtime_error(szErrMsg)
        {}
    };
 
    class LibCZIAccessorException : public LibCZIException
    {
    public:
        enum class ErrorType
        {
            CouldntDeterminePixelType,  
            Unspecified                 
        };
    private:
        ErrorType errorType;
    public:
        LibCZIAccessorException(const char* szErrMsg, ErrorType errorType)
            : LibCZIException(szErrMsg), errorType(errorType)
        {}
 
        ErrorType GetErrorType() const { return this->errorType; }
    };
 
    class LibCZIStringParseException : public LibCZIException
    {
    public:
        enum class ErrorType
        {
            InvalidSyntax,      
            DuplicateDimension, 
            FromGreaterThanTo,  
            Unspecified         
        };
    private:
        ErrorType errorType;
        int numberOfCharsParsedOk;
    public:
 
        LibCZIStringParseException(const char* szErrMsg, int numberOfCharsParsedOk, ErrorType errorType)
            : LibCZIException(szErrMsg), errorType(errorType), numberOfCharsParsedOk(numberOfCharsParsedOk)
        {}
 
        ErrorType GetErrorType() const { return this->errorType; }
 
        int GetNumberOfCharsParsedOk() const { return this->numberOfCharsParsedOk; }
    };
 
 
    class LibCZIIOException : public LibCZIException, public std::nested_exception
    {
    private:
        std::uint64_t offset;
        std::uint64_t size;
    public:
        LibCZIIOException(const char* szErrMsg, std::uint64_t offset, std::uint64_t size)
            : LibCZIException(szErrMsg), offset(offset), size(size) {}
 
        std::uint64_t GetOffset() const { return this->offset; }
 
        std::uint64_t GetSize() const { return this->size; }
    };
 
 
    struct LibCZICZIParseException : public LibCZIException
    {
        enum class ErrorCode
        {
            NotEnoughData,                      
            CorruptedData,                      
            NonConformingSubBlockDimensionEntry,
            InternalError                       
        };
 
        LibCZICZIParseException(const char* szErrMsg, ErrorCode code)
            : LibCZIException(szErrMsg), errorCode(code)
        {
        }
 
        ErrorCode GetErrorCode() const { return this->errorCode; }
    private:
        ErrorCode errorCode;
    };
 
    struct LibCZISegmentNotPresent : public LibCZIException
    {
        explicit LibCZISegmentNotPresent(const char* szErrMsg)
            : LibCZIException(szErrMsg)
        {
        }
    };
 
    struct LibCZIInvalidPlaneCoordinateException : public LibCZIException
    {
        enum class ErrorCode
        {
            SurplusDimension,    
            MissingDimension,    
            InvalidDimension,    
            CoordinateOutOfRange 
        };
 
        LibCZIInvalidPlaneCoordinateException(const char* szErrMsg, ErrorCode code)
            : LibCZIException(szErrMsg), errorCode(code)
        {
        }
    private:
        ErrorCode errorCode;
    };
 
    class LibCZIWriteException : public LibCZIException
    {
    public:
        enum class ErrorType
        {
            AddCoordinateContainsUnexpectedDimension,       
            AddCoordinateAlreadyExisting,                   
            AddAttachmentAlreadyExisting,                   
            NotEnoughDataWritten,                           
            GetDataCallError,                               
            SubBlockCoordinateOutOfBounds,                  
            SubBlockCoordinateInsufficient                  
        };
 
        LibCZIWriteException(const char* szErrMsg, ErrorType code)
            : LibCZIException(szErrMsg), errorType(code)
        {
        }
 
        ErrorType GetErrorType() const { return this->errorType; }
 
    private:
        ErrorType errorType;
    };
 
    class LibCZIReaderWriteException : public LibCZIException
    {
    public:
        enum class ErrorType
        {
            InvalidSubBlkId,                
            InvalidAttachmentId,            
            AddCoordinateAlreadyExisting,   
            AddAttachmentAlreadyExisting    
        };
 
        LibCZIReaderWriteException(const char* szErrMsg, ErrorType code)
            : LibCZIException(szErrMsg), errorType(code)
        {
        }
 
        ErrorType GetErrorType() const { return this->errorType; }
 
    private:
        ErrorType errorType;
    };
 
    class LibCZIMetadataBuilderException : public LibCZIException
    {
    public:
        enum class ErrorType
        {
            InvalidPath,            
            CannotSetValueToNode    
        };
 
        LibCZIMetadataBuilderException(const char* szErrMsg, ErrorType code)
            : LibCZIException(szErrMsg), errorType(code)
        {
        }
 
        ErrorType GetErrorType() const { return this->errorType; }
 
    private:
        ErrorType errorType;
    };
 
    class LibCZIMetadataException : public LibCZIException
    {
    public:
        enum class ErrorType
        {
            InvalidPath,            
        };
 
        LibCZIMetadataException(const char* szErrMsg, ErrorType code)
            : LibCZIException(szErrMsg), errorType(code)
        {
        }
 
        ErrorType GetErrorType() const { return this->errorType; }
 
    private:
        ErrorType errorType;
    };
 
    class LibCZIXmlParseException : public LibCZIException
    {
    public:
        explicit LibCZIXmlParseException(const char* szErrMsg)
            : LibCZIException(szErrMsg)
        {
        }
    };
}