error.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: GPL-2.0-or-later
 
#ifndef ERROR_HPP_
#define ERROR_HPP_
 
// *****************************************************************************
#include "exiv2lib_export.h"
 
#include "config.h"
 
#include <exception>  // for exception
#include <sstream>    // for operator<<, ostream, ostringstream, bas...
#include <string>     // for basic_string, string
 
// *****************************************************************************
// namespace extensions
namespace Exiv2 {
// *****************************************************************************
// class definitions
 
class EXIV2API LogMsg {
 public:
  LogMsg(const LogMsg&) = delete;
  LogMsg& operator=(const LogMsg&) = delete;
  enum Level {
    debug = 0,
    info = 1,
    warn = 2,
    error = 3,
    mute = 4,
  };
  using Handler = void (*)(int, const char*);
 
 
 
  explicit LogMsg(Level msgType);
 
  ~LogMsg();
 
 
 
  std::ostringstream& os();
 
  static void setLevel(Level level);
  static void setHandler(Handler handler);
  static Level level();
  static Handler handler();
  static void defaultHandler(int level, const char* s);
 
 private:
  // DATA
  // The output level. Only messages with type >= level_ will be written
  static Level level_;
  // The log handler in use
  static Handler handler_;
  // The type of this log message
  Level msgType_;
  // Holds the log message until it is passed to the message handler
  std::ostringstream os_;
 
};  // class LogMsg
 
// Macros for simple access
#define EXV_DEBUG                                            \
  if (LogMsg::debug >= LogMsg::level() && LogMsg::handler()) \
  LogMsg(LogMsg::debug).os()
#define EXV_INFO                                            \
  if (LogMsg::info >= LogMsg::level() && LogMsg::handler()) \
  LogMsg(LogMsg::info).os()
#define EXV_WARNING                                         \
  if (LogMsg::warn >= LogMsg::level() && LogMsg::handler()) \
  LogMsg(LogMsg::warn).os()
#define EXV_ERROR                                            \
  if (LogMsg::error >= LogMsg::level() && LogMsg::handler()) \
  LogMsg(LogMsg::error).os()
 
#ifdef _MSC_VER
// Disable MSVC warnings "non - DLL-interface classkey 'identifier' used as base
// for DLL-interface classkey 'identifier'"
#pragma warning(disable : 4275)
#endif
 
template <typename charT, typename T>
std::basic_string<charT> toBasicString(const T& arg) {
  std::basic_ostringstream<charT> os;
  os << arg;
  return os.str();
}
 
enum class ErrorCode {
  kerSuccess = 0,
  kerGeneralError,
  kerErrorMessage,
  kerCallFailed,
  kerNotAnImage,
  kerInvalidDataset,
  kerInvalidRecord,
  kerInvalidKey,
  kerInvalidTag,
  kerValueNotSet,
  kerDataSourceOpenFailed,
  kerFileOpenFailed,
  kerFileContainsUnknownImageType,
  kerMemoryContainsUnknownImageType,
  kerUnsupportedImageType,
  kerFailedToReadImageData,
  kerNotAJpeg,
  kerFailedToMapFileForReadWrite,
  kerFileRenameFailed,
  kerTransferFailed,
  kerMemoryTransferFailed,
  kerInputDataReadFailed,
  kerImageWriteFailed,
  kerNoImageInInputData,
  kerInvalidIfdId,
  kerValueTooLarge,
  kerDataAreaValueTooLarge,
  kerOffsetOutOfRange,
  kerUnsupportedDataAreaOffsetType,
  kerInvalidCharset,
  kerUnsupportedDateFormat,
  kerUnsupportedTimeFormat,
  kerWritingImageFormatUnsupported,
  kerInvalidSettingForImage,
  kerNotACrwImage,
  kerFunctionNotSupported,
  kerNoNamespaceInfoForXmpPrefix,
  kerNoPrefixForNamespace,
  kerTooLargeJpegSegment,
  kerUnhandledXmpdatum,
  kerUnhandledXmpNode,
  kerXMPToolkitError,
  kerDecodeLangAltPropertyFailed,
  kerDecodeLangAltQualifierFailed,
  kerEncodeLangAltPropertyFailed,
  kerPropertyNameIdentificationFailed,
  kerSchemaNamespaceNotRegistered,
  kerNoNamespaceForPrefix,
  kerAliasesNotSupported,
  kerInvalidXmpText,
  kerTooManyTiffDirectoryEntries,
  kerMultipleTiffArrayElementTagsInDirectory,
  kerWrongTiffArrayElementTagType,
  kerInvalidKeyXmpValue,
  kerInvalidIccProfile,
  kerInvalidXMP,
  kerTiffDirectoryTooLarge,
  kerInvalidTypeValue,
  kerInvalidLangAltValue,
  kerInvalidMalloc,
  kerCorruptedMetadata,
  kerArithmeticOverflow,
  kerMallocFailed,
  kerInvalidIconvEncoding,
  kerFileAccessDisabled,
 
  kerErrorCount,
};
 
class EXIV2API Error : public std::exception {
 public:
 
 
  explicit Error(ErrorCode code);
 
  template <typename A>
  Error(ErrorCode code, const A& arg1) : code_(code), arg1_(toBasicString<char>(arg1)) {
    setMsg(1);
  }
 
  template <typename A, typename B>
  Error(ErrorCode code, const A& arg1, const B& arg2) :
      code_(code), arg1_(toBasicString<char>(arg1)), arg2_(toBasicString<char>(arg2)) {
    setMsg(2);
  }
 
  template <typename A, typename B, typename C>
  Error(ErrorCode code, const A& arg1, const B& arg2, const C& arg3) :
      code_(code),
      arg1_(toBasicString<char>(arg1)),
      arg2_(toBasicString<char>(arg2)),
      arg3_(toBasicString<char>(arg3)) {
    setMsg(3);
  }
 
  ~Error() noexcept override = default;
 
 
  [[nodiscard]] ErrorCode code() const noexcept;
  [[nodiscard]] const char* what() const noexcept override;
 
 private:
 
 
  void setMsg(int count);
 
  // DATA
  ErrorCode code_;    
  std::string arg1_;  
  std::string arg2_;  
  std::string arg3_;  
  std::string msg_;   
};
 
inline std::ostream& operator<<(std::ostream& os, const Error& error) {
  return os << error.what();
}
 
#ifdef _MSC_VER
#pragma warning(default : 4275)
#endif
 
}  // namespace Exiv2
#endif  // #ifndef ERROR_HPP_