Tools/Debugging/DebugDataTable.h

Go to the documentation of this file.

/*
* @file Tools/Debugging/DebugDataTable.h
* Table for generic handling of debug data
*
*
*/

#ifndef __DebugRegistry_h_
#define __DebugRegistry_h_



class DebugDataTable;
DebugDataTable& getDebugDataTable();


#include "Tools/Streams/InOut.h"
#include <vector>
#include <typeinfo>
#include <string>

#ifdef WIN32
  #pragma warning(disable:4786) 
  #include <typeinfo.h>
  #if _MSC_VER > 1200
    #include <hash_map>
    using stdext::hash_map;
  #else
    #include <map>
    #define hash_map map
    using std::map;
  #endif
#else
  #include <typeinfo>
  //#include <ext/hash_map>
  //using __gnu_cxx::hash_map;
  #include <map>
  #define hash_map std::map
#endif

#ifdef NDEBUG
#define MODIFY( name, object)
// #define MODIFYENUM( name, object, numberOfEnumElements, getNameFunctionPtr)
#else
#define MODIFY( names, object) \
  getDebugDataTable().registerObject( names, object); \
  getDebugDataTable().f( names, object); \
  DEBUG_RESPONSE( "debug data:"names, \
  OUTPUT( idDebugDataResponse, bin, names << typeid( object ).name() << object); \
  );
/*
#define MODIFYENUM( names, object, numberOfEnumElements, getNameFunctionPtr) \
  getStreamHandler().registerEnum( object, numberOfEnumElements, getNameFunctionPtr); \
  getDebugDataTable().registerEnum( names, object); \
  getDebugDataTable().f( names, object); \
  DEBUG_RESPONSE( "debug data:"names, \
  OUTPUT( idDebugDataResponse, bin, names << typeid( object ).name() << (int) object); \
  );
*/
#endif//

class DebugDataHeader
{
  
public:
  enum { write, unchanged } request;
  virtual void changeData(In&)=0;
};
template< class T>
class DebugData : public DebugDataHeader
{
public:
  T data;
  virtual void changeData(In& in)
  {
    in >> data;
  }
};
/*
template< class T>
class EnumDebugData : public DebugDataHeader
{
public:
  T data;
  virtual void changeData(In& in)
  {
    int i;
    in >> i;
    data = (T)i;
  }
};
*/
class DebugDataTable
{
  hash_map< std::string, DebugDataHeader*> table;
public:
  ~DebugDataTable()
  {
    for(hash_map< std::string, DebugDataHeader*>::iterator iter = table.begin(); iter != table.end(); ++iter)
      delete iter->second;
  }

  template< class T>
  void f( const char* name, T& t)
  {
    hash_map< std::string, DebugDataHeader*>::iterator iter = table.find( name);
    if( iter != table.end() && iter->second->request == DebugDataHeader::write)
    {
      DebugData<T>* debugData = dynamic_cast<DebugData<T>*>(iter->second);
      if( debugData != NULL)
        t = debugData->data;
    }
  }

  template< class T>
  void registerObject( const char* name, T& t)
  {
    hash_map< std::string, DebugDataHeader*>::iterator iter = table.find( name);
    if( iter == table.end())
    {
      DebugData<T>* data = new DebugData<T>();
      data->request = DebugDataHeader::unchanged;
      data->data = t;
      table[ name] = data;
    }
  }
  /*
  template< class T>
  void registerEnum( const char* name, T& t)
  {
    hash_map< std::string, DebugDataHeader*>::iterator iter = table.find( name);
    if( iter == table.end())
    {
      EnumDebugData<T>* data = new EnumDebugData<T>();
      data->request = DebugDataHeader::unchanged;
      data->data = t;
      table[ name] = data;
    }
  }
  */
  bool processChangeRequest( In& in)
  {
    char name[100];
    in >> name;
    
    if( strcmp( name, "disable all") == 0)
    {
      for( 
        hash_map< std::string, DebugDataHeader*>::iterator iter = table.begin();
        iter != table.end();
        ++iter
          )
          iter->second->request = DebugDataHeader::unchanged;
    }
    else
    {
      char change;
      in >> change;
      hash_map< std::string, DebugDataHeader*>::iterator iter = table.find( name);
      if( iter != table.end())
      {
        if( change)
        {
          iter->second->request = DebugDataHeader::write;
          iter->second->changeData( in);
        }
        else
          iter->second->request = DebugDataHeader::unchanged;
      }
    }
    return true;

  }
 
};
In& operator>>(In& in, DebugDataTable& debugDataTable);
// global StreamHandler stuff
// global StreamHandler Object
void initDebugDataTable(DebugDataTable* debugDataTablePtr);
DebugDataTable& getDebugDataTable();

#ifndef WIN32
#undef hash_map
#endif
#endif // DebugRegistry

---