libCZI_exceptions.h

//******************************************************************************
// 
// libCZI is a reader for the CZI fileformat written in C++
// Copyright (C) 2017  Zeiss Microscopy GmbH
// 
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.
// 
// To obtain a commercial version please contact Zeiss Microscopy GmbH.
// 
//******************************************************************************

#pragma once

#include <exception>
#include <stdexcept>

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,  
            InternalError   
        };

        LibCZICZIParseException(const char* szErrMsg, ErrorCode code)
            : LibCZIException(szErrMsg), errorCode(code)
        {
        }

        ErrorCode GetErrorCode() const { return this->errorCode; }
    private:
        ErrorCode errorCode;
    };

    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 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:
        LibCZIXmlParseException(const char* szErrMsg)
            : LibCZIException(szErrMsg)
        {
        }
    };

    class LibCZIQueryParseException : public LibCZIException
    {
    public:
        enum class ErrorType
        {
            SyntaxError,
            UnbalancedParenthesis,
            IllformedExpression,
            InvalidNumberFormat
        };
    private:
        ErrorType errorType;
        int parseErrorAfterCharNo;
    public:
        LibCZIQueryParseException(const char* szErrMsg, ErrorType errorType)
            : LibCZIQueryParseException(szErrMsg, errorType, -1)
        {}

        explicit LibCZIQueryParseException(const char* szErrMsg, ErrorType errorType, int indexOfParseError)
            : LibCZIException(szErrMsg),
            errorType(errorType),
            parseErrorAfterCharNo(indexOfParseError)
        {}

        ErrorType GetErrorType() const { return this->errorType; }

        int GetPositionAfterWhichParserErrorOccurred() const { return this->parseErrorAfterCharNo; }
    };

    class LibCZIQueryExecutionException : public LibCZIException
    {
    public:
        enum class ErrorType
        {
            NonExistentDimension,
            InternalError
        };
    private:
        ErrorType errorType;
    public:
        explicit LibCZIQueryExecutionException(const char* szErrMsg, ErrorType errorType)
            : LibCZIException(szErrMsg),
            errorType(errorType)
        {}

        explicit LibCZIQueryExecutionException(const std::string& errMsg, ErrorType errorType)
            : LibCZIQueryExecutionException(errMsg.c_str(), errorType)
        {}

        ErrorType GetErrorType() const { return this->errorType; }
    };
}