LCOV - code coverage report
Current view: top level - core/meshkit - Error.hpp (source / functions) Hit Total Coverage
Test: coverage_sk.info Lines: 20 36 55.6 %
Date: 2020-07-01 15:24:36 Functions: 9 10 90.0 %
Branches: 8 34 23.5 %

           Branch data     Line data    Source code
       1                 :            : #ifndef MESHKIT_ERROR_HPP
       2                 :            : #define MESHKIT_ERROR_HPP
       3                 :            : 
       4                 :            : /** \file Error.hpp
       5                 :            :  */
       6                 :            : #include <string>
       7                 :            : #include <typeinfo>
       8                 :            : 
       9                 :            : #include "meshkit/iGeom.hpp"
      10                 :            : #include "meshkit/iMesh.hpp"
      11                 :            : #include "meshkit/iRel.hpp"
      12                 :            : 
      13                 :            : namespace MeshKit {
      14                 :            : 
      15                 :            : #define ECERRCHK(err, descr)                                               \
      16                 :            :   do {                                                                     \
      17                 :            :     if (MK_SUCCESS != err) {                                  \
      18                 :            :       Error tmp_err(0, "%s, line %d: %s", __FILE__, __LINE__, descr); \
      19                 :            :       throw tmp_err;                           \
      20                 :            :     }                                                                      \
      21                 :            :   } while(false)
      22                 :            : 
      23                 :            :     
      24                 :            : #define MKERRCHK(err, descr)                                               \
      25                 :            :   do {                                                                     \
      26                 :            :     if (MK_SUCCESS != err.error_code()) {                                  \
      27                 :            :       Error tmp_err(0, "%s, line %d: %s: %s", __FILE__, __LINE__, err.what(), descr); \
      28                 :            :       err.set_string(tmp_err.what()); throw err;                           \
      29                 :            :     }                                                                      \
      30                 :            :   } while(false)
      31                 :            : 
      32                 :            :     
      33                 :            : #define MBERRCHK(err, mbimpl)                                           \
      34                 :            :   do {                                                                     \
      35                 :            :     if (moab::MB_SUCCESS != err) {                                         \
      36                 :            :       std::string mb_err;                                                 \
      37                 :            :       mbimpl->get_last_error(mb_err); \
      38                 :            :       throw Error(err, "%s, line %d: %s", __FILE__, __LINE__, mb_err.c_str()); \
      39                 :            :     }                                                                      \
      40                 :            :   } while(false)
      41                 :            : 
      42                 :            : #define IBERRCHK(err, x) IBERRCHK_((err), (x), __FILE__, __LINE__)
      43                 :            : 
      44                 :            : inline void IBERRCHK_(int err, const char *descr);
      45                 :            : inline void IBERRCHK_(int err, iMesh &mesh);
      46                 :            : inline void IBERRCHK_(int err, iGeom &geom);
      47                 :            : inline void IBERRCHK_(int err, iRel &rel);
      48                 :            : 
      49                 :            :     enum ErrorCode {
      50                 :            :         MK_SUCCESS = 0, 
      51                 :            :         MK_FAILURE,
      52                 :            :         MK_NOT_FOUND,
      53                 :            :         MK_MULTIPLE_FOUND,
      54                 :            :         MK_MESHOP_NOT_FOUND,
      55                 :            :         MK_NOT_IMPLEMENTED,
      56                 :            :         MK_WRONG_DIMENSION,
      57                 :            :         MK_ALREADY_DEFINED,
      58                 :            :         MK_BAD_INPUT,
      59                 :            :         MK_BAD_GEOMETRIC_EVALUATION,
      60                 :            :         MK_INCOMPLETE_MESH_SPECIFICATION
      61                 :            :     };
      62                 :            :     
      63                 :            : /** \class Error Error.hpp "meshkit/Error.hpp"
      64                 :            :  * \brief The Error object returned from or thrown by many MeshKit functions    
      65                 :            :  *
      66                 :            :  * This class is derived from std::exception.
      67                 :            :  */
      68         [ +  - ]:       1810 : class Error : public std::exception
      69                 :            : {
      70                 :            : public:
      71                 :            : 
      72                 :            :     /** \brief Constructor
      73                 :            :      * \param err %Error code to which this Error should be initialized
      74                 :            :      */
      75                 :            :   Error(int err);
      76                 :            :   
      77                 :            :   Error(int err, const char* format, ...)
      78                 :            : #ifdef __GNUC__
      79                 :            :     __attribute__((format(printf,3,4)))
      80                 :            : #endif
      81                 :            :     ;
      82                 :            : 
      83                 :            :   Error() {};
      84                 :            : 
      85                 :            :     /** \brief Destructor
      86                 :            :      *
      87                 :            :      * Must have throw() to match std::exception.
      88                 :            :      */
      89                 :            :   virtual ~Error() throw();
      90                 :            : 
      91                 :            :     //! Return the error code
      92                 :            :   virtual ErrorCode error_code() const;
      93                 :            :   
      94                 :            :     /** \brief Standard function for retrieving a description of this Error
      95                 :            :      *
      96                 :            :      * Must have throw() to match std::exception.
      97                 :            :      * \return Text description of error.
      98                 :            :      */
      99                 :            :   virtual const char *what() const throw();
     100                 :            : 
     101                 :            :     /** \brief Set the error string
     102                 :            :      * \param str String to set
     103                 :            :      */
     104                 :            :   virtual void set_string(const char *str);
     105                 :            :   
     106                 :            :     /** \brief Return an error string for the specified code
     107                 :            :      * \param err Error code whose string is being queried
     108                 :            :      * \return String corresponding to the error code
     109                 :            :      */
     110                 :            :   static const char* error_str(ErrorCode err);
     111                 :            : 
     112                 :            : private:
     113                 :            :     //! Locally-stored error code, from ErrorCode enumeration
     114                 :            :   ErrorCode errorCode;
     115                 :            : 
     116                 :            :     //! String-based description of error
     117                 :            :   std::string errDescription;
     118                 :            : };
     119                 :            : 
     120         [ +  - ]:         15 : inline Error::Error(int err) : errorCode((ErrorCode)err) {}
     121                 :            : 
     122         [ -  + ]:       7240 : inline Error::~Error() throw () {}
     123                 :            : 
     124                 :         15 : inline ErrorCode Error::error_code() const
     125                 :            : {
     126                 :         15 :   return errorCode;
     127                 :            : }
     128                 :            : 
     129                 :          5 : inline const char *Error::what() const throw ()
     130                 :            : {
     131                 :          5 :   return errDescription.c_str();
     132                 :            : }
     133                 :            :       
     134                 :          0 : inline const char* Error::error_str(ErrorCode err)
     135                 :            : {
     136   [ #  #  #  #  :          0 :   switch (err) {
          #  #  #  #  #  
                #  #  # ]
     137                 :          0 :     case MK_SUCCESS: return "Success";
     138                 :          0 :     case MK_FAILURE: return "Failure";
     139                 :          0 :     case MK_NOT_FOUND: return "Not found";
     140                 :          0 :     case MK_MULTIPLE_FOUND: return "Multiple entities found";
     141                 :          0 :     case MK_MESHOP_NOT_FOUND: return "MeshOp not found";
     142                 :          0 :     case MK_NOT_IMPLEMENTED: return "Not implemented";
     143                 :          0 :     case MK_WRONG_DIMENSION: return "Wrong dimension";
     144                 :          0 :     case MK_ALREADY_DEFINED: return "Already defined";
     145                 :          0 :     case MK_BAD_INPUT: return "Bad input";
     146                 :          0 :     case MK_BAD_GEOMETRIC_EVALUATION: return "Bad geometric evaluation";
     147                 :          0 :     case MK_INCOMPLETE_MESH_SPECIFICATION: return "Incomplete mesh specification";
     148                 :          0 :     default : return "Unknown Error";
     149                 :            :   };
     150                 :            : }
     151                 :            : 
     152                 :         15 : inline void Error::set_string(const char *str) 
     153                 :            : {
     154                 :         15 :   errDescription = str;
     155                 :         15 : }
     156                 :            : 
     157                 :     214293 : inline void IBERRCHK_(int err, const char *descr, const char *file, int line)
     158                 :            : {
     159         [ +  + ]:     214293 :   if (iBase_SUCCESS != err)
     160         [ +  - ]:       1795 :     throw Error(err, "%s, line %d: %s", file, line, descr);
     161                 :     212498 : }
     162                 :            : 
     163                 :        369 : inline void IBERRCHK_(int err, iMesh &mesh, const char *file, int line)
     164                 :            : {
     165         [ -  + ]:        369 :   if (iBase_SUCCESS != err)
     166                 :            :     throw Error(err, "%s, line %d: %s", file, line,
     167 [ #  # ][ #  # ]:          0 :                 mesh.getDescription().c_str());
     168                 :        369 : }
     169                 :            : 
     170                 :      10059 : inline void IBERRCHK_(int err, iGeom &geom, const char *file, int line)
     171                 :            : {
     172         [ -  + ]:      10059 :   if (iBase_SUCCESS != err)
     173                 :            :     throw Error(err, "%s, line %d: %s", file, line,
     174 [ #  # ][ #  # ]:          0 :                 geom.getDescription().c_str());
     175                 :      10059 : }
     176                 :            : 
     177                 :            : inline void IBERRCHK_(int err, iRel &rel, const char *file, int line)
     178                 :            : {
     179                 :            :   if (iBase_SUCCESS != err)
     180                 :            :     throw Error(err, "%s, line %d: %s", file, line,
     181                 :            :                 rel.getDescription().c_str());
     182                 :            : }
     183                 :            : 
     184                 :            : } // namespace MeshKit
     185                 :            : 
     186                 :            : #endif

Generated by: LCOV version 1.11