#include "packers_i.hh"                  // Include the header definition for
                                         //  the implementation class
#include "Buffer.h"                      // Provide Support for Buffer Class
#include <iostream.h>                    // Provide Support for IO handling 

///////////////////////////////////////
//Function: Packers_i Constructor
//Author: Dean Thompson            
//Created: 3rd August 1996            
//Last Modified: 4th October 1996     
//Description:  This constructor is    
//  responsible for initialising the     
//  server object upon initial load.    
//                                    
//  This routine places the object     
//  into a safe state and allocates    
//  the appropriate memory           
///////////////////////////////////////

Packers_i::Packers_i() : m_aByteStream(2000),
                         m_aString(CORBA::string_alloc(2000))
                                             // Allocate storage space for 2000
                                             //  characters for the internal 
                                             //  string data member and 
                                             //  allocate 2000 bytes to the 
                                             //  byte stream
{
  m_aShort = 0;                      //
  m_aLong = 0;                       //
  m_aUnsignedShort = 0;              //
  m_aUnsignedLong = 0;               //--->  Assigning "safe" values to the
  m_aFloat = 0;                      //               Packers class
  m_aDouble = 0;                     //
  m_aCharacter = 0;                  //
  m_aBoolean = 0;                    //
  m_bFloat = 0;			     //
  m_bDouble = 0;		     //
  m_bShort = 0;			     //
  m_bLong = 0;			     //
}

///////////////////////////////////////
//Function: Packers_i Destructor     
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Description:  This destructor is   
//  responsible for de-allocating any
//  memory which was assigned to the 
//  class during its lifetime or     
//  construction.                    
///////////////////////////////////////

Packers_i::~Packers_i()
{
  CORBA::string_free(m_aString);     // Deallocate memory that was assigned
}

///////////////////////////////////////
//Function: aShort                   
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: CORBA::Short               
//Return Type: (void)                
//Description:  This member function 
//  is responsible for taking a      
//  parameter in and assigning that  
//  data to the internal data member 
//  without validation.              
///////////////////////////////////////

void Packers_i::aShort(CORBA::Short aShort, CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  m_aShort = aShort;
}

///////////////////////////////////////
//Function: aShort                   
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: (none)                     
//Return Type: CORBA::Short          
//Description:  This member function 
//  is responsible for taking the    
//  internal data member and         
//  returning it back to the calling 
//  process.                         
///////////////////////////////////////

CORBA::Short Packers_i::aShort(CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  return m_aShort;
}

///////////////////////////////////////
//Function: aLong                    
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: CORBA::Long                
//Return Type: (void)                
//Description:  This member function 
//  is responsible for taking a      
//  parameter in and assigning that  
//  data to the internal data member 
//  without validation.              
///////////////////////////////////////

void Packers_i::aLong(CORBA::Long aLong, CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  m_aLong = aLong;
}

///////////////////////////////////////
//Function: aLong                    
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: (none)                     
//Return Type: CORBA::Long           
//Description:  This member function 
//  is responsible for taking the    
//  internal data member and         
//  returning it back to the calling 
//  procedure.                       
///////////////////////////////////////

CORBA::Long Packers_i::aLong(CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  return m_aLong;
}

///////////////////////////////////////
//Function: bShort                   
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: CORBA::Short               
//Return Type: (void)                
//Description:  This member function 
//  is responsible for taking a      
//  parameter in and assigning that  
//  data to the internal data member 
//  without validation.              
///////////////////////////////////////

void Packers_i::bShort(CORBA::Short bShort, CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  m_bShort = bShort;
}

///////////////////////////////////////
//Function: bShort                   
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: (none)                     
//Return Type: CORBA::Short          
//Description:  This member function 
//  is responsible for taking the    
//  internal data member and         
//  returning it back to the calling 
//  process.                         
///////////////////////////////////////

CORBA::Short Packers_i::bShort(CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  return m_bShort;
}

///////////////////////////////////////
//Function: bLong                    
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: CORBA::Long                
//Return Type: (void)                
//Description:  This member function 
//  is responsible for taking a      
//  parameter in and assigning that  
//  data to the internal data member 
//  without validation.              
///////////////////////////////////////

void Packers_i::bLong(CORBA::Long bLong, CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  m_bLong = bLong;
}

///////////////////////////////////////
//Function: bLong                    
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: (none)                     
//Return Type: CORBA::Long           
//Description:  This member function 
//  is responsible for taking the    
//  internal data member and         
//  returning it back to the calling 
//  procedure.                       
///////////////////////////////////////

CORBA::Long Packers_i::bLong(CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  return m_bLong;
}


///////////////////////////////////////
//Function: aUnsignedShort           
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996   
//Inputs: CORBA::UShort              
//Return Type: (void)                
//Description:  This member function 
//  is responsible for taking a      
//  parameter in and assigning that  
//  data to the internal data member 
//  without validation.              
///////////////////////////////////////

void Packers_i::aUnsignedShort(CORBA::UShort aUnsignedShort, CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  m_aUnsignedShort = aUnsignedShort;
}

///////////////////////////////////////
//Function: aUnsignedShort           
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: (none)                     
//Return Type: CORBA::UShort         
//Description:  This member function 
//  is responsible for taking the    
//  internal data member and         
//  returning it back to the calling 
//  procedure.                       
///////////////////////////////////////

CORBA::UShort Packers_i::aUnsignedShort(CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  return m_aUnsignedShort;
}

///////////////////////////////////////
//Function: aUnsignedLong            
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: CORBA::ULong               
//Return Type: (void)                
//Description:  This member function 
//  is responsible for taking a      
//  parameter in and assigning that  
//  data to the internal data member 
//  without validation.              
///////////////////////////////////////

void Packers_i::aUnsignedLong(CORBA::ULong aUnsignedLong, CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  m_aUnsignedLong = aUnsignedLong;
}

///////////////////////////////////////
//Function: aUnsignedLong            
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: (none)                     
//Return Type: CORBA::ULong          
//Description:  This member function 
//  is responsible for taking the    
//  internal data member and         
//  returning it back to the calling 
//  procedure.                       
///////////////////////////////////////

CORBA::ULong Packers_i::aUnsignedLong(CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  return m_aUnsignedLong;
}

///////////////////////////////////////
//Function: aFloat                   
//Author: Dean Thompson             
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: CORBA::Float               
//Return Type: (void)                
//Description:  This member function 
//  is responsible for taking a      
//  parameter in and assigning that  
//  data to the internal data member 
//  without validation.              
///////////////////////////////////////

void Packers_i::aFloat(CORBA::Float aFloat, CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  m_aFloat = aFloat;
}

///////////////////////////////////////
//Function: aFloat                   
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: (none)                     
//Return Type: CORBA::Float          
//Description:  This member function 
//  is responsible for taking the    
//  internal data member and         
//  returning it back to the calling 
//  procedure.                       
///////////////////////////////////////

CORBA::Float Packers_i::aFloat(CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  return m_aFloat;
}

///////////////////////////////////////
//Function: aDouble                  
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: CORBA::Double              
//Return Type: (void)                
//Description:  This member function 
//  is responsible for taking a      
//  parameter in and assigning that  
//  data to the internal data member 
//  without validation.              
///////////////////////////////////////

void Packers_i::aDouble(CORBA::Double aDouble, CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  m_aDouble = aDouble;
}

///////////////////////////////////////
//Function: aDouble                  
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: (none)                     
//Return Type: CORBA::Double         
//Description:  This member function 
//  is responsible for taking the    
//  internal data member and         
//  returning it back to the calling 
//  procedure.                       
///////////////////////////////////////

CORBA::Double Packers_i::aDouble(CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  return m_aDouble;
}

///////////////////////////////////////
//Function: bFloat                   
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: CORBA::Float               
//Return Type: (void)                
//Description:  This member function 
//  is responsible for taking a      
//  parameter in and assigning that  
//  data to the internal data member 
//  without validation.              
///////////////////////////////////////

void Packers_i::bFloat(CORBA::Float bFloat, CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  m_bFloat = bFloat;
}

///////////////////////////////////////
//Function: bFloat                   
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: (none)                     
//Return Type: CORBA::Float          
//Description:  This member function 
//  is responsible for taking the    
//  internal data member and         
//  returning it back to the calling 
//  procedure.                       
///////////////////////////////////////

CORBA::Float Packers_i::bFloat(CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  return m_bFloat;
}

///////////////////////////////////////
//Function: bDouble                  
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: CORBA::Double              
//Return Type: (void)                
//Description:  This member function 
//  is responsible for taking a      
//  parameter in and assigning that  
//  data to the internal data member 
//  without validation.              
///////////////////////////////////////

void Packers_i::bDouble(CORBA::Double bDouble, CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  m_bDouble = bDouble;
}

///////////////////////////////////////
//Function: bDouble                  
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: (none)                     
//Return Type: CORBA::Double         
//Description:  This member function
//  is responsible for taking the    
//  internal data member and         
//  returning it back to the calling 
//  procedure.                       
///////////////////////////////////////

CORBA::Double Packers_i::bDouble(CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  return m_bDouble;
}

///////////////////////////////////////
//Function: aCharacter               
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: CORBA::Char                
//Return Type: (void)                
//Description:  This member function 
//  is responsible for taking a     
//  parameter in and assigning that  
//  data to the internal data member 
//  without validation.              
///////////////////////////////////////

void Packers_i::aCharacter(CORBA::Char aCharacter, CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  m_aCharacter = aCharacter;
}

///////////////////////////////////////
//Function: aCharacter               
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: (none)                     
//Return Type: CORBA::Char           
//Description:  This member function 
//  is responsible for taking the    
//  internal data member and         
//  returning it back to the calling 
//  procedure.                       
///////////////////////////////////////

CORBA::Char Packers_i::aCharacter(CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  return m_aCharacter;
}

///////////////////////////////////////
//Function: aBoolean                 
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: CORBA::Boolean             
//Return Type: (void)                
//Description:  This member function 
//  is responsible for taking a      
//  parameter in and assigning that  
//  data to the internal data member 
//  without validation.              
///////////////////////////////////////

void Packers_i::aBoolean(CORBA::Boolean aBoolean, CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  m_aBoolean = aBoolean;
}

///////////////////////////////////////
//Function: aBoolean                 
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: (none)                     
//Return Type: CORBA::Boolean        
//Description:  This member function 
//  is responsible for taking the    
//  internal data member and         
//  returning it back to the calling 
//  procedure.                       
///////////////////////////////////////

CORBA::Boolean Packers_i::aBoolean(CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  return m_aBoolean;
}

///////////////////////////////////////
//Function: aString                  
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: const char *String         
//Return Type: (void)                
//Description:  This member function 
//  is responsible for taking a      
//  parameter in and assigning that  
//  data to the internal data member 
//  without validation.              
///////////////////////////////////////

void Packers_i::aString(const char *aString, CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  CORBA::string_free(m_aString);
  m_aString = CORBA::string_alloc(strlen(aString)+1);
  strcpy(m_aString,aString);
}

///////////////////////////////////////
//Function: aString                  
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: (none)                     
//Return Type: char *                
//Description:  This member function 
//  is responsible for taking the    
//  internal data member and         
//  returning it back to the calling 
//  procedure.                       
///////////////////////////////////////

char *Packers_i::aString(CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  return m_aString;
}

///////////////////////////////////////
//Function: aByteStream              
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: const byteStream&          
//Return Type: (void)                
//Description:  This member function 
//  is responsible for taking a      
//  parameter in and assigning that  
//  data to the internal data member 
//  without validation.              
///////////////////////////////////////

void Packers_i::aByteStream(const byteStream& aByteStream,
			    CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  m_aByteStream = aByteStream;
}

///////////////////////////////////////
//Function: aByteStream              
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: (none)                     
//Return Type: byteStream *          
//Description:  This member function 
//  is responsible for taking the    
//  internal data member and         
//  returning it back to the calling 
//  procedure.                       
///////////////////////////////////////

byteStream *Packers_i::aByteStream(CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  return &m_aByteStream;
}

///////////////////////////////////////
//Function: saveObject (octet)       
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: (none)                     
//Return Type: (void)                
//Description:  This member function 
//  is responsible for taking all the
//  data members located in the class
//  and packing them into a          
//  byteStream which the client      
//  then requests at a later date    
///////////////////////////////////////

void Packers_i::saveObject(CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  int counted = 0;                          // Used to hold the length
                                            //  of the binary bit stream
 
  CORBA::string aBuffer;                    // Temporary string created to
                                            //  hold all the data after it has
                                            //  been marshalled and is
                                            //  awaiting transfer into the 
                                            //  bytestream
 
  Buffer buff;                              // Temporary buffer created to
                                            //  hold all the data while it is 
                                            //  being packed

  buff.pack(m_aShort);                      // Pack the internal short data
                                            //  member into the buffer

  buff.pack(m_aLong);                       // Pack the internal long data
                                            //  member into the buffer

  buff.pack(m_aUnsignedShort);              // Pack the internal unsigned short
                                            //  data member into the buffer

  buff.pack(m_aUnsignedLong);               // Pack the internal unsigned long
                                            //  data member into the buffer

  buff.pack(m_aFloat);                      // Pack the internal float data
                                            //  member into the buffer

  buff.pack(m_aDouble);                     // Pack the internal double data
                                            //  member into the buffer

  buff.pack(m_aCharacter);                  // Pack the internal character data
                                            //  member into the buffer
 
  buff.pack(m_aBoolean);                    // Pack the internal boolean data
                                            //  member into the buffer

  buff.packNonMappedString(m_aString);      // Pack the internal string data
                                            //  member into the buffer

  buff.pack(m_bFloat);			    // Pack the internal float data
					    //  member into the buffer

  buff.pack(m_bDouble);			    // Pack the internal double data
					    //  member into the buffer

  buff.pack(m_bShort);			    // Pack the internal short data
					    //  member into the buffer

  buff.pack(m_bLong);			    // Pack the internal long data
					    //  member into the buffer
  
  counted = buff.calculateSize();              // Calculate the total length of 
                                            // the binary bit stream held in
                                            // the buffer

  try
    {
      aBuffer = CORBA::string_alloc(counted+1);
      // Try and allocate memory space for the buffer to hold the character
      //  representation of the buffer class
    }
  catch(...)                                // Catch any errors that might
                                            //  occur as a result of allocating
                                            // memory
    {
      cout << "Error allocating memory in the function string_alloc" << endl;
    }
  
  buff.constructBuffer(aBuffer);               // Construct a string
                                            //  representation of the "buff"
                                            //  class and place the character
                                            // representation into the aBuffer
  try
    {
      m_aByteStream.length(counted);        // Inform the byteStream of how
                                            //  much data we are going to 
                                            //  store within it 
    }
  catch(...)                                // Catch any errors that might 
                                            //  occur as a result of trying to
                                            //  set the length of the 
                                            //  byteStream
    {
      cout << "Error allocating a length to the byteStream" << endl;
    }
  
  for (int counter=0;counter<counted;counter++)
    m_aByteStream[counter] = (int) aBuffer[counter];
                                            // This routine copies the
                                            //  character representation
                                            //  of the class into the 
                                            //  byteStream
}

///////////////////////////////////////
//Function: restoreObject (octet)    
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: (none)                     
//Return Type: (void)                
//Description:  This member function 
//  is responsible for taking a      
//  byteStream and restoring an      
//  object given the contents        
///////////////////////////////////////

CORBA::UShort Packers_i::restoreObject (byteStream& aBuffer, 
					CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  Buffer buff;                              // Temporary buffer created to
                                            //  hold all the data while it is
                                            //  unpacked
 
  CORBA::string aCharacterStream;           // Temporary string which holds
                                            //  the contents of the incoming
                                            //  buffer after type conversion
  
  aCharacterStream = CORBA::string_alloc(aBuffer.length() + 1);
                                            // Dynamically assign memory to
                                            //  the character stream so that
                                            //  it can contain the contents
                                            //  of the buffer
   
  for (int counter=0;counter < aBuffer[0];counter++)
    aCharacterStream[counter] = (int) aBuffer[counter];

                                            // Convert the byteStream into a
                                            //  a "known" type so that the 
                                            //  other operations can work on 
                                            //  it.  Additionally, this  
                                            //  routine does "type-casting"
                                            //  to integers
  
  m_aString = CORBA::string_alloc(2000);    // Allocate memory to the internal
                                            //  data member 
  
  if (buff.reconstructBuffer(aCharacterStream) == -1)
    return -1;                              // Reconstruct the buffer and
                                            //  return with "-1" if there is
                                            //  an error in the 
                                            //  re-construction  
  
  buff.unpack(m_aShort);                    // Unpack the first element in the
                                            //  buffer and place it into the
                                            //  private data member "m_aShort"
  
  buff.unpack(m_aLong);                     // Unpack the second element in the
                                            //  buffer and place it into the 
                                            //  private data member "m_aLong" 
                                            //  "m_aUnsignedShort"  

  buff.unpack(m_aUnsignedShort);            // Unpack the third element in the
                                            //  buffer and place it into the 
                                            //  private data member
                                            //  "m_aUnsignedShort"

  buff.unpack(m_aUnsignedLong);             // Unpack the fourth element in the
                                            //  buffer and place it into the
                                            //  private data member
                                            //  "m_aUnsignedLong"

  buff.unpack(m_aFloat);                    // Unpack the fifth element in the
                                            //  buffer and place it into the
                                            //  private data member
                                            //  "m_aFloat"

  buff.unpack(m_aDouble);                   // Unpack the sixth element in the
                                            //  buffer and place it into the
                                            //  private data member "m_aDouble"
 
  buff.unpack(m_aCharacter);                // Unpack the seventh element in
                                            //  the buffer and place it into
                                            //  the private data member 
                                            //  "m_aCharacter"
   
  buff.unpack(m_aBoolean);                  // Unpack the eigth element in
                                            //  the buffer and place it into
                                            //  the private data member
                                            //  "m_aBoolean"
 
  buff.unpack(m_aString);                   // Unpack the nineth element in 
                                            //  the buffer and place it into 
                                            //  the private data member 
                                            //  "m_aString"   

  buff.unpack(m_bFloat);		    // Unpack the tenth element in
					    //  the buffer and place it into
					    //  the private data member
					    //  "m_bFloat"

  buff.unpack(m_bDouble);		    // Unpack the eleventh element in
					    //  the buffer and place it into
					    //  the private data member
					    //  "m_bDouble"

  buff.unpack(m_bShort);		    // Unpack the 12 element in the
					    //  buffer and place it into the
					    //  private data member 
					    //  "m_bShort"

  buff.unpack(m_bLong);			    // Unpack the 13 element in the
					    //  buffer and place it into the
					    //  private data member
					    //  "m_bLong"
  return 1;
}

///////////////////////////////////////
//Function: defaultSave (standard)   
//Author: Dean Thompson              
//Created: 3rd August 1996          
//Last Modified: 4th October 1996    
//Inputs: CORBA::Short, CORBA::Long, 
//        CORBA::UShort,CORBA::ULong,
//        CORBA::Float,CORBA::Double,
//        CORBA::Char,,CORBA::Boolean
//        const char *               
//Return Type: (void)                
//Description:  This member function 
//  is responsible for taking in a   
//  series of CORBA types and        
//  assigning them to the individual 
//  internal data members within the 
//  class                            
///////////////////////////////////////

void Packers_i::defaultSave (CORBA::Short aShort, CORBA::Long aLong, 
                             CORBA::UShort aUnsignedShort, 
                             CORBA::ULong aUnsignedLong, 
                             CORBA::Float aFloat, CORBA::Double aDouble, 
                             CORBA::Char aCharacter, CORBA::Boolean aBoolean, 
                             const char * aString, 
                             CORBA::Float bFloat, CORBA::Double bDouble,
                             CORBA::Short bShort, CORBA::Long bLong,
                             CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  m_aShort = aShort;                  // Assign internal data member
  m_aLong = aLong;                    // Assign internal data member
  m_aUnsignedShort = aUnsignedShort;  // Assign internal data member
  m_aUnsignedLong = aUnsignedLong;    // Assign internal data member

  CORBA::string_free(m_aString);      // De-allocate any previous memory
  m_aString = CORBA::string_alloc(strlen(aString)+1);  // Allocate memory
  strcpy(m_aString, aString);         // Assign internal data member

  m_aFloat = aFloat;                  // Assign internal data member
  m_aDouble = aDouble;                // Assign internal data member
  m_aCharacter = aCharacter;          // Assign internal data member
  m_aBoolean = aBoolean;              // Assign internal data member
  m_bFloat = bFloat;		      // Assign internal data member
  m_bDouble = bDouble;		      // Assign internal data member
  m_bShort = bShort; 		      // Assign internal data member
  m_bLong = bLong;		      // Assign internal data member
}

///////////////////////////////////////
//Function: defaultLoad (standard)   
//Author: Dean Thompson              
//Created: 3rd August 1996           
//Last Modified: 4th October 1996    
//Inputs: CORBA::Short, CORBA::Long, 
//        CORBA::UShort,CORBA::ULong,
//  All   CORBA::Float,CORBA::Double,
//  &'s   CORBA::Char,,CORBA::Boolean
//        const char *               
//Return Type: (void)                
//Description:  This member function 
//  is responsible for taking in a   
//  series of CORBA types as         
//  references and assigning the     
//  internal data members of the     
//  class to those references        
///////////////////////////////////////

void Packers_i::defaultLoad (CORBA::Short& aShort, CORBA::Long& aLong, 
                             CORBA::UShort& aUnsignedShort, 
                             CORBA::ULong& aUnsignedLong, 
                             CORBA::Float& aFloat, CORBA::Double& aDouble, 
                             CORBA::Char& aCharacter, 
                             CORBA::Boolean& aBoolean, 
                             char *& aString, 
                             CORBA::Float& bFloat, CORBA::Double& bDouble,
                             CORBA::Short& bShort, CORBA::Long& bLong,
			     CORBA::Environment &IT_env) 
  throw (CORBA::SystemException)
{
  aShort = m_aShort;                 // Assign to external reference from class
  aLong = m_aLong;                   // Assign to external reference from class
  aUnsignedShort = m_aUnsignedShort; // Assign to external reference from class
  aUnsignedLong = m_aUnsignedLong;   // Assign to external reference from class

  CORBA::string_free(aString);       // De-allocate any previous memory
  aString = CORBA::string_alloc(strlen(m_aString)+1); // Allocate memory
  strcpy(aString,m_aString);         // Assign to external reference from class

  aFloat = m_aFloat;                 // Assign to external reference from class
  aDouble = m_aDouble;               // Assign to external reference from class
  aCharacter = m_aCharacter;         // Assign to external reference from class
  aBoolean = m_aBoolean;             // Assign to external reference from class
  bFloat = m_bFloat;
  bDouble = m_bDouble;
  bShort = m_bShort;
  bLong = m_bLong;
  return;
}