Debug.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#warning ZYPP_BASE_DEBUG_H included
#ifndef ZYPP_BASE_DEBUG_H
#define ZYPP_BASE_DEBUG_H

#include <iosfwd>
//#include <sstream>
//#include <string>
#include "zypp/base/Logger.h"
#include "zypp/base/String.h"
#include "zypp/ExternalProgram.h"
#include "zypp/base/ProvideNumericId.h"

namespace zypp
{ 

  namespace debug
  { 

#define TAG INT << __PRETTY_FUNCTION__ << std::endl

    inline std::ostream & dumpMemOn( std::ostream & str, const std::string & msg = std::string() )
    {
      static std::string mypid( str::numstring( getpid() ) );
      const char* argv[] =
      {
        "ps",
        "v",
        mypid.c_str(),
        NULL
      };
      ExternalProgram prog(argv,ExternalProgram::Discard_Stderr, false, -1, true);

      str << "MEMUSAGE " << msg << std::endl;
      for( std::string line = prog.receiveLine(); ! line.empty(); line = prog.receiveLine() )
          str << line;

      prog.close();
      return str;
    }


    struct TraceCADBase
    {
      enum What { CTOR, COPYCTOR, ASSIGN, DTOR, PING };
      std::string _ident;
    };

    inline std::ostream & operator<<( std::ostream & str, TraceCADBase::What obj )
    {
      switch( obj )
        {
        case TraceCADBase::CTOR:     return str << "CTOR";
        case TraceCADBase::COPYCTOR: return str << "COPYCTOR";
        case TraceCADBase::ASSIGN:   return str << "ASSIGN";
        case TraceCADBase::DTOR:     return str << "DTOR";
        case TraceCADBase::PING:     return str << "PING";
        }
      return str;
    }

    template<class _Tp>
      struct TraceCAD : public base::ProvideNumericId<TraceCAD<_Tp>, unsigned long>
                      , public TraceCADBase
      {
        static unsigned long & _totalTraceCAD()
        { static unsigned long _val = 0;
          return _val; }

        TraceCAD()
        { _ident = __PRETTY_FUNCTION__;
          ++_totalTraceCAD();
          traceCAD( CTOR, *this, *this ); }

        TraceCAD( const TraceCAD & rhs )
        { ++_totalTraceCAD();
          traceCAD( COPYCTOR, *this, rhs ); }

        TraceCAD & operator=( const TraceCAD & rhs )
        { traceCAD( ASSIGN, *this, rhs ); return *this; }

        virtual ~TraceCAD()
        { --_totalTraceCAD();
          traceCAD( DTOR, *this, *this ); }

        void _PING() const
        { traceCAD( PING, *this, *this ); }
      };

    template<class _Tp>
      inline std::ostream & operator<<( std::ostream & str, const TraceCAD<_Tp> & obj )
      { return str << "(ID " << obj.numericId() << ", TOTAL " << obj._totalTraceCAD()
                   << ") [" << &obj << "] "; }

    template<class _Tp>
      void traceCAD( TraceCADBase::What what_r,
                     const TraceCAD<_Tp> & self_r,
                     const TraceCAD<_Tp> & rhs_r )
      {
        switch( what_r )
          {
          case TraceCADBase::CTOR:
          case TraceCADBase::PING:
          case TraceCADBase::DTOR:
            _DBG("DEBUG") << what_r << self_r << " (" << self_r._ident << ")" << std::endl;
            break;

          case TraceCADBase::COPYCTOR:
          case TraceCADBase::ASSIGN:
            _DBG("DEBUG") << what_r << self_r << "( " << rhs_r << ")" << " (" << self_r._ident << ")" << std::endl;
            break;
          }
      }


  } // namespace debug
} // namespace zypp
#endif // ZYPP_BASE_DEBUG_H