outputChannelManager.h

Go to the documentation of this file.

/*********************************************************************
** Copyright (c) 2015 VT MAK
** All rights reserved.
*********************************************************************/

#pragma once

#include "vrfutil/vrfutilDefines.h"
#include "vrfutil/rwChannelDescriptor.h"
#include <vrfutil/objectCounter.h>

#include "tbb/spin_mutex.h"

class DtChannelSpecificOutputStream;

class DT_DLL_vrfutil DtOutputChannelManager
{
public:
   DtOutputChannelManager(int& globalNotifyReference);
   virtual ~DtOutputChannelManager();

   struct ChannelSettings
   {
      ChannelSettings(int nl = DtNlInfo, const DtString& p = "", 
         bool enabled = false)
         : notifyLevel(nl)
         , prefix(p)
         , enabled(enabled)
      {

      }

      int notifyLevel;
      DtString prefix;
      bool enabled;
   };

   virtual void addPrinter(DtPrinter* printer);

   virtual void addAndManagePrinter(DtPrinter* printer);

   virtual void removePrinter(DtPrinter* printer);

   virtual DtOutputStream& printError(const DtString& channel = "");
   virtual DtOutputStream& printWarn(const DtString& channel = "");
   virtual DtOutputStream& printInfo(const DtString& channel = "");
   virtual DtOutputStream& printVerbose(const DtString& channel = "");
   virtual DtOutputStream& printDebug(const DtString& channel = "");

   virtual void setChannelSettings(const DtRwChannelDescriptorList& settings);

   virtual int channelNotifyLevel(const DtString& channel);
   virtual void setChannelNotifyLevel(const DtString& channel, 
      int level);

   virtual DtString channelPrefix(const DtString& channel);
   virtual void setChannelPrefix(const DtString& channel,
      const DtString& prefix);

   virtual bool channelEnabled(const DtString& channel);
   virtual void setChannelEnabled(const DtString& channel,
      bool enabled);

   virtual void addDefaultStream(int notifyLevel, DtOutputStream& stream);

   virtual DtOutputStream& defaultStream(int notifyLevel);

   virtual void printStatus(const DtString& channel = "");

   virtual DtString channelStatus(const DtString& channel);

   typedef DtChannelSpecificOutputStream* (*DtOutputChannelStreamCreatorFcn)(
      DtOutputStreamBuffer*, int&, int, DtPrinter*, const std::string&);
   virtual void setStreamCreatorFcn(DtOutputChannelStreamCreatorFcn fcn);

   typedef DtOutputStreamBuffer* (*DtOutputStreamBufferCreatorFcn)();
   virtual void setStreamBufferCreatorFcn(DtOutputStreamBufferCreatorFcn fcn);

   virtual DtOutputStreamBuffer* createStreamBuffer();

   virtual void setManageDefaultStreams(bool manage);

   virtual std::vector<DtString> allChannels() const;

protected:
   virtual DtOutputStream& streamForChannel(const DtString& channel, int notifyLevel);

   virtual DtChannelSpecificOutputStream* createStream(
      int &globalThresholdRef, int threshold = 1, DtPrinter *dflt_printer = 0,
      const std::string& prefix = "");

   virtual void attachToAllStreams(DtPrinter* printer);
   virtual void detachFromAllStreams(DtPrinter* printer);

   virtual ChannelSettings* channelSettings(const DtString& channel);

   virtual void addAllPrinters(DtOutputStream* stream);

protected:
   std::vector<DtPrinter*> myPrinters;
   std::vector<DtPrinter*> myManagedPrinters;

   typedef std::map<DtString, ChannelSettings*> ChannelSettingsMap;
   ChannelSettingsMap myChannelSettingsMap;

   int& myGlobalNotifyReference;

   typedef std::vector<DtChannelSpecificOutputStream*> StreamVector;
   typedef std::map<DtString, StreamVector> ChannelMap;
   ChannelMap myChannelMap;

   struct DefaultStreamInfo
   {
      explicit DefaultStreamInfo(DtOutputStream* stream = 0, DtOutputStreamBuffer* buffer = 0);

      DtOutputStream* stream;
      DtOutputStreamBuffer* buffer;
   };

   std::vector<DefaultStreamInfo> myDefaultStreams;

   DtOutputStreamBuffer myNullStreamBuffer;
   std::auto_ptr<DtOutputStream> myNullStream;

   DtOutputChannelStreamCreatorFcn myStreamCreatorFcn;
   DtOutputStreamBufferCreatorFcn myStreamBufferCreatorFcn;

   bool myManageDefaultStreams;

   //locked when accessing/modifying internal maps to allow streams to be 
   //accessed from different threads concurrently.
   tbb::spin_mutex myMutex;
};

class DtChannelSpecificOutputStream : public DtOutputStream
   , public DtObjectDebugger<DtChannelSpecificOutputStream>
{
public:
   DtChannelSpecificOutputStream(
      DtOutputStreamBuffer *b,
      int &globalThresholdRef,
      int threshold = 1,
      DtPrinter *dflt_printer = 0,
      const std::string& prefix = "")
      : DtOutputStream(b, globalThresholdRef, threshold, dflt_printer)
      , myPrefix(prefix)
      , myBuffer(b)
   {
   }

   virtual ~DtChannelSpecificOutputStream()
   {
   };

   virtual void write( const std::string &str )
   {
      if (myPrefix != "" && str != "")
      {
         DtOutputStream::write(std::string("[") + myPrefix + "]: " + str);
      }
      else //if (str != "")
      {
         DtOutputStream::write(str);
      }
   }

   virtual void setPrefix(const DtString& str)
   {
      myPrefix = str.c_str();
   }

   DtOutputStreamBuffer* getBuffer()
   {
      return myBuffer;
   }

   static DtChannelSpecificOutputStream* creator(
      DtOutputStreamBuffer *b,
      int &globalThresholdRef,
      int threshold = 1,
      DtPrinter *dflt_printer = 0,
      const std::string& prefix = "")
   {
      return new DtChannelSpecificOutputStream(b, globalThresholdRef,
         threshold, dflt_printer, prefix);
   }

protected:
   std::string myPrefix;
   DtOutputStreamBuffer* myBuffer;
};

DT_DEFINE_OBJECT_DEBUGGER_NAME(DtChannelSpecificOutputStream);