Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	include/dynamic-graph/exception-abstract.h	Lines:	7	7	100.0 %
Date:	2023-03-15 12:04:10	Branches:	5	6	83.3 %


// -*- mode: c++ -*-
// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
// JRL, CNRS/AIST.
//

#ifndef DYNAMIC_GRAPH_EXCEPTION_ABSTRACT_H
#define DYNAMIC_GRAPH_EXCEPTION_ABSTRACT_H
#include <dynamic-graph/dynamic-graph-api.h>

#include <dynamic-graph/fwd.hh>
#include <string>

// Uncomment this macros to have lines parameter on the throw display
// #define DYNAMIC-GRAPH_EXCEPTION_PASSING_PARAM

#define DG_RETHROW \
  (const ::dynamicgraph::ExceptionAbstract &err) { throw err; }

#ifdef DYNAMICGRAPH_EXCEPTION_PASSING_PARAM
#define DG_THROW                                                         \
  throw ::dynamicgraph::ExceptionAbstract::Param(__LINE__, __FUNCTION__, \
                                                 __FILE__) +
#else
#define DG_THROW throw
#endif  // DYNAMICGRAPH_EXCEPTION_PASSING_PARAM

namespace dynamicgraph {
/// \ingroup error
///
/// \brief Abstract root class for all dynamic-graph exceptions.
class DYNAMIC_GRAPH_DLLAPI ExceptionAbstract : public std::exception {
 public:
  /// \ingroup error
  ///
  /// \brief Class owned by exceptions to store error locations.
  class Param {
   public:
    static const int BUFFER_SIZE = 80;

    Param(const int &_line, const char *_function, const char *_file);
    Param()
        : functionPTR(),
          function(),
          line(),
          filePTR(),
          file(),
          pointersSet(false),
          set(false) {}
    Param &initCopy(const Param &p);

    const char *functionPTR;
    char function[BUFFER_SIZE];
    int line;
    const char *filePTR;
    char file[BUFFER_SIZE];
    bool pointersSet;
    bool set;
  };

  /// \brief Categories error code.
  ///
  /// Each value matches categories used by a subclass of
  /// ExceptionAbstract.
  ///
  /// This is the programmer responsibility to make sure there is
  /// enough room between two categories error code.
  enum ExceptionEnum {
    ABSTRACT = 0,
    SIGNAL = 100,
    FACTORY = 200,
    TRACES = 300,
    TOOLS = 700
  };

  static const std::string EXCEPTION_NAME;

  explicit ExceptionAbstract(const int &code, const std::string &msg = "");
  virtual ~ExceptionAbstract() throw() {}

  virtual const std::string &getExceptionName() const { return EXCEPTION_NAME; }

  /// \brief Access to the error code.
  int getCode() const;

  /// \brief Reference access to the error message (can be empty).
  const std::string &getStringMessage() const;

  /// \brief Access to the pointer on the array of \e char related
  /// to the error string.
  ///
  /// Cannot be \e NULL.
  const char *getMessage() const;

  virtual const char *what() const throw() {
    return getStringMessage().c_str();
  }

  /// \brief Print the error structure.
  DYNAMIC_GRAPH_DLLAPI friend std::ostream &operator<<(
      std::ostream &os, const ExceptionAbstract &err);

 protected:
  /// \brief Error code.
  /// \sa ErrorCodeEnum
  int code;

  /// \brief Error message (can be empty).
  std::string message;

#ifdef DYNAMICGRAPH_EXCEPTION_PASSING_PARAM
  /// \brief Optional mutable attribute to store exception location.
  ///
  /// Only present if DYNAMICGRAPH_EXCEPTION_PASSING_PARAM
  /// preprocessor symbol exists.
  mutable Param p;

  template <class Exc>
  friend const Exc &operator+(const ExceptionAbstract::Param &p, const Exc &e) {
    e.p.initCopy(p);
    return e;
  }

  template <class Exc>
  friend Exc &operator+(const ExceptionAbstract::Param &p, Exc &e) {
    e.p.initCopy(p);
    return e;
  }

#endif  // DYNAMICGRAPH_EXCEPTION_PASSING_PARAM

 private:
  /// \brief Forbid the empty constructor (private).
  ExceptionAbstract();
};
}  // end of namespace dynamicgraph

#endif  //! DYNAMIC_GRAPH_EXCEPTION_ABSTRACT_H


Generated by: GCOVR (Version 4.2)

Line	Branch	Exec	Source
1			// -- mode: c++ --
2			// Copyright 2010, François Bleibel, Thomas Moulard, Olivier Stasse,
3			// JRL, CNRS/AIST.
4			//
5
6			#ifndef DYNAMIC_GRAPH_EXCEPTION_ABSTRACT_H
7			#define DYNAMIC_GRAPH_EXCEPTION_ABSTRACT_H
8			#include <dynamic-graph/dynamic-graph-api.h>
9
10			#include <dynamic-graph/fwd.hh>
11			#include <string>
12
13			// Uncomment this macros to have lines parameter on the throw display
14			// #define DYNAMIC-GRAPH_EXCEPTION_PASSING_PARAM
15
16			#define DG_RETHROW \
17			(const ::dynamicgraph::ExceptionAbstract &err) { throw err; }
18
19			#ifdef DYNAMICGRAPH_EXCEPTION_PASSING_PARAM
20			#define DG_THROW \
21			throw ::dynamicgraph::ExceptionAbstract::Param(__LINE__, __FUNCTION__, \
22			__FILE__) +
23			#else
24			#define DG_THROW throw
25			#endif // DYNAMICGRAPH_EXCEPTION_PASSING_PARAM
26
27			namespace dynamicgraph {
28			/// \ingroup error
29			///
30			/// \brief Abstract root class for all dynamic-graph exceptions.
31			class DYNAMIC_GRAPH_DLLAPI ExceptionAbstract : public std::exception {
32			public:
33			/// \ingroup error
34			///
35			/// \brief Class owned by exceptions to store error locations.
36			class Param {
37			public:
38			static const int BUFFER_SIZE = 80;
39
40			Param(const int &_line, const char _function, const char _file);
41		1	Param()
42		1	: functionPTR(),
43			function(),
44			line(),
45			filePTR(),
46			file(),
47			pointersSet(false),
48	✓✓✓✓	161	set(false) {}
49			Param &initCopy(const Param &p);
50
51			const char *functionPTR;
52			char function[BUFFER_SIZE];
53			int line;
54			const char *filePTR;
55			char file[BUFFER_SIZE];
56			bool pointersSet;
57			bool set;
58			};
59
60			/// \brief Categories error code.
61			///
62			/// Each value matches categories used by a subclass of
63			/// ExceptionAbstract.
64			///
65			/// This is the programmer responsibility to make sure there is
66			/// enough room between two categories error code.
67			enum ExceptionEnum {
68			ABSTRACT = 0,
69			SIGNAL = 100,
70			FACTORY = 200,
71			TRACES = 300,
72			TOOLS = 700
73			};
74
75			static const std::string EXCEPTION_NAME;
76
77			explicit ExceptionAbstract(const int &code, const std::string &msg = "");
78		128	virtual ~ExceptionAbstract() throw() {}
79
80		2	virtual const std::string &getExceptionName() const { return EXCEPTION_NAME; }
81
82			/// \brief Access to the error code.
83			int getCode() const;
84
85			/// \brief Reference access to the error message (can be empty).
86			const std::string &getStringMessage() const;
87
88			/// \brief Access to the pointer on the array of \e char related
89			/// to the error string.
90			///
91			/// Cannot be \e NULL.
92			const char *getMessage() const;
93
94		1	virtual const char *what() const throw() {
95	✓✗	1	return getStringMessage().c_str();
96			}
97
98			/// \brief Print the error structure.
99			DYNAMIC_GRAPH_DLLAPI friend std::ostream &operator<<(
100			std::ostream &os, const ExceptionAbstract &err);
101
102			protected:
103			/// \brief Error code.
104			/// \sa ErrorCodeEnum
105			int code;
106
107			/// \brief Error message (can be empty).
108			std::string message;
109
110			#ifdef DYNAMICGRAPH_EXCEPTION_PASSING_PARAM
111			/// \brief Optional mutable attribute to store exception location.
112			///
113			/// Only present if DYNAMICGRAPH_EXCEPTION_PASSING_PARAM
114			/// preprocessor symbol exists.
115			mutable Param p;
116
117			template <class Exc>
118			friend const Exc &operator+(const ExceptionAbstract::Param &p, const Exc &e) {
119			e.p.initCopy(p);
120			return e;
121			}
122
123			template <class Exc>
124			friend Exc &operator+(const ExceptionAbstract::Param &p, Exc &e) {
125			e.p.initCopy(p);
126			return e;
127			}
128
129			#endif // DYNAMICGRAPH_EXCEPTION_PASSING_PARAM
130
131			private:
132			/// \brief Forbid the empty constructor (private).
133			ExceptionAbstract();
134			};
135			} // end of namespace dynamicgraph
136
137			#endif //! DYNAMIC_GRAPH_EXCEPTION_ABSTRACT_H