Line data    Source code

       1              : #include <assert.h>
       2              : #include <sstream>
       3              : #include <ers/ers.hpp>
       4              : 
       5              : namespace 
       6              : {
       7              :     const char * SeverityNames[] =
       8              :     { 
       9              :         "DEBUG",
      10              :         "LOG",
      11              :         "INFO",
      12              :         "WARNING",
      13              :         "ERROR",
      14              :         "FATAL"
      15              :     };
      16              : }
      17              : 
      18           73 : ERS_DECLARE_ISSUE(      ers,
      19              :                         BadSeverity,
      20              :                         "string \"" << severity << "\" does not contain valid severity",
      21              :                         ((std::string)severity) )
      22              : 
      23              : 
      24              : /** 
      25              :  * \brief Transforms a severity type into the corresponding string
      26              :  * \param s severity
      27              :  * \return reference to string with associated text 
      28              :  */
      29              : std::string
      30           54 : ers::to_string( ers::severity severity )
      31              : {
      32           54 :     assert( ers::Debug <= severity && severity <= ers::Fatal );
      33           54 :     return SeverityNames[severity];
      34              : }
      35              : 
      36              : /** 
      37              :  * \brief Transforms a severity type into the corresponding string
      38              :  * \param s severity
      39              :  * \return pointer to string with associated text 
      40              :  */
      41              : std::string
      42         1022 : ers::to_string( ers::Severity severity )
      43              : {
      44         1022 :     assert( ers::Debug <= severity && severity <= ers::Fatal );
      45              : 
      46         1022 :     if ( severity.type == ers::Debug )
      47              :     {
      48            0 :         std::ostringstream out;
      49            0 :         out << SeverityNames[severity] << "_" << severity.rank;
      50            0 :         return out.str();
      51            0 :     }
      52         1022 :     return SeverityNames[severity.type];
      53              : }
      54              : 
      55              : /** Parses a string and extracts a severity 
      56              :  * \param s the string to parse 
      57              :  * \return a severity value
      58              :  */
      59              : ers::severity
      60            0 : ers::parse( const std::string & string, ers::severity & s )
      61              : {
      62            0 :     for( short ss = ers::Debug; ss <= ers::Fatal; ++ss )
      63              :     {
      64            0 :         if ( string == SeverityNames[ss] )
      65              :         {
      66            0 :             return ( s = (ers::severity)ss );
      67              :         }
      68              :     }
      69            0 :     throw ers::BadSeverity( ERS_HERE, string ); 
      70              : }
      71              : 
      72              : /** Parses a string and extracts a severity 
      73              :  * \param s the string to parse 
      74              :  * \return a severity value
      75              :  */
      76              : ers::Severity
      77            0 : ers::parse( const std::string & string, ers::Severity & s )
      78              : {
      79            0 :     int level = 0;
      80            0 :     ers::severity type;
      81            0 :     std::string::size_type pos = string.find( '_' );
      82            0 :     if ( pos )
      83              :     {
      84            0 :         std::istringstream in( string.substr( pos + 1 ) );
      85            0 :         in >> level;
      86            0 :         ers::parse( string.substr( 0, pos ), type );
      87            0 :     }
      88              :     else
      89              :     {
      90            0 :         ers::parse( string, type );
      91              :     }
      92            0 :     return ( s = ers::Severity( type, level ) );
      93              : }
      94              :