Tools/Streams/StreamHandler.h

Go to the documentation of this file.

#ifndef __StreamHandler_h_
#define __StreamHandler_h_

#include "Tools/Streams/InOut.h"
#include "Tools/Streams/Streamable.h"

#ifndef NEWDEBUGGING
#define STREAM_REGISTER_BEGIN_EXT( s)
  
#define STREAM_EXT( stream, s) \
  streamObject( stream ,s);

#define STREAM_ENUMASINT_EXT( stream, s) \
  streamEnum( stream , s);

#define STREAM_ENUM_EXT( stream, s, numberOfEnumElements, getNameFunctionPtr) \
  streamEnum( stream , s);

#define STREAM_BASE_EXT( stream, s) \
  streamObject( stream, s);

#define STREAM_ARRAY_EXT( stream, s) \
  streamStaticArray( stream, s, sizeof(s));

#define STREAM_DYN_ARRAY_EXT( stream, s, count) \
  streamDynamicArray( stream, s, count);

#define STREAM_REGISTER_BEGIN()

#define STREAM_BASE( s) \
  if( in){ \
    if(dynamic_cast< s *>(this)) \
      this-> s ::serialize( in, out); \
    else \
      *in >> (*this); \
  }else{ \
    if(dynamic_cast< s *>(this)) \
      this-> s ::serialize( in, out); \
    else \
      *out << (*this); \
  }
  
#define STREAM( s) \
   if( in){ \
      *in >> s; \
    }else{ \
      *out << s; \
    }

#define STREAM_ENUMASINT( s) \
  if( in){ \
    streamEnum( *in , s);\
  }else{ \
    streamEnum( *out , s);\
  }

#define STREAM_ENUM( s, numberOfEnumElements, getNameFunctionPtr) \
  if( in){ \
    streamEnum( *in , s);\
  }else{ \
    streamEnum( *out , s);\
  }

#define STREAM_ARRAY( s) \
  if(in) \
    streamStaticArray( *in, s, sizeof(s)); \
  else \
    streamStaticArray( *out, s, sizeof(s));

#define STREAM_DYN_ARRAY( s, count) \
  if(in) \
    streamDynamicArray( *in, s, count); \
  else \
    streamDynamicArray( *out, s, count); 

#define STREAM_REGISTER_FINISH()


#else // #ifdef NEWDEBUGGING

#define STREAM_REGISTER_BEGIN_EXT( s) \
  getStreamHandler().startRegistration( typeid(s).name(), true);

#define STREAM_EXT( stream, s) \
  getStreamHandler().registerWithSpecification( #s, s); \
  streamObject( stream ,s);

#define STREAM_ENUMASINT_EXT( stream, s) \
  { int ____xyzstreamhandlertemp; getStreamHandler().registerWithSpecification( #s, ____xyzstreamhandlertemp); }\
  streamEnum( stream , s);

#define STREAM_ENUM_EXT( stream, s, numberOfEnumElements, getNameFunctionPtr) \
  getStreamHandler().registerEnumWithSpecification( #s, s, numberOfEnumElements, getNameFunctionPtr); \
  streamEnum( stream , s);

#define STREAM_BASE_EXT( stream, s) \
  getStreamHandler().registerBase(); \
  streamObject( stream, s);

#define STREAM_ARRAY_EXT( stream, s) \
  getStreamHandler().registerWithSpecification( #s, s); \
  streamStaticArray( stream, s, sizeof(s));

#define STREAM_DYN_ARRAY_EXT( stream, s, count) \
  getStreamHandler().registerDynamicArrayWithSpecification( #s, s); \
  streamDynamicArray( stream, s, count);

#define STREAM_REGISTER_BEGIN() \
  getStreamHandler().startRegistration( typeid(*this).name(), false);

#define STREAM_BASE( s) \
  getStreamHandler().registerBase(); \
  if( in){ \
    if(dynamic_cast< s *>(this)) \
      this-> s ::serialize( in, out); \
    else \
      *in >> (*this); \
  }else{ \
    if(dynamic_cast< s *>(this)) \
      this-> s ::serialize( in, out); \
    else \
      *out << (*this); \
  }
  
#define STREAM( s) \
  getStreamHandler().registerWithSpecification( #s, s); \
    if( in){ \
      *in >> s; \
    }else{ \
      *out << s; \
    }

#define STREAM_ENUMASINT( s) \
  { int ____xyzstreamhandlertemp; getStreamHandler().registerWithSpecification( #s, ____xyzstreamhandlertemp); }\
  if( in){ \
    streamEnum( *in , s);\
  }else{ \
    streamEnum( *out , s);\
  }

#define STREAM_ENUM( s, numberOfEnumElements, getNameFunctionPtr) \
  getStreamHandler().registerEnumWithSpecification( #s, s, numberOfEnumElements, getNameFunctionPtr); \
  if( in){ \
    streamEnum( *in , s);\
  }else{ \
    streamEnum( *out , s);\
  }

#define STREAM_ARRAY( s) \
  getStreamHandler().registerWithSpecification( #s, s); \
  if(in) \
    streamStaticArray( *in, s, sizeof(s)); \
  else \
    streamStaticArray( *out, s, sizeof(s));

#define STREAM_DYN_ARRAY( s, count) \
  getStreamHandler().registerDynamicArrayWithSpecification( #s, s); \
  if(in) \
    streamDynamicArray( *in, s, count); \
  else \
    streamDynamicArray( *out, s, count); 

#define STREAM_REGISTER_FINISH() \
  getStreamHandler().finishRegistration();

#endif // #ifndef NEWDEBUGGING

#include <vector>
#include <stack>
#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;
#endif

  struct RegisteringAttributes{
    bool registering;
    bool baseClass;
    bool externalOperator;
  } ;
class StreamHandler
{
  friend Out& operator<<(Out&, const StreamHandler&);
  hash_map<const char*,const char*> basicTypeSpecification;
  hash_map<const char*, std::vector<std::pair< std::string, const char*> > >specification;

  hash_map<const char*, std::vector<const char*> > enumSpecification;

  std::stack< std::pair< hash_map<const char*, std::vector<std::pair< std::string, const char*> > >::iterator, RegisteringAttributes> > currentRegisteringEntryStack;
   
public:
  bool registering;
  bool registeringBase;
  StreamHandler():registering(false),registeringBase(false)
  {
    basicTypeSpecification[ typeid(double).name()]  = "double";
    basicTypeSpecification[ typeid(bool).name()]  = "bool";
    basicTypeSpecification[ typeid(float).name()]  = "float";
    basicTypeSpecification[ typeid(int).name()]  = "int";
    basicTypeSpecification[ typeid(unsigned int).name()]  = "unsigned int";
    basicTypeSpecification[ typeid(long).name()]  = "long";
    basicTypeSpecification[ typeid(unsigned long).name()]  = "unsigned long";
    basicTypeSpecification[ typeid(char).name()]  = "char";
    basicTypeSpecification[ typeid(unsigned char).name()]  = "unsigned char";
  }

  void startRegistration(const char* name, bool registerWithExternalOperator);
  void registerBase(){ registeringBase=true;}
  void finishRegistration()
  { 
    if( currentRegisteringEntryStack.size() > 0)
    {
      if( !currentRegisteringEntryStack.top().second.baseClass)
        currentRegisteringEntryStack.pop();
      else
        currentRegisteringEntryStack.top().second.baseClass = false;
    }
    if( currentRegisteringEntryStack.size() <= 0)
      registering = false;
    else
      registering = currentRegisteringEntryStack.top().second.registering;
    registeringBase = false;
  }

  template<class T>
  void registerWithSpecification(const char* name, T& t)
  {
    if(registering  == true && currentRegisteringEntryStack.top().second.registering)
    {
      std::string nameString = name;
      if(currentRegisteringEntryStack.top().second.externalOperator)
      {
        nameString.erase( 0, nameString.find(".")+1);
        std::pair< std::string, const char*> names ( nameString, typeid(t).name());
        currentRegisteringEntryStack.top().first->second.push_back(names);

      }
      else
      {
        std::pair< std::string, const char*> names ( name, typeid(t).name());
        currentRegisteringEntryStack.top().first->second.push_back(names);
      }
    }
  }
  template<class T>
  void registerDynamicArrayWithSpecification(const char* name, T& t)
  {
    if(registering  == true && currentRegisteringEntryStack.top().second.registering)
    {
      std::string nameString = name;
      if(currentRegisteringEntryStack.top().second.externalOperator)
      {
        nameString.erase( 0, nameString.find(".")+1);
        std::pair< std::string, const char*> names ( nameString,  typeid(&*t).name());
        currentRegisteringEntryStack.top().first->second.push_back(names);
      }
      else
      {
        std::pair< std::string, const char*> names ( name, typeid(&*t).name());
        currentRegisteringEntryStack.top().first->second.push_back(names);
      }
    }
  }
    
  template<class T>
  void registerEnumWithSpecification(const char* name, const T& t, T numberOfEnumElements, const char* (*fp)(T))
  {
    if(registering  == true && currentRegisteringEntryStack.top().second.registering)
    {
      std::string nameString = name;
      if(currentRegisteringEntryStack.top().second.externalOperator)
      {
        nameString.erase( 0, nameString.find(".")+1);
        std::pair< std::string, const char*> names ( nameString,  typeid(t).name());
        currentRegisteringEntryStack.top().first->second.push_back(names);
      }
      else
      {
        std::pair< std::string, const char*> names ( name, typeid(t).name());
        currentRegisteringEntryStack.top().first->second.push_back(names);
      }
      

      // register enum if necessary
//      hash_map<const char*, std::vector<const char*> >::iterator enumSpecificationEntry;
//      enumSpecificationEntry = enumSpecification.find( typeid(t).name());
      if(enumSpecification.find( typeid(t).name()) == enumSpecification.end())
      {
        enumSpecification[ typeid(t).name()];
        for( int i = 0; i < (int) numberOfEnumElements; ++i)
        {
          enumSpecification[ typeid(t).name()].push_back( (*fp)((T)i));
        }
      }
    }
  }
    
  template<class T>
    void registerEnum( const T& t, T numberOfEnumElements, const char* (*fp)(T))
  {
    if(enumSpecification.find( typeid(t).name()) == enumSpecification.end())
    {
      enumSpecification[ typeid(t).name()];
      for( int i = 0; i < (int) numberOfEnumElements; ++i)
      {
        enumSpecification[ typeid(t).name()].push_back( (*fp)((T)i));
      }
    }
  }
};

// In& operator>>(In& in, StreamHandler& streamHandler);
Out& operator<<(Out& out, const StreamHandler& streamHandler);


In& operator>>(In& in, bool& inBool);
Out& operator<<(Out& out, bool& outBool);

template<class T>
In& streamStaticArray(In& in, T inArray[], int size)
{
  int numberOfEntries = size/sizeof(T);
  for(int i = 0; i < numberOfEntries;++i)
  {
      in >> inArray[i];
  } 
  return in;
}
template<class T>
Out& streamStaticArray(Out& out, T outArray[], int size)
{
  int numberOfEntries = size/sizeof(T);
  for(int i = 0; i < numberOfEntries;++i)
  {
      out << outArray[i];
  }
  return out;
}

template<class T>
In& streamDynamicArray(In& in, T* inArray, int& numberOfEntries)
{
  in >> numberOfEntries;
  for(int i = 0; i < numberOfEntries;++i)
  {
      in >> inArray[i];
  } 
  return in;
}
template<class T>
Out& streamDynamicArray(Out& out, T* outArray, int numberOfEntries)
{
  out << numberOfEntries;
  for(int i = 0; i < numberOfEntries;++i)
  {
      out << outArray[i];
  }
  return out;
}


// global StreamHandler stuff
// global StreamHandler Object
void initStreamHandler(StreamHandler* streamHandlerPtr);
StreamHandler& getStreamHandler();

template<class T>
void streamObject(In& in, T& t)
{
  in >> t;
}
template<class T>
void streamObject(Out& out, T& t)
{
  out << t;
}
template<class T>
void streamEnum(In& in, T& t)
{
  int i;
  in >> i;
  t = (T) i;
}
template<class T>
void streamEnum(Out& out, T& t)
{
  int i = (int) t;
  out << i;
}



#ifdef hash_map
#undef hash_map
#endif
#endif // __StreamHandler_h_

---