edebug.h

#ifndef EDEBUG_H
#define EDEBUG_H
#include <QObject>
#include <QAtomicInteger>
#include <QVector>
#include "eabstractanalytic.h"
#include "eabstractanalytic_input.h"
#include "ace_analytic_abstractmpi.h"
#ifdef QT_DEBUG
#define EDEBUG_FUNC(...) EDebug debug(__PRETTY_FUNCTION__,#__VA_ARGS__); debug.setArguments(__VA_ARGS__);
#else
#define EDEBUG_FUNC(...)
#endif
//



class EDebug
{
public:
   enum Token
   {
      Quote
      ,NoQuote
   };
public:
   static int threadId();
public:
   EDebug& operator<<(Token token);
   EDebug& operator<<(bool value);
   EDebug& operator<<(qint8 value);
   EDebug& operator<<(qint16 value);
   EDebug& operator<<(qint32 value);
   EDebug& operator<<(qint64 value);
   EDebug& operator<<(quint8 value);
   EDebug& operator<<(quint16 value);
   EDebug& operator<<(quint32 value);
   EDebug& operator<<(quint64 value);
   EDebug& operator<<(float value);
   EDebug& operator<<(double value);
   EDebug& operator<<(const char* value);
   EDebug& operator<<(const void*const value);
   EDebug& operator<<(const QByteArray& value);
   EDebug& operator<<(const QString& value);
   EDebug& operator<<(const QStringList& value);
   EDebug& operator<<(const QObject*const value);
   EDebug& operator<<(const QVariant& value);
   EDebug& operator<<(EAbstractAnalytic::Input::Type value);
   EDebug& operator<<(EAbstractAnalytic::Input::Role value);
   EDebug& operator<<(Ace::Analytic::AbstractMPI::Type value);
public:
   EDebug(const char* function, const char* argumentNames);
   ~EDebug();
   template<class... Args> void setArguments(Args... arguments);
protected:
   template<class T> void setArgument(int depth, T last);
   template<class T,class... Args> void setArgument(int depth, T next, Args... arguments);
private:
   static QAtomicInteger<int> _counter;
   static thread_local int _threadId;
   static thread_local int _stackDepth;
   static thread_local bool _active;
private:
   void setArgument(int depth);
   void setupArguments(const char* argumentNames);
   void dumpArguments();
   const char* _function;
   char* _argumentNames {nullptr};
   QVector<int> _argumentIndexes;
   QVector<QByteArray> _argumentValues;
   QByteArray _holder;
   bool _quote {true};
};






template<class... Args> void EDebug::setArguments(Args... arguments)
{
   // Signal this debug object is active, call the initial variadic template 
   // function, and then disable the active flag. 
   _active = true;
   setArgument(0,arguments...);
   _active = false;
}






template<class T> void EDebug::setArgument(int depth, T last)
{
   // Reset this object's holder byte array for streaming. 
   _quote = true;
   _holder.clear();

   // Stream the given argument's value using this object's stream operators. 
   *this << last;

   // Get the holder byte array string and set it as this object's tracked argument 
   // value for the given depth. 
   _argumentValues[depth] = _holder;

   // Dump all argument names and values to the logging server. 
   dumpArguments();
}






template<class T,class... Args> void EDebug::setArgument(int depth, T next, Args... arguments)
{
   // Reset this object's holder byte array for streaming. 
   _quote = true;
   _holder.clear();

   // Stream the given next argument's value using this object's stream operators. 
   *this << next;

   // Get the holder byte array string and set it as this object's tracked argument 
   // value for the given depth. 
   _argumentValues[depth] = _holder;

   // Call the next variadic function in this chain with one less argument in the 
   // list. 
   setArgument(depth + 1,arguments...);
}



#endif