outputChannelManager.h

Go to the documentation of this file.

/****************************************************************************
 * Copyright (c) 2022 MAK Technologies, Inc.
 * All rights reserved.
 ****************************************************************************/


#pragma once

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

#include "tbb/spin_mutex.h"

#include <stdarg.h>

class DtChannelSpecificOutputStream;

class DT_DLL_vrfutil DtOutputChannelManager
{
public:

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

      int notifyLevel;
      DtString prefix;
      bool enabled;

   };

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

   typedef DtOutputStreamBuffer* (*DtOutputStreamBufferCreatorFcn)();

public:

   DtOutputChannelManager( int& globalNotifyReference );

   virtual ~DtOutputChannelManager();

   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 );

   virtual void setStreamCreatorFcn( DtOutputChannelStreamCreatorFcn fcn );

   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* default_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:

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

      DtOutputStream* stream;
      DtOutputStreamBuffer* buffer;
   };

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;

   std::vector<DefaultStreamInfo> myDefaultStreams;

   DtOutputStreamBuffer myNullStreamBuffer;
   std::unique_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.
   mutable tbb::spin_mutex myMutex;

};


class DtChannelSpecificOutputStream : public DtOutputStream
#ifdef DtObjectDebugger_Enable
   , public DtObjectDebugger<DtChannelSpecificOutputStream>
#endif
{
public:

   DtChannelSpecificOutputStream( DtOutputStreamBuffer* b, int& globalThresholdRef, int threshold = 1,
         DtPrinter* default_printer = 0, const std::string& prefix = "" )
      : DtOutputStream( b, globalThresholdRef, threshold, default_printer )
      , myPrefix( prefix )
      , myBuffer( b )
   {
   }

   virtual ~DtChannelSpecificOutputStream() override {
   }

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

   virtual void operator() (const char* s, ...) override
   {
      if (okToPrint())
      {
         myStreamBufMutex.lock();
         myStreamBuf->pubsync();
         myStreamBufMutex.unlock();

         if (!s)
         {
            return;
         }

         char str[2048];
         va_list args; 
         va_start(args, s);
         vsprintf(str, s, args);
         va_end(args);
         std::string temp(str);

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


   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* default_printer = 0, const std::string& prefix = "" )
   {
      return new DtChannelSpecificOutputStream( b, globalThresholdRef, threshold, default_printer, prefix );
   }

protected:

   std::string myPrefix;
   DtOutputStreamBuffer* myBuffer;

};


DT_DEFINE_OBJECT_DEBUGGER_NAME( DtChannelSpecificOutputStream );