logMeta.hpp

Go to the documentation of this file.

/** \file logMeta.hpp
 * \brief Declares and defines the logMeta class and related classes.
 * \author Jared R. Males (jaredmales@gmail.com)
 *
 * \ingroup logger_files
 *
 * History:
 * - 2020-01-02 created by JRM
 */
 
#ifndef logger_logMeta_hpp
#define logger_logMeta_hpp
 
#include <mx/ioutils/fits/fitsHeaderCard.hpp>
// #define HARD_EXIT
#include "logMap.hpp"
 
namespace MagAOX
{
namespace logger
{
 
// This is how the user specifies an item of log meta data (i.e. via a config file)
struct logMetaSpec
{
    std::string          device;
    flatlogs::eventCodeT eventCode;
    std::string          member;
    std::string          keyword; // overrides the default
    std::string          format;  // overrides the default
    std::string          comment; // overrides the default
 
    logMetaSpec()
    {
    }
 
    logMetaSpec( const std::string         &dev,
                 const flatlogs::eventCodeT ec,
                 const std::string         &memb,
                 const std::string         &k,
                 const std::string         &f,
                 const std::string         &c )
        : device( dev ), eventCode( ec ), member( memb ), keyword( k ), format( f ), comment( c )
    {
    }
 
    logMetaSpec( const std::string &dev, const flatlogs::eventCodeT ec, const std::string &memb )
        : device( dev ), eventCode( ec ), member( memb )
    {
    }
};
 
// This is the data returned by the member accessor.
struct logMetaDetail
{
    std::string keyword;
    std::string comment;
    std::string format;
    int         valType{ -1 };
    int         metaType{ -1 };
    void       *accessor{ nullptr };
    bool        hierarch{ true }; // if false the device name is not included.
 
    logMetaDetail()
    {
    }
 
    logMetaDetail( const std::string &k, const std::string &c, const std::string &f, int vt, int mt, void *acc )
        : keyword( k ), comment( c ), format( f ), valType( vt ), metaType( mt ), accessor( acc )
    {
    }
 
    logMetaDetail( const std::string &k, const std::string &c, const std::string &f, int vt, int mt, void *acc, bool h )
        : keyword( k ), comment( c ), format( f ), valType( vt ), metaType( mt ), accessor( acc ), hierarch( h )
    {
    }
 
    logMetaDetail( const std::string &k, const std::string &c, int vt, int mt, void *acc, bool h )
        : keyword( k ), comment( c ), valType( vt ), metaType( mt ), accessor( acc ), hierarch( h )
    {
    }
 
    logMetaDetail( const std::string &k, int vt, int mt, void *acc )
        : keyword( k ), valType( vt ), metaType( mt ), accessor( acc )
    {
    }
 
    logMetaDetail( const std::string &k, int vt, int mt, void *acc, bool h )
        : keyword( k ), valType( vt ), metaType( mt ), accessor( acc ), hierarch( h )
    {
    }
};
 
 
/*logMetaDetail logMemberAccessor( flatlogs::eventCodeT ec,
                                 const std::string & memberName
                               );
*/
 
template <typename valT, class verboseT = XWC_DEFAULT_VERBOSITY>
int getLogStateVal( valT                      &val,
                    logMap<verboseT>          &lm,
                    const std::string         &appName,
                    flatlogs::eventCodeT       ev,
                    const flatlogs::timespecX &stime,
                    const flatlogs::timespecX &atime,
                    valT ( *getter )( void * ),
                    char **hint = 0 )
{
    char *atprior = nullptr;
    char *stprior = nullptr;
 
    char *_hint = nullptr;
 
    if( hint )
        _hint = *hint;
    else
        _hint = 0;
 
#ifdef DEBUG
    std::cerr << __FILE__ << " " << __LINE__ << "\n";
#endif
 
    if( lm.getPriorLog( stprior, appName, ev, stime, _hint ) != 0 )
    {
        std::cerr << __FILE__ << " " << __LINE__ << " getPriorLog returned error for " << appName << ":" << ev << "\n";
        return -1;
    }
    valT stprV = getter( flatlogs::logHeader::messageBuffer( stprior ) );
 
    valT atprV;
 
#ifdef DEBUG
    std::cerr << __FILE__ << " " << __LINE__ << "\n";
#endif
 
    if( lm.getNextLog( atprior, stprior, appName ) != 0 )
    {
        std::cerr << __FILE__ << " " << __LINE__ << " getNextLog returned error for " << appName << ":" << ev << "\n";
        return -1;
    }
 
#ifdef DEBUG
    std::cerr << __FILE__ << " " << __LINE__ << "\n";
#endif
 
    while( flatlogs::logHeader::timespec( atprior ) < atime )
    {
        atprV = getter( flatlogs::logHeader::messageBuffer( atprior ) );
        if( atprV != stprV )
        {
            val = atprV;
            if( hint )
                *hint = stprior;
            return 0;
        }
        stprior = atprior;
        if( lm.getNextLog( atprior, stprior, appName ) != 0 )
        {
            std::cerr << __FILE__ << " " << __LINE__ << " getNextLog returned error for " << appName << ":" << ev
                      << "\n";
            return -1;
        }
    }
 
    val = stprV;
 
    if( hint )
        *hint = stprior;
    return 0;
}
 
template <typename valT, class verboseT = XWC_DEFAULT_VERBOSITY>
int getLogContVal( valT                      &val,
                   logMap<verboseT>          &lm,
                   const std::string         &appName,
                   flatlogs::eventCodeT       ev,
                   const flatlogs::timespecX &stime,
                   const flatlogs::timespecX &atime,
                   valT ( *getter )( void * ),
                   char **hint = 0 )
{
    char *atafter;
    char *stprior;
 
    char *_hint;
    if( hint )
        _hint = *hint;
    else
        _hint = 0;
 
    flatlogs::timespecX midexp = meanTimespecX( atime, stime );
 
    // Get log entry before midexp
    if( lm.getPriorLog( stprior, appName, ev, midexp, _hint ) != 0 )
    {
        std::cerr << __FILE__ << " " << __LINE__ << " getPriorLog returned error for " << appName << ":" << ev << "\n";
        return 1;
    }
    valT stprV = getter( flatlogs::logHeader::messageBuffer( stprior ) );
 
    // Get log entry after.
    if( lm.getNextLog( atafter, stprior, appName ) != 0 )
    {
        std::cerr << __FILE__ << " " << __LINE__ << " getNextLog returned error for " << appName << ":" << ev << "\n";
#ifdef HARD_EXIT
        exit( -1 );
#endif
        return 1;
    }
    valT atprV = getter( flatlogs::logHeader::messageBuffer( atafter ) );
 
    double st = flatlogs::logHeader::timespec( stprior ).asDouble();
    double it = midexp.asDouble();
    double et = flatlogs::logHeader::timespec( atafter ).asDouble();
 
    val = stprV + ( atprV - stprV ) / ( et - st ) * ( it - st );
 
    if( hint )
        *hint = stprior;
 
    return 0;
}
 
/// Manage meta data for a log entry
/** Handles cases where log is a state, i.e. has one of a finite number of values, or is a
 * continuous variable, e.g. a temperature.
 *
 * Contains the information to construct a FITS header card.
 */
struct logMeta
{
    typedef XWC_DEFAULT_VERBOSITY verboseT;
 
  public:
    enum valTypes
    {
        String           = mx::fits::fitsType<std::string>(),
        Bool             = mx::fits::fitsType<bool>(),
        Char             = mx::fits::fitsType<char>(),
        UChar            = mx::fits::fitsType<unsigned char>(),
        Short            = mx::fits::fitsType<short>(),
        UShort           = mx::fits::fitsType<unsigned short>(),
        Int              = mx::fits::fitsType<int>(),
        UInt             = mx::fits::fitsType<unsigned int>(),
        Long             = mx::fits::fitsType<long>(),
        ULong            = mx::fits::fitsType<unsigned long>(),
        LongLong         = mx::fits::fitsType<long long>(),
        ULongLong        = mx::fits::fitsType<unsigned long long>(),
        Float            = mx::fits::fitsType<float>(),
        Double           = mx::fits::fitsType<double>(),
        Vector_String    = 10000,
        Vector_Bool      = 10002,
        Vector_Char      = 10004,
        Vector_UChar     = 10006,
        Vector_Short     = 10008,
        Vector_UShort    = 10010,
        Vector_Int       = 10012,
        Vector_UInt      = 10014,
        Vector_Long      = 10016,
        Vector_ULong     = 10018,
        Vector_LongLong  = 10020,
        Vector_ULongLong = 10022,
        Vector_Float     = 10024,
        Vector_Double    = 10026
    };
 
    enum metaTypes
    {
        State,
        Continuous
    };
 
  protected:
    logMetaSpec   m_spec;
    logMetaDetail m_detail;
 
    bool        m_isValid{ false };
    std::string m_invalidValue{ "invalid" };
 
    char *m_hint{ nullptr };
 
  public:
    logMeta( const logMetaSpec &lms /**< [in] the specification of this meta data entry */ );
 
    const std::string &device();
    const std::string &keyword();
 
    const std::string &comment();
 
    int setLog( const logMetaSpec & );
 
    std::string value( logMap<verboseT> &lm, const flatlogs::timespecX &stime, const flatlogs::timespecX &atime );
 
    std::string valueNumber( logMap<verboseT> &lm, const flatlogs::timespecX &stime, const flatlogs::timespecX &atime );
 
    std::string valueString( logMap<verboseT> &lm, const flatlogs::timespecX &stime, const flatlogs::timespecX &atime );
 
    mx::fits::fitsHeaderCard<verboseT>
    card( logMap<verboseT> &lm, const flatlogs::timespecX &stime, const flatlogs::timespecX &atime );
};
 
} // namespace logger
} // namespace MagAOX
 
#endif // logger_logMeta_hpp