Exiv2
error.hpp
Go to the documentation of this file.
1 // ***************************************************************** -*- C++ -*-
2 /*
3  * Copyright (C) 2004-2021 Exiv2 authors
4  * This program is part of the Exiv2 distribution.
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, 5th Floor, Boston, MA 02110-1301 USA.
19  */
28 #ifndef ERROR_HPP_
29 #define ERROR_HPP_
30 
31 // *****************************************************************************
32 #include "exiv2lib_export.h"
33 
34 // included header files
35 #include "types.hpp"
36 
37 // + standard includes
38 #include <exception>
39 #include <string>
40 
41 // *****************************************************************************
42 // namespace extensions
43 namespace Exiv2 {
44 
45 // *****************************************************************************
46 // class definitions
47 
75  class EXIV2API LogMsg {
77  LogMsg(const LogMsg&);
79  LogMsg& operator=(const LogMsg&);
80  public:
85  enum Level { debug = 0, info = 1, warn = 2, error = 3, mute = 4 };
92  typedef void (*Handler)(int, const char*);
93 
95 
96  explicit LogMsg(Level msgType);
98 
100  ~LogMsg();
102 
104 
105  std::ostringstream& os();
108 
115  static void setLevel(Level level);
121  static void setHandler(Handler handler);
123  static Level level();
125  static Handler handler();
127  static void defaultHandler(int level, const char* s);
128 
129  private:
130  // DATA
131  // The output level. Only messages with type >= level_ will be written
132  static Level level_;
133  // The log handler in use
134  static Handler handler_;
135  // The type of this log message
136  const Level msgType_;
137  // Holds the log message until it is passed to the message handler
138  std::ostringstream os_;
139 
140  }; // class LogMsg
141 
142 // Macros for simple access
144 #define EXV_DEBUG if (LogMsg::debug >= LogMsg::level() && LogMsg::handler()) LogMsg(LogMsg::debug).os()
146 #define EXV_INFO if (LogMsg::info >= LogMsg::level() && LogMsg::handler()) LogMsg(LogMsg::info).os()
148 #define EXV_WARNING if (LogMsg::warn >= LogMsg::level() && LogMsg::handler()) LogMsg(LogMsg::warn).os()
150 #define EXV_ERROR if (LogMsg::error >= LogMsg::level() && LogMsg::handler()) LogMsg(LogMsg::error).os()
151 
152 #ifdef _MSC_VER
153 // Disable MSVC warnings "non - DLL-interface classkey 'identifier' used as base
154 // for DLL-interface classkey 'identifier'"
155 # pragma warning( disable : 4275 )
156 #endif
157 
159  template<typename charT, typename T>
160  std::basic_string<charT> toBasicString(const T& arg)
161  {
162  std::basic_ostringstream<charT> os;
163  os << arg;
164  return os.str();
165  }
166 
174  class EXIV2API AnyError : public std::exception {
175  public:
176  AnyError();
177  AnyError(const AnyError& o);
178 
179  virtual ~AnyError() throw();
181  virtual int code() const throw() =0;
182  };
183 
185  inline std::ostream& operator<<(std::ostream& os, const AnyError& error)
186  {
187  return os << error.what();
188  }
189 
191  enum ErrorCode {
192  kerGeneralError = -1,
193  kerSuccess = 0,
194  kerErrorMessage,
195  kerCallFailed,
196  kerNotAnImage,
197  kerInvalidDataset,
198  kerInvalidRecord,
199  kerInvalidKey,
200  kerInvalidTag,
201  kerValueNotSet,
202  kerDataSourceOpenFailed,
203  kerFileOpenFailed,
204  kerFileContainsUnknownImageType,
205  kerMemoryContainsUnknownImageType,
206  kerUnsupportedImageType,
207  kerFailedToReadImageData,
208  kerNotAJpeg,
209  kerFailedToMapFileForReadWrite,
210  kerFileRenameFailed,
211  kerTransferFailed,
212  kerMemoryTransferFailed,
213  kerInputDataReadFailed,
214  kerImageWriteFailed,
215  kerNoImageInInputData,
216  kerInvalidIfdId,
221  kerOffsetOutOfRange,
222  kerUnsupportedDataAreaOffsetType,
223  kerInvalidCharset,
224  kerUnsupportedDateFormat,
225  kerUnsupportedTimeFormat,
226  kerWritingImageFormatUnsupported,
227  kerInvalidSettingForImage,
228  kerNotACrwImage,
229  kerFunctionNotSupported,
230  kerNoNamespaceInfoForXmpPrefix,
231  kerNoPrefixForNamespace,
232  kerTooLargeJpegSegment,
233  kerUnhandledXmpdatum,
234  kerUnhandledXmpNode,
235  kerXMPToolkitError,
236  kerDecodeLangAltPropertyFailed,
237  kerDecodeLangAltQualifierFailed,
238  kerEncodeLangAltPropertyFailed,
239  kerPropertyNameIdentificationFailed,
240  kerSchemaNamespaceNotRegistered,
241  kerNoNamespaceForPrefix,
242  kerAliasesNotSupported,
243  kerInvalidXmpText,
244  kerTooManyTiffDirectoryEntries,
245  kerMultipleTiffArrayElementTagsInDirectory,
246  kerWrongTiffArrayElementTagType,
247  kerInvalidKeyXmpValue,
248  kerInvalidIccProfile,
249  kerInvalidXMP,
250  kerTiffDirectoryTooLarge,
251  kerInvalidTypeValue,
252  kerInvalidLangAltValue,
253  kerInvalidMalloc,
254  kerCorruptedMetadata,
255  kerArithmeticOverflow,
256  kerMallocFailed,
257  };
258 
263  template<typename charT>
264  class EXIV2API BasicError : public AnyError {
265  public:
267 
268  explicit inline BasicError(ErrorCode code);
270 
272  template<typename A>
273  inline BasicError(ErrorCode code, const A& arg1);
274 
276  template<typename A, typename B>
277  inline BasicError(ErrorCode code, const A& arg1, const B& arg2);
278 
280  template<typename A, typename B, typename C>
281  inline BasicError(ErrorCode code, const A& arg1, const B& arg2, const C& arg3);
282 
284  virtual inline ~BasicError() throw();
286 
288 
289  virtual inline int code() const throw();
294  virtual inline const char* what() const throw();
295 #ifdef EXV_UNICODE_PATH
300  virtual inline const wchar_t* wwhat() const throw();
301 #endif
303 
304  private:
306 
307  void setMsg();
310 
311  // DATA
312  ErrorCode code_;
313  int count_;
314  std::basic_string<charT> arg1_;
315  std::basic_string<charT> arg2_;
316  std::basic_string<charT> arg3_;
317  std::string msg_;
318 #ifdef EXV_UNICODE_PATH
319  std::wstring wmsg_;
320 #endif
321  }; // class BasicError
322 
325 #ifdef EXV_UNICODE_PATH
327  typedef BasicError<wchar_t> WError;
328 #endif
329 
330 // *****************************************************************************
331 // free functions, template and inline definitions
332 
334  const char* errMsg(int code);
335 
336  template<typename charT>
338  : code_(code), count_(0)
339  {
340  setMsg();
341  }
342 
343  template<typename charT> template<typename A>
345  : code_(code), count_(1), arg1_(toBasicString<charT>(arg1))
346  {
347  setMsg();
348  }
349 
350  template<typename charT> template<typename A, typename B>
351  BasicError<charT>::BasicError(ErrorCode code, const A& arg1, const B& arg2)
352  : code_(code), count_(2),
353  arg1_(toBasicString<charT>(arg1)),
354  arg2_(toBasicString<charT>(arg2))
355  {
356  setMsg();
357  }
358 
359  template<typename charT> template<typename A, typename B, typename C>
360  BasicError<charT>::BasicError(ErrorCode code, const A& arg1, const B& arg2, const C& arg3)
361  : code_(code), count_(3),
362  arg1_(toBasicString<charT>(arg1)),
363  arg2_(toBasicString<charT>(arg2)),
364  arg3_(toBasicString<charT>(arg3))
365  {
366  setMsg();
367  }
368 
369  template<typename charT>
371  {
372  }
373 
374  template<typename charT>
375  int BasicError<charT>::code() const throw()
376  {
377  return code_;
378  }
379 
380  template<typename charT>
381  const char* BasicError<charT>::what() const throw()
382  {
383  return msg_.c_str();
384  }
385 
386 #ifdef EXV_UNICODE_PATH
387  template<typename charT>
388  const wchar_t* BasicError<charT>::wwhat() const throw()
389  {
390  return wmsg_.c_str();
391  }
392 #endif
393 
394 #ifdef _MSC_VER
395 # pragma warning( default : 4275 )
396 #endif
397 
398 } // namespace Exiv2
399 #endif // #ifndef ERROR_HPP_
Error class interface. Allows the definition and use of a hierarchy of error classes which can all be...
Definition: error.hpp:174
virtual int code() const =0
Return the error code.
Simple error class used for exceptions. An output operator is provided to print errors to a stream.
Definition: error.hpp:264
BasicError(ErrorCode code)
Constructor taking only an error code.
Definition: error.hpp:337
virtual ~BasicError()
Virtual destructor. (Needed because of throw())
Definition: error.hpp:370
virtual int code() const
Return the error code.
Definition: error.hpp:375
virtual const char * what() const
Return the error message as a C-string. The pointer returned by what() is valid only as long as the B...
Definition: error.hpp:381
Class for a log message, used by the library. Applications can set the log level and provide a custom...
Definition: error.hpp:75
Level
Defined log levels. To suppress all log messages, either set the log level to mute or set the log mes...
Definition: error.hpp:85
Provides classes and functions to encode and decode Exif and Iptc data. The libexiv2 API consists of ...
Definition: asfvideo.hpp:36
ErrorCode
Complete list of all Exiv2 error codes.
Definition: error.hpp:191
@ kerValueTooLarge
Entry::setValue: Value too large.
Definition: error.hpp:218
@ kerDataAreaValueTooLarge
Entry::setDataArea: Value too large.
Definition: error.hpp:220
std::basic_string< charT > toBasicString(const T &arg)
Generalised toString function.
Definition: error.hpp:160
const char * errMsg(int code)
Return the error message for the error with code code.
Definition: error.cpp:298
BasicError< char > Error
Error class used for exceptions (std::string based)
Definition: error.hpp:324