Line data    Source code

       1              : /** \file string_log.hpp
       2              :  * \brief The MagAO-X logger string_log log type.
       3              :  * \author Jared R. Males (jaredmales@gmail.com)
       4              :  *
       5              :  * \ingroup logger_types_files
       6              :  *
       7              :  * History:
       8              :  * - 2018-08-18 created by JRM
       9              :  */
      10              : #ifndef logger_types_string_log_hpp
      11              : #define logger_types_string_log_hpp
      12              : 
      13              : #include "generated/string_log_generated.h"
      14              : #include "flatbuffer_log.hpp"
      15              : 
      16              : namespace MagAOX
      17              : {
      18              : 
      19              : namespace logger
      20              : {
      21              : 
      22              : /// Base class for logs consisting of a string message.
      23              : /** Does not have eventCode or defaultLevel, so this can not be used as a log type in logger.
      24              :  *
      25              :  * \ingroup logger_types_basic
      26              :  */
      27              : struct string_log : public flatbuffer_log
      28              : {
      29              :     /// The type of the message
      30              :     struct messageT : public fbMessage
      31              :     {
      32           41 :         messageT( const char *msg )
      33           41 :         {
      34           41 :             auto _msg = builder.CreateString( msg );
      35              : 
      36           41 :             auto gs = CreateString_log_fb( builder, _msg );
      37           41 :             builder.Finish( gs );
      38           41 :         }
      39              : 
      40           83 :         messageT( const std::string &msg )
      41           83 :         {
      42           83 :             auto _msg = builder.CreateString( msg );
      43              : 
      44           83 :             auto gs = CreateString_log_fb( builder, _msg );
      45           83 :             builder.Finish( gs );
      46           83 :         }
      47              :     };
      48              : 
      49            2 :     static bool verify( flatlogs::bufferPtrT &logBuff, ///< [in] Buffer containing the flatbuffer serialized message.
      50              :                         flatlogs::msgLenT     len      ///< [in] length of msgBuffer.
      51              :     )
      52              :     {
      53            2 :         auto verifier = flatbuffers::Verifier( static_cast<uint8_t *>( flatlogs::logHeader::messageBuffer( logBuff ) ),
      54            2 :                                                static_cast<size_t>( len ) );
      55            4 :         return VerifyString_log_fbBuffer( verifier );
      56              :     }
      57              : 
      58              :     /// Get the message formatted for human consumption.
      59           81 :     static std::string msgString( void *msgBuffer,      /**< [in] Buffer containing the flatbuffer serialized message.*/
      60              :                                   flatlogs::msgLenT len /**< [in] [unused] length of msgBuffer.*/
      61              :     )
      62              :     {
      63              :         static_cast<void>( len );
      64              : 
      65           81 :         auto rgs = GetString_log_fb( msgBuffer );
      66              : 
      67           81 :         if( rgs->message() == nullptr )
      68            0 :             return "";
      69              :         else
      70          162 :             return rgs->message()->c_str();
      71              :     }
      72              : 
      73              :     /// Access the message field
      74            0 :     static std::string message( void *msgBuffer /**< [in] Buffer containing the flatbuffer serialized message.*/ )
      75              :     {
      76            0 :         auto rgs = GetString_log_fb( msgBuffer );
      77            0 :         if( rgs->message() == nullptr )
      78              :         {
      79            0 :             return "";
      80              :         }
      81              :         else
      82              :         {
      83            0 :             return rgs->message()->c_str();
      84              :         }
      85              :     }
      86              : 
      87              :     /// Get the logMetaDetail for a member by name
      88              :     /**
      89              :      * \returns the a logMetaDetail filled in with the appropriate details
      90              :      * \returns an empty logMetaDetail if member not recognized
      91              :      */
      92            1 :     static logMetaDetail getAccessor( const std::string &member /**< [in] the name of the member */ )
      93              :     {
      94            1 :         if( member == "message" )
      95              :         {
      96              :             return logMetaDetail( { "MESSAGE",
      97              :                                     "log message",
      98              :                                     logMeta::valTypes::String,
      99              :                                     logMeta::metaTypes::State,
     100              :                                     reinterpret_cast<void *>( &message ),
     101            0 :                                     false } );
     102              :         }
     103              :         else
     104              :         {
     105            1 :             std::cerr << "No member " << member << " in string_log\n";
     106            1 :             return logMetaDetail();
     107              :         }
     108              :     }
     109              : };
     110              : 
     111              : } // namespace logger
     112              : } // namespace MagAOX
     113              : 
     114              : #endif // logger_types_string_log_hpp