Line data    Source code

       1              : /** \file user_log.hpp
       2              :   * \brief The MagAO-X logger user_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              :   * - 2025-05-02 revised with added email field by JRM
      10              :   */
      11              : #ifndef logger_types_user_log_hpp
      12              : #define logger_types_user_log_hpp
      13              : 
      14              : #include "generated/user_log_generated.h"
      15              : #include "flatbuffer_log.hpp"
      16              : 
      17              : namespace MagAOX
      18              : {
      19              : namespace logger
      20              : {
      21              : 
      22              : /// User entered log
      23              : /** \ingroup logger_types
      24              :   */
      25              : struct user_log : public flatbuffer_log
      26              : {
      27              :     /// The event code
      28              :     static const flatlogs::eventCodeT eventCode = eventCodes::USER_LOG;
      29              : 
      30              :     /// The default level
      31              :     static const flatlogs::logPrioT defaultLevel = flatlogs::logPrio::LOG_INFO;
      32              : 
      33              :     ///The type of the message
      34              :     struct messageT : public fbMessage
      35              :     {
      36            1 :         messageT( const std::string & email,
      37              :                   const std::string & message
      38              :                 )
      39            1 :         {
      40            1 :             auto _eml = builder.CreateString(email);
      41            1 :             auto _msg = builder.CreateString(message);
      42              : 
      43            1 :             auto gs = CreateUser_log_fb(builder, _eml, _msg);
      44            1 :             builder.Finish(gs);
      45            1 :         }
      46              :     };
      47              : 
      48            1 :     static bool verify( flatlogs::bufferPtrT & logBuff,  ///< [in] Buffer containing the flatbuffer serialized message.
      49              :                         flatlogs::msgLenT len            ///< [in] length of msgBuffer.
      50              :                       )
      51              :     {
      52            1 :         auto verifier = flatbuffers::Verifier( static_cast<uint8_t*>(flatlogs::logHeader::messageBuffer(logBuff)), static_cast<size_t>(len));
      53            2 :         return VerifyUser_log_fbBuffer(verifier);
      54              :     }
      55              : 
      56              :     ///Get the message formatte for human consumption.
      57            0 :     static std::string msgString( void * msgBuffer,  /**< [in] Buffer containing the flatbuffer serialized message.*/
      58              :                                   flatlogs::msgLenT len  /**< [in] [unused] length of msgBuffer.*/
      59              :                                 )
      60              :     {
      61              :         static_cast<void>(len);
      62              : 
      63            0 :         auto fbs = GetUser_log_fb(msgBuffer);
      64              : 
      65            0 :         std::string msg = "[USER] ";
      66              : 
      67            0 :         if(fbs->email())
      68              :         {
      69            0 :             msg += fbs->email()->c_str();
      70            0 :             msg += ": ";
      71              :         }
      72              :         else
      73              :         {
      74            0 :             msg += "unknown: ";
      75              :         }
      76              : 
      77            0 :         if(fbs->message())
      78              :         {
      79            0 :             msg += fbs->message()->c_str();
      80              :         }
      81              : 
      82            0 :         return msg;
      83            0 :     }
      84              : 
      85              :     ///Get the user email from a user_log
      86            0 :     static std::string email( void * msgBuffer /**< [in] Buffer containing the flatbuffer serialized message.*/)
      87              :     {
      88            0 :         auto fbs = GetUser_log_fb(msgBuffer);
      89            0 :         if(fbs->email() != nullptr)
      90              :         {
      91            0 :             return std::string(fbs->email()->c_str());
      92              :         }
      93            0 :         else return "";
      94              :    }
      95              : 
      96              :     ///Get the message from a user_log
      97            0 :     static std::string message( void * msgBuffer /**< [in] Buffer containing the flatbuffer serialized message.*/)
      98              :     {
      99            0 :         auto fbs = GetUser_log_fb(msgBuffer);
     100            0 :         if(fbs->message() != nullptr)
     101              :         {
     102            0 :             return std::string(fbs->message()->c_str());
     103              :         }
     104            0 :         else return "";
     105              :     }
     106              : 
     107              :     /// Get the logMetaDetail for a member by name
     108              :    /**
     109              :      * \returns the a logMetaDetail filled in with the appropriate details
     110              :      * \returns an empty logMetaDetail if member not recognized
     111              :      */
     112            1 :     static logMetaDetail getAccessor( const std::string & member /**< [in] the name of the member */ )
     113              :     {
     114            1 :         if(     member == "email")   return logMetaDetail({"USER", logMeta::valTypes::String, logMeta::metaTypes::State, reinterpret_cast<void*>(&email), false});
     115            1 :         else if(member == "message") return logMetaDetail({"MESSAGE", logMeta::valTypes::String, logMeta::metaTypes::State, reinterpret_cast<void*>(&message), false});
     116              :         else
     117              :         {
     118            1 :             std::cerr << "No member " << member << " in user_log\n";
     119            1 :             return logMetaDetail();
     120              :         }
     121              :    }
     122              : 
     123              : };
     124              : 
     125              : 
     126              : } //namespace logger
     127              : } //namespace MagAOX
     128              : 
     129              : #endif //logger_types_user_log_hpp