text: #include <dis6/StartResumePdu.h>
  
  using namespace DIS;
  
  
  StartResumePdu::StartResumePdu() : SimulationManagementFamilyPdu(),
     _realWorldTime(), 
     _simulationTime(), 
     _requestID(0)
  {
      setPduType( 13 );
  }
  
  StartResumePdu::~StartResumePdu()
  {
  }
  
  ClockTime& StartResumePdu::getRealWorldTime() 
  {
      return _realWorldTime;
  }
  
  const ClockTime& StartResumePdu::getRealWorldTime() const
  {
      return _realWorldTime;
  }
  
  void StartResumePdu::setRealWorldTime(const ClockTime &pX)
  {
      _realWorldTime = pX;
  }
  
  ClockTime& StartResumePdu::getSimulationTime() 
  {
      return _simulationTime;
  }
  
  const ClockTime& StartResumePdu::getSimulationTime() const
  {
      return _simulationTime;
  }
  
  void StartResumePdu::setSimulationTime(const ClockTime &pX)
  {
      _simulationTime = pX;
  }
  
  unsigned int StartResumePdu::getRequestID() const
  {
      return _requestID;
  }
  
  void StartResumePdu::setRequestID(unsigned int pX)
  {
      _requestID = pX;
  }
  
  void StartResumePdu::marshal(DataStream& dataStream) const
  {
      SimulationManagementFamilyPdu::marshal(dataStream); // Marshal information in superclass first
      _realWorldTime.marshal(dataStream);
      _simulationTime.marshal(dataStream);
      dataStream << _requestID;
  }
  
  void StartResumePdu::unmarshal(DataStream& dataStream)
  {
      SimulationManagementFamilyPdu::unmarshal(dataStream); // unmarshal information in superclass first
      _realWorldTime.unmarshal(dataStream);
      _simulationTime.unmarshal(dataStream);
      dataStream >> _requestID;
  }
  
  
  bool StartResumePdu::operator ==(const StartResumePdu& rhs) const
   {
       bool ivarsEqual = true;
  
       ivarsEqual = SimulationManagementFamilyPdu::operator==(rhs);
  
       if( ! (_realWorldTime == rhs._realWorldTime) ) ivarsEqual = false;
       if( ! (_simulationTime == rhs._simulationTime) ) ivarsEqual = false;
       if( ! (_requestID == rhs._requestID) ) ivarsEqual = false;
  
      return ivarsEqual;
   }
  
  int StartResumePdu::getMarshalledSize() const
  {
     int marshalSize = 0;
  
     marshalSize = SimulationManagementFamilyPdu::getMarshalledSize();
     marshalSize = marshalSize + _realWorldTime.getMarshalledSize();  // _realWorldTime
     marshalSize = marshalSize + _simulationTime.getMarshalledSize();  // _simulationTime
     marshalSize = marshalSize + 4;  // _requestID
      return marshalSize;
  }
  
  // Copyright (c) 1995-2009 held by the author(s).  All rights reserved.
  // Redistribution and use in source and binary forms, with or without
  // modification, are permitted provided that the following conditions
  //  are met:
  // 
  //  * Redistributions of source code must retain the above copyright
  // notice, this list of conditions and the following disclaimer.
  // * Redistributions in binary form must reproduce the above copyright
  // notice, this list of conditions and the following disclaimer
  // in the documentation and/or other materials provided with the
  // distribution.
  // * Neither the names of the Naval Postgraduate School (NPS)
  //  Modeling Virtual Environments and Simulation (MOVES) Institute
  // (http://www.nps.edu and http://www.MovesInstitute.org)
  // nor the names of its contributors may be used to endorse or
  //  promote products derived from this software without specific
  // prior written permission.
  // 
  // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  // AS IS AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  // FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  // COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  // INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  // BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  // CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  // LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  // ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  // POSSIBILITY OF SUCH DAMAGE.
  