columnLogger.h

Go to the documentation of this file.

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


#pragma once

#include <vrfutil/vrfutilDefines.h>

#include <boost/noncopyable.hpp>
#include <boost/ptr_container/ptr_list.hpp>

#include <tbb/spin_mutex.h>
#include <tbb/spin_rw_mutex.h>

#include <iosfwd>
#include <list>
#include <map>
#include <sstream>
#include <string>
#include <vector>


class DT_DLL_vrfutil DtColumnLogger : boost::noncopyable
{
public:
   explicit DtColumnLogger();

   ~DtColumnLogger();

   class DT_DLL_vrfutil Column : boost::noncopyable
   {
   public:
      struct DT_DLL_vrfutil Value
      {
         typedef std::list<Value> List;

         unsigned line;
         double number;
         unsigned calls;
         unsigned precision;

         struct Parent
         {
            typedef std::vector<Parent> Sequence;

            const char* group;
            double percent;

            explicit Parent(const char* g, double p)
               : group(g), percent(p) { }
         };

         Parent::Sequence parents;

         Value& setGroup(const char* n, double percent)
         { parents.push_back(Parent(n,percent)); return *this; }
         Value& addCalls(unsigned c) { calls += c; return *this; }
         Value& setPrecision(unsigned p) { precision = p; return *this; }

         std::string str() const;

         explicit Value(double number, unsigned line);
      };

      typedef boost::ptr_list<Column> Sequence;

      explicit Column(DtColumnLogger&, const std::string& label);
      explicit Column(Column& parent, const std::string& label);

      Column& getColumn(const std::string& label, int index = -1);

      Value& addValue(double);

      template <typename T>
      Value& addValue(T val)
      {
         return addValue(double(val)).setPrecision(3);
      }

      void reset(bool resetWidth);

      int print(std::ostream* textstream, std::ostream* csvsteram, bool headers);

      unsigned width();
      void updateWidth(unsigned, bool onlyIfGreater=true);

      Value::List& values() { return myValues; }
      Sequence& subColumns() { return myColumns; }

      std::string label() const { return myLabel; }

      void markAsPrinted();
      bool hasBeenPrinted();

   private:
      typedef tbb::spin_rw_mutex Mutex;

      mutable Mutex myMutex;
      DtColumnLogger& myLogger;

      std::string myLabel;
      Value::List myValues;

      unsigned myMaxWidth;
      bool myNewFlag;

      Sequence myColumns;
   };

   Column& getColumn(const std::string& label, int index = -1)
   {
      return myRootColumn.getColumn(label, index);
   }

   Column& getColumn(const char* label, int index = -1)
   {
      return getColumn(std::string(label), index);
   }

   unsigned lineNumber() const;
   void incrementLineNumber();

   void reset(bool resetWidth = false);

   void print();
   void printText(const std::string&);

   void setOutput(const std::string& file);
   void setTag(const std::string& tag);

private:
   void initFiles();

   unsigned myCurrentLine;
   unsigned myLinesSinceHeaderPrint;

   Column myRootColumn;
   std::string myTextOutputFile;
   std::string myCSVOutputFile;
   std::string myTag;

   std::ostream* myTextOutput;
   std::ostream* myCSVOutput;
   
};