UT_UniversalLogEntry.h

Go to the documentation of this file.

/*
 * PROPRIETARY INFORMATION.  This software is proprietary to
 * Side Effects Software Inc., and is not to be reproduced,
 * transmitted, or disclosed in any way without written permission.
 *
 * NAME:        UT_UniversalLogEntry.h ( FS Library, C++)
 *
 * COMMENTS:
 *
 */

#ifndef __UT_UniversalLogEntry__
#define __UT_UniversalLogEntry__

#include "UT_API.h"
#include "UT_Date.h"
#include "UT_Error.h"
#include "UT_ErrorCode.h"
#include "UT_IntrusivePtr.h"
#include "UT_SourceLocation.h"
#include "UT_StringHolder.h"
#include <SYS/SYS_Hash.h>
#include <SYS/SYS_Math.h>
#include <SYS/SYS_SequentialThreadIndex.h>
#include <SYS/SYS_Time.h>

template <typename T> class UT_Array;
class UT_JSONParser;
class UT_JSONWriter;

class UT_UniversalLogExternalInfo :
    public UT_IntrusiveRefCounter<UT_UniversalLogExternalInfo>
{
public:
    UT_UniversalLogExternalInfo()
        : myProcessId(0)
    { }

    SYS_HashType hash() const
    {
        SYS_HashType h = myHostName.hash();
        SYShashCombine(h, myIdentifier.hash());
        SYShashCombine(h, myCommandLine.hash());
        SYShashCombine(h, SYSwang_inthash(myProcessId));

        return h;
    }

    UT_StringHolder                  myHostName;
    UT_StringHolder                  myIdentifier;
    UT_StringHolder                  myCommandLine;
    int                              myProcessId;
};
typedef UT_IntrusivePtr<UT_UniversalLogExternalInfo>
    UT_UniversalLogExternalInfoHandle;

/// Simple object to hold the data associated with a single log entry event.
class UT_API UT_UniversalLogEntry
{
public:
    UT_UniversalLogEntry(
        const UT_StringHolder &source_name = UT_StringHolder::theEmptyString,
        const UT_StringHolder &message = UT_StringHolder::theEmptyString,
        const UT_StringHolder &source_context = UT_StringHolder::theEmptyString,
        UT_ErrorSeverity severity = UT_ERROR_NONE,
        int verbosity = 0,
        const UT_SourceLocation &source_code_location = UT_SourceLocation(),
        UT_UniversalLogExternalInfoHandle external_info =
            UT_UniversalLogExternalInfoHandle())
        : mySourceName(source_name),
          myMessage(message),
          mySourceContext(source_context),
          mySourceCodeLocation(source_code_location),
          myErrorSeverity(severity),
          myVerbosity(verbosity),
          myTime(SYStime() - theStartTime + theStartTimeSinceEpoch),
          myThreadId(SYSgetSTID()),
          myExternalInfo(external_info)
    { }

    UT_UniversalLogEntry(
            const UT_ErrorCode &ec,
            const UT_StringHolder &what,
            const UT_StringHolder &source_context
            = UT_StringHolder::theEmptyString,
            UT_ErrorSeverity severity = UT_ERROR_ABORT,
            int verbosity = 0,
            const UT_SourceLocation &source_location = UT_SourceLocation(),
            UT_UniversalLogExternalInfoHandle external_info
            = UT_UniversalLogExternalInfoHandle())
        : mySourceName(ec.category().name())
        , mySourceContext(source_context)
        , mySourceCodeLocation(source_location)
        , myErrorSeverity(severity)
        , myVerbosity(verbosity)
        , myTime(SYStime() - theStartTime + theStartTimeSinceEpoch)
        , myThreadId(SYSgetSTID())
        , myExternalInfo(external_info)
    {
        myMessage.format("{}: {}", what, ec.message());
    }

    /// The natural order of log messages is chronological.
    bool operator<(const UT_UniversalLogEntry &other) const
    {
        return myTime < other.myTime;
    }

    exint getMemoryUsage() const
    {
        return sizeof(*this) +
           mySourceName.length() +
           myMessage.length() +
           mySourceContext.length() +
           mySourceCodeLocation.getMemoryUsage(false);
    }

    SYS_HashType hash() const
    {
        SYS_HashType h = mySourceName.hash();
        SYShashCombine(h, myMessage.hash());
        SYShashCombine(h, mySourceContext.hash());
        SYShashCombine(h, mySourceCodeLocation.source().hash());
        SYShashCombine(h, SYSwang_inthash(mySourceCodeLocation.line()));
        SYShashCombine(h, SYSwang_inthash(mySourceCodeLocation.columnStart()));
        SYShashCombine(h, SYSwang_inthash(mySourceCodeLocation.columnEnd()));
        SYShashCombine(h, SYSwang_inthash(myErrorSeverity));
        SYShashCombine(h, SYSwang_inthash(myVerbosity));
        SYShashCombine(h, SYSreal_hash(myTime));
        SYShashCombine(h, SYSwang_inthash(myThreadId));
        if (myExternalInfo)
            SYShashCombine(h, myExternalInfo->hash());

        return h;
    }

    static bool save(UT_JSONWriter &w,
                     const UT_Array<UT_UniversalLogEntry> &log_entries);
    static bool load(UT_JSONParser &p,
                     UT_Array<UT_UniversalLogEntry> &log_entries);

    UT_StringHolder                      mySourceName;
    UT_StringHolder                      myMessage;
    UT_StringHolder                      mySourceContext;
    UT_SourceLocation                    mySourceCodeLocation;
    UT_ErrorSeverity                     myErrorSeverity;
    int                                  myVerbosity;
    fpreal                               myTime;
    int                                  myThreadId;
    UT_UniversalLogExternalInfoHandle    myExternalInfo;
    static fpreal                        theStartTime;
    static fpreal                        theStartTimeSinceEpoch;
};
typedef UT_Array<UT_UniversalLogEntry> UT_UniversalLogEntryArray;

#endif