exceptions.hpp

Go to the documentation of this file.

/*
 * Copyright 2025 Jinwoo Sung
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include <stdexcept>
#include <string>
 
#include "unilink/base/visibility.hpp"
 
namespace unilink {
namespace diagnostics {
 
class UNILINK_API UnilinkException : public std::runtime_error {
 public:
  explicit UnilinkException(const std::string& message, const std::string& component = "",
                            const std::string& operation = "")
      : std::runtime_error(message), component_(component), operation_(operation) {}
 
  const std::string& get_component() const noexcept { return component_; }
  const std::string& get_operation() const noexcept { return operation_; }
 
  std::string get_full_message() const {
    std::string full_msg = what();
    if (!component_.empty()) {
      full_msg = "[" + component_ + "] " + full_msg;
    }
    if (!operation_.empty()) {
      full_msg += " (operation: " + operation_ + ")";
    }
    return full_msg;
  }
 
 private:
  std::string component_;
  std::string operation_;
};
 
class UNILINK_API BuilderException : public UnilinkException {
 public:
  explicit BuilderException(const std::string& message, const std::string& builder_type = "",
                            const std::string& operation = "")
      : UnilinkException(message, "builder", operation), builder_type_(builder_type) {}
 
  const std::string& get_builder_type() const noexcept { return builder_type_; }
 
  std::string get_full_message() const {
    std::string full_msg = UnilinkException::get_full_message();
    if (!builder_type_.empty()) {
      full_msg = "[" + builder_type_ + "] " + full_msg;
    }
    return full_msg;
  }
 
 private:
  std::string builder_type_;
};
 
class UNILINK_API ValidationException : public UnilinkException {
 public:
  explicit ValidationException(const std::string& message, const std::string& parameter = "",
                               const std::string& expected = "")
      : UnilinkException(message, "validation", "validate"), parameter_(parameter), expected_(expected) {}
 
  const std::string& get_parameter() const noexcept { return parameter_; }
  const std::string& get_expected() const noexcept { return expected_; }
 
  std::string get_full_message() const {
    std::string full_msg = UnilinkException::get_full_message();
    if (!parameter_.empty()) {
      full_msg += " (parameter: " + parameter_ + ")";
    }
    if (!expected_.empty()) {
      full_msg += " (expected: " + expected_ + ")";
    }
    return full_msg;
  }
 
 private:
  std::string parameter_;
  std::string expected_;
};
 
class UNILINK_API MemoryException : public UnilinkException {
 public:
  explicit MemoryException(const std::string& message, size_t size = 0, const std::string& operation = "")
      : UnilinkException(message, "memory", operation), size_(size) {}
 
  size_t get_size() const noexcept { return size_; }
 
  std::string get_full_message() const {
    std::string full_msg = UnilinkException::get_full_message();
    if (size_ > 0) {
      full_msg += " (size: " + std::to_string(size_) + " bytes)";
    }
    return full_msg;
  }
 
 private:
  size_t size_;
};
 
class UNILINK_API ConnectionException : public UnilinkException {
 public:
  explicit ConnectionException(const std::string& message, const std::string& connection_type = "",
                               const std::string& operation = "")
      : UnilinkException(message, "connection", operation), connection_type_(connection_type) {}
 
  const std::string& get_connection_type() const noexcept { return connection_type_; }
 
  std::string get_full_message() const {
    std::string full_msg = UnilinkException::get_full_message();
    if (!connection_type_.empty()) {
      full_msg = "[" + connection_type_ + "] " + full_msg;
    }
    return full_msg;
  }
 
 private:
  std::string connection_type_;
};
 
class UNILINK_API ConfigurationException : public UnilinkException {
 public:
  explicit ConfigurationException(const std::string& message, const std::string& config_section = "",
                                  const std::string& operation = "")
      : UnilinkException(message, "configuration", operation), config_section_(config_section) {}
 
  const std::string& get_config_section() const noexcept { return config_section_; }
 
  std::string get_full_message() const {
    std::string full_msg = UnilinkException::get_full_message();
    if (!config_section_.empty()) {
      full_msg += " (section: " + config_section_ + ")";
    }
    return full_msg;
  }
 
 private:
  std::string config_section_;
};
 
}  // namespace diagnostics
 
// Compatibility alias while transitioning from legacy `common` namespace.
namespace common {
using UnilinkException = diagnostics::UnilinkException;
using BuilderException = diagnostics::BuilderException;
using ValidationException = diagnostics::ValidationException;
using MemoryException = diagnostics::MemoryException;
using ConnectionException = diagnostics::ConnectionException;
using ConfigurationException = diagnostics::ConfigurationException;
}  // namespace common
}  // namespace unilink