UT_UniversalLogSource.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_UniversalLogSource.h ( FS Library, C++)
 *
 * COMMENTS:
 *
 */

#ifndef __UT_UniversalLogSource__
#define __UT_UniversalLogSource__

#include "UT_API.h"
#include "UT_Array.h"
#include "UT_Function.h"
#include "UT_Lock.h"
#include "UT_StringHolder.h"
#include "UT_UniversalLogEntry.h"

class UT_StringArray;
class UT_UniversalLogSink;
class UT_UniversalLogSource;

typedef UT_Function<UT_UniversalLogSource *()>
    UT_UniversalLogSourceCreator;

/// Use this macro to register a log source class so it can be created by
/// and attached to a log sink object.
#define UT_REGISTERUNIVERSALLOGSOURCE(source_class)                 \
    static UT_UniversalLogSourceRegistration theReg##source_class(  \
        source_class::staticName(),                                 \
        [] () { return new source_class(); })

/// This class performs the registration of a log source class. It also holds
/// the static map of instantiated source objects.
class UT_API UT_UniversalLogSourceRegistration
{
public:
                     UT_UniversalLogSourceRegistration(
                            const UT_StringHolder &source_name,
                            UT_UniversalLogSourceCreator creator);

    static bool      connect(const UT_StringHolder &source_name,
                            UT_UniversalLogSink *sink);
    static bool      disconnect(const UT_StringHolder &source_name,
                            UT_UniversalLogSink *sink);

    static void      getSourceNames(UT_StringArray &source_names);
    static bool      isSourceName(const UT_StringRef &source_name);
    static UT_UniversalLogSource *getSource(const UT_StringRef &source_name);
};

/// This class represents a logging data source. Each source is a singleton
/// created by the registration code the first time a sink asks to connect
/// to it. The Source is destroyed when the last sink disconnects from it.
/// The source's connection to its sinks is maintained by the base class, so
/// source subclasses simply need to call sendToSinks when they have a log
/// entry to broadcast.
class UT_API UT_UniversalLogSource
{
public:
    /// Sends a message to our associated log sinks.
    void             sendToSinks(const UT_UniversalLogEntry &entry);

protected:
                     UT_UniversalLogSource();
    virtual         ~UT_UniversalLogSource();

    UT_UniversalLogSource(const UT_UniversalLogSource &) = delete;
    UT_UniversalLogSource &operator=(const UT_UniversalLogSource &) = delete;

    UT_Lock                              mySinksLock;
    UT_Array<UT_UniversalLogSink *>      mySinks;

    friend class UT_UniversalLogSourceRegistration;
};

#endif