Tools/Streams/StreamHandler.cpp

Go to the documentation of this file.

#include "Tools/Streams/StreamHandler.h"

using namespace std;


#include "Tools/Process.h"

void StreamHandler::startRegistration(const char* name, bool registerWithExternalOperator)
{ 
  if(registeringBase)
  {
    currentRegisteringEntryStack.top().second.baseClass = true;
  }
  else
  {
    hash_map<const char*, std::vector<std::pair< std::string, const char*> > >::iterator currentlyRegisteringEntry;
    currentlyRegisteringEntry = specification.find( name);
    if(currentlyRegisteringEntry == specification.end())
    {
       specification[name];
       RegisteringAttributes attr;
       attr.registering = true;
       attr.baseClass = false;
       attr.externalOperator = registerWithExternalOperator;
       std::pair< hash_map<const char*, std::vector<std::pair< std::string, const char*> > >::iterator, RegisteringAttributes> stackEntry(specification.find( name), attr);
       currentRegisteringEntryStack.push( stackEntry);
       registering = true;
    }
    else
    {
      RegisteringAttributes attr;
      attr.registering = false;
       attr.baseClass = false;
       attr.externalOperator = registerWithExternalOperator;
      std::pair< hash_map<const char*, std::vector<std::pair< std::string, const char*> > >::iterator, RegisteringAttributes> stackEntry(currentlyRegisteringEntry, attr);
      currentRegisteringEntryStack.push( stackEntry);
      registering = false;
    }
  }
  registeringBase = false;
}

Out& operator<<(Out& out, const StreamHandler& streamHandler)
{
  // basic types
  out << streamHandler.basicTypeSpecification.size();;
  hash_map<const char*, const char*>::const_iterator basicTypeIter = streamHandler.basicTypeSpecification.begin();
  for ( ; basicTypeIter != streamHandler.basicTypeSpecification.end(); ++basicTypeIter )
  {
    out << basicTypeIter->first;
    out << basicTypeIter->second;
    
  }

  // specification
  out << streamHandler.specification.size();;
  hash_map<const char*, std::vector<std::pair< std::string, const char*> > >::const_iterator specificationIter = streamHandler.specification.begin();
  for ( ; specificationIter != streamHandler.specification.end(); ++specificationIter)
  {
    out << specificationIter->first;
    out << specificationIter->second.size();
    
    std::vector<std::pair< std::string, const char*> >::const_iterator typeNamePairIter = specificationIter->second.begin();
    for(; typeNamePairIter != specificationIter->second.end(); ++ typeNamePairIter)
    {
      out << typeNamePairIter->first.c_str();
      out << typeNamePairIter->second;
    }
  }

  // enum specification
  out << streamHandler.enumSpecification.size();;
  hash_map<const char*, std::vector<const char*> >::const_iterator enumSpecificationIter = streamHandler.enumSpecification.begin();
  for ( ; enumSpecificationIter != streamHandler.enumSpecification.end(); ++enumSpecificationIter)
  {
    out << enumSpecificationIter->first;
    out << enumSpecificationIter->second.size();
    
    std::vector<const char*>::const_iterator enumElementsIter = enumSpecificationIter->second.begin();
    for(; enumElementsIter != enumSpecificationIter->second.end(); ++ enumElementsIter)
    {
      out << *enumElementsIter;
    }
  }
  
  return out;
}

/** references to StreamHandler */
GT_GLOBAL StreamHandler* streamHandler;
void initStreamHandler(StreamHandler* streamHandlerPtr)
{
  streamHandler = streamHandlerPtr;
}

StreamHandler& getStreamHandler()
{
  return *streamHandler;
}

In& operator>>(In& in, bool& inBool)
{
  int temp;
  in >> temp;
  inBool = (temp != 0);
  return in;
}

Out& operator<<(Out& out, bool& outBool)
{
    out << (int)outBool;
    return out;
}

---