---

cluster_pack_unpack.H

Go to the documentation of this file.

// pack_unpack.H

#ifndef PACK_UNPACK_H
#define PACK_UNPACK_H

#include "std/hash.H"
#include "dev/room6d.H"
#include "dev/buttons.H"
#include "dev/dev2d.H"
#include "dev/wall_clock.H"
#include "mlib/transf3d.H"
#include "mlib/points.H"
#include "asciinet/asciinet.H"

enum { END = 0, EVT_ROOM6D, EVT_BTN, EVT_2D, EVT_ASCII, EVT_WALLCLOCKMSG };

int packings = 0;


/*****************************************************************************
 * Function: pack_one_event_into_buffer
 * Params:   A buffer of char to pack into. An int telling us how much space is 
 *           in the buffer. And a ptr to an event that is to be packed.
 * Returns:  The amount of space the new event used. Returns -1 if there wasn't
 *           enough space to pack the event.
 ******************************************************************************/
int 
pack_one_event_into_buffer( char *buf, int bufSize, cEVENTptr &evt )
{
  // Keep track of how much space this event will use
  int eventLen = 0;
  
  /**************************************************************************
   * Room 6D Events
   *   - These have a source name, a current transform, a previous transform,
   *     and a time. 
   **************************************************************************/
  if ( evt->class_name() == "EVENTroom6d" ) {

    // Test to see if there's enough room in the buffer for this event
    eventLen = 1 + 16 * sizeof(Greal) + 16 * sizeof(Greal) + sizeof(double) 
      + strlen(**evt->source()->evt_name()) + 1;
      
    // If there's enough room then serialize the event into the buffer
    if ( eventLen < bufSize ) {
      
      // The first byte is the event type
      buf[0] = EVT_ROOM6D;
      buf++;
      
      // Then the name of the source 
      strcpy( buf, **evt->source()->evt_name() );
      buf += strlen(**evt->source()->evt_name()) + 1;
        
      // Then the current transform of this event
      Wtransf curr_xf = EVENTroom6d::cast( evt )->cur();
      memcpy( buf, (char *)curr_xf.matrix(), 16 * sizeof(Greal) );
      buf += 16 * sizeof(Greal);

      // Then the previous transform of this event
      Wtransf prev_xf = EVENTroom6d::cast( evt )->old();
      memcpy( buf, (char *)prev_xf.matrix(), 16 * sizeof(Greal) );
      buf += 16 * sizeof(Greal);

      // Then the time that the event occurred
      double t = evt->time();
      memcpy( buf, (char *)&t, sizeof(double) );
      buf += sizeof(double);
      
    } 
    // Otherwise, if there isn't enough room, print an error and don't touch the buffer
    else {
    cerr << "Not enough room to pack event: " << evt->source()->evt_name() << endl;
    return -1;
    }
  }
  
  /**************************************************************
   * 2D Events
   *   - These are generated by the various joysticks. They have
   *     a name, a current (x,y), an old (x,y)
   **************************************************************/
  else if ( evt->class_name() == "EVENT2d" ) {
    
    // Test to see if there's enough room in the buffer
    eventLen = 1 + 4*sizeof(double) + strlen(**evt->source()->evt_name()) + 1;
    
    if ( eventLen < bufSize ) {

      // Event type indicator
      buf[0] = EVT_2D;
      buf++;
      
      // The name of the event source
      strcpy( buf, **evt->source()->evt_name() );
      buf += strlen(**evt->source()->evt_name() ) + 1;
      
      // The old (x,y)
      double old_x = EVENT2d::cast( evt )->old()[0];
      memcpy( buf, (char*)&old_x, sizeof(double) );
      buf += sizeof(double);
      double old_y = EVENT2d::cast( evt )->old()[1];
      memcpy( buf, (char*)&old_y, sizeof(double) );
      buf += sizeof(double);

      // The current (x,y)
      double cur_x = EVENT2d::cast( evt )->cur()[0];
      memcpy( buf, (char*)&cur_x, sizeof(double) );
      buf += sizeof(double);
      double cur_y = EVENT2d::cast( evt )->cur()[1];
      memcpy( buf, (char*)&cur_y, sizeof(double) );
      buf += sizeof(double);
    }
    // Otherwise, if there isn't enough room, print an error and don't touch the buffer
    else {
    cerr << "Not enough room to pack event: " << evt->source()->evt_name() << endl;
    return -1;
    }
    
  }
  
  /**************************************************************
   * Button Change Events 
   *   - These have a source name, a boolean state, and a time
   *     NOTE: THE TIME ISN'T USED???
   **************************************************************/
  else if ( evt->class_name() == "EVENTbtn" ) {
      
    // Test to see if there's enough room in the buffer
    eventLen = 1 + sizeof(bool) + sizeof(double) 
      + strlen(**evt->source()->evt_name()) + 1;
    
    if ( eventLen < bufSize ) {      
      // Event type indicator
      buf[0] = EVT_BTN;
      buf++;

      // The name of the event
      strcpy( buf, **evt->source()->evt_name() );
      buf += strlen(**evt->source()->evt_name() ) + 1;
      
      // The boolean indicating button state
      bool buttonState = EVENTbtn::cast( evt )->transition();
      memcpy( buf, (char*)&buttonState, sizeof(bool) );
      buf += sizeof(bool);
      
      // The time that this happened
      double t = evt->time();
      memcpy( buf, (char *)&t, sizeof(double) );
      buf += sizeof(double);
      
    } 
    // Otherwise, if there isn't enough room, print an error and don't touch the buffer
    else {
    cerr << "Not enough room to pack event: " << evt->source()->evt_name() << endl;
    return -1;
    }
  }
  
  /**************************************************************
   * ASCII Events
   *   - These have a message name and that's it.
   **************************************************************/
  else if ( evt->class_name() == "EVENTascii" ) {
    
    // Test to see if there's enough room in the buffer
    eventLen = 1 + strlen( **(EVENTascii::cast(evt)->text()) ) + 1;
    
    if ( eventLen < bufSize ) {
      
      // Event type indicator
      buf[0] = EVT_ASCII;
      buf++;
      
      // The message
      strcpy( buf, **(EVENTascii::cast(evt)->text()) );
      buf +=  strlen( **(EVENTascii::cast(evt)->text()) ) + 1;
      
    }
    // Otherwise, if there isn't enough room, print an error and don't touch the buffer
    else {
    cerr << "Not enough room to pack event: " << evt->source()->evt_name() << endl;
    return -1;
    }
  }

  /********************************************************************************
   * Wall Clock Events
   *   - These are for giving a sync'd time to simulations running on the cluster
   ********************************************************************************/
  else if ( evt->class_name() == "EVENTWallClockmsg" ) {
    
    // Test to see if there's enough room in the buffer
    eventLen = 1 + sizeof(double);
    
    if ( eventLen < bufSize ) {
      
      // Event type indicator
      buf[0] = EVT_WALLCLOCKMSG;
      buf++;
            
      // The time 
      double t = EVENTWallClockmsg::cast(evt)->msg_time();
      memcpy( buf, (char *)&t, sizeof(double) );
      buf += sizeof(double);
    }
    // Otherwise, if there isn't enough room, print an error and don't touch the buffer
    else {
    cerr << "Not enough room to pack event: " << evt->source()->evt_name() << endl;
    return -1;
    }
  }


  /*********************************************************************
   * Unknown Event Types
   *   - Just don't touch the buffer and print an error message
   *********************************************************************/
  else {
      cerr << "*** Tried to pack unknown type: " << evt->class_name() << endl;
  }

  // Finally return the length of the event that we just packed into the buffer
  return eventLen;
}

int unpackings = 0;

void unpack_buffer( char *buf )
{
  char *ptr = buf;


  int evtCount = 0;

  while( 1 ) {
    if (ptr[0] == END)
      break;

    evtCount++;
    
      
    /*****************************************************
     * Room 6d Events
     *****************************************************/
    if ( ptr[0] == EVT_ROOM6D ) {
      ptr++;  // (skip past type byte)

      str_ptr evt_name = ptr;
      ptr += strlen(ptr) + 1;

      EVENTsource *src = new EVENTsource(evt_name);

      Wtransf cur;
      memcpy((char *)cur.matrix(), ptr, 16 * sizeof(Greal));
      ptr += 16 * sizeof(Greal);

      Wtransf old;
      memcpy((char *)old.matrix(), ptr, 16 * sizeof(Greal));
      ptr += 16 * sizeof(Greal);

      double t;
      memcpy((char *)&t, ptr, sizeof(t));
      ptr += sizeof(t);

      EVENTroom6dptr e = new EVENTroom6d(src, old, cur, t);
      EVENTmgr::distrib(e);

    } 
    
    /*****************************************************
     * Button Events
     *****************************************************/
    else if ( ptr[0] == EVT_BTN ) {

      // Skip to the name
      ptr++;  

      // Get the name
      str_ptr evt_name = ptr;
      ptr += strlen(ptr) + 1;

      EVENTsource *src = new EVENTsource(evt_name);
      
      bool buttonTransition;
      memcpy( (char*)&buttonTransition, ptr, sizeof(bool) );

      ptr += sizeof(bool);

      double t;
      memcpy((char *)&t, ptr, sizeof(t));
      ptr += sizeof(t);

      EVENTbtnptr e = new EVENTbtn(src, buttonTransition);//, t);
      EVENTmgr::distrib( e );
    }

    /*****************************************************
     * 2D Events
     *****************************************************/
    else if ( ptr[0] == EVT_2D ) {
      
      // Skip to the name 
      ptr++;

      // Get the name
      str_ptr evt_name = ptr;
      ptr += strlen(ptr) + 1;
      
      // Get the old and current (x,y)
      double coord_array[4];
      memcpy( (char*)coord_array, ptr, 4*sizeof(double) );

      // Make the event and distribute
      EVENT2dptr e = new EVENT2d( evt_name, 
                  XYpt(coord_array[0],coord_array[1]),
                  XYpt(coord_array[2],coord_array[3]) );
      EVENTmgr::distrib( e );
    }

    /*****************************************************
     * ASCII Events
     *****************************************************/
    else if ( ptr[0] == EVT_ASCII ) {
      
      // Skip past the type indicator
      ptr++;
      
      // Get the message
      str_ptr msg = ptr;
      ptr += strlen(ptr) + 1;
      
      // Make the event and distribute
      EVENTasciiptr e = new EVENTascii( msg );
      EVENTmgr::distrib( e );
    } 

    /*****************************************************
     * Wall Clock Events
     *****************************************************/
    else if ( ptr[0] == EVT_WALLCLOCKMSG ) {
      
      // Skip past the type indicator
      ptr++;
      
      // Get the time
      double t;
      memcpy( (char *)&t, ptr, sizeof(double) );
      ptr += sizeof(double);
      
      // Make the event and distribute
      EVENTWallClockmsgptr e = new EVENTWallClockmsg( t );
      EVENTmgr::distrib( e );
    } 



    
    /*****************************************************
     * ERROR Condition... If we end up here, that's bad.
     *****************************************************/
    else {
      cerr << "Event Type: " << ptr[0] << endl;
      cerr << "ERROR! Trying to unpack but got weird value as event type." << endl;
      exit(0);
    }
  }
  
  //cerr << "Unpacked " << evtCount << " for\t" << (++unpackings) << endl;

}

#endif

---