exceptions.h

// SPDX-FileCopyrightText: 2023 Carl Zeiss Microscopy GmbH
//
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <stdexcept>
#include <string>
 
#include "types.h"
 
namespace imgdoc2
{
    class imgdoc2_exception : public std::runtime_error
    {
    public:
        explicit imgdoc2_exception(const char* error_message)
            : std::runtime_error(error_message)
        {}
    };
 
    class database_exception : public imgdoc2_exception
    {
    private:
        int sqlite_errorcode_;
        bool sqlite_errorcode_valid_;
    public:
        database_exception() = delete;
 
        explicit database_exception(const char* error_message)
            : imgdoc2_exception(error_message), sqlite_errorcode_(-1), sqlite_errorcode_valid_(false)
        {}
 
        explicit database_exception(const char* error_message, int sqlite_error_code)
            : imgdoc2_exception(error_message), sqlite_errorcode_(sqlite_error_code), sqlite_errorcode_valid_(true)
        {}
 
        bool GetIsSqliteErrorCodeValid() const { return this->sqlite_errorcode_valid_; }
 
        int GetSqliteErrorCode() const { return this->sqlite_errorcode_; }
 
        std::string GetSqliteErrorMessage() const;
    };
 
    class invalid_operation_exception : public imgdoc2_exception
    {
    public:
        explicit invalid_operation_exception(const char* error_message)
            : imgdoc2_exception(error_message)
        {}
    };
 
    class discovery_exception : public imgdoc2_exception
    {
    public:
        explicit discovery_exception(const char* error_message)
            : imgdoc2_exception(error_message)
        {}
 
        explicit discovery_exception(const std::string& error_message)
            : discovery_exception(error_message.c_str())
        {}
    };
 
    class invalid_argument_exception : public imgdoc2_exception
    {
    public:
        explicit invalid_argument_exception(const char* error_message)
            : imgdoc2_exception(error_message)
        {}
    };
 
    class non_existing_tile_exception : public imgdoc2_exception
    {
    private:
        bool index_valid_{ false };
        imgdoc2::dbIndex index_{ 0 };
    public:
        non_existing_tile_exception() = delete;
 
        explicit non_existing_tile_exception(const std::string& error_message, imgdoc2::dbIndex index)
            : non_existing_tile_exception(error_message.c_str(), index)
        {}
 
        explicit non_existing_tile_exception(const char* error_message, imgdoc2::dbIndex index)
            : imgdoc2_exception(error_message),
            index_valid_(true),
            index_(index)
        {}
 
        [[nodiscard]] bool IsIndexValid() const { return this->index_valid_; }
 
        [[nodiscard]] imgdoc2::dbIndex GetIndex() const { return this->index_; }
    };
 
    class invalid_path_exception : public imgdoc2_exception
    {
    public:
        invalid_path_exception() = delete;
 
        explicit invalid_path_exception(const std::string& error_message)
            : imgdoc2_exception(error_message.c_str())
        {}
 
        explicit invalid_path_exception(const char* error_message)
            : imgdoc2_exception(error_message)
        {}
    };
 
    class non_existing_item_exception : public imgdoc2_exception
    {
    private:
        bool index_valid_{ false };
        imgdoc2::dbIndex index_{ 0 };
    public:
        non_existing_item_exception() = delete;
 
        explicit non_existing_item_exception(const std::string& error_message, imgdoc2::dbIndex index)
            : non_existing_item_exception(error_message.c_str(), index)
        {}
 
        explicit non_existing_item_exception(const char* error_message, imgdoc2::dbIndex index)
            : imgdoc2_exception(error_message),
            index_valid_(true),
            index_(index)
        {}
 
        [[nodiscard]] bool IsIndexValid() const { return this->index_valid_; }
 
        [[nodiscard]] imgdoc2::dbIndex GetIndex() const { return this->index_; }
    };
 
    class internal_error_exception : public imgdoc2_exception
    {
    public:
        internal_error_exception() = delete;
 
        explicit internal_error_exception(const std::string& error_message)
            : imgdoc2_exception(error_message.c_str())
        {}
    };
}