Index: RTIA/ObjectManagement.hh
===================================================================
RCS file: /sources/certi/certi/RTIA/ObjectManagement.hh,v
retrieving revision 3.33
diff -u -r3.33 ObjectManagement.hh
--- RTIA/ObjectManagement.hh	7 Mar 2010 21:30:30 -0000	3.33
+++ RTIA/ObjectManagement.hh	18 Mar 2010 18:31:08 -0000
@@ -72,8 +72,8 @@
                         TypeException &e);
 
     void reflectAttributeValues(ObjectHandle theObjectHandle,
-                                std::vector <AttributeHandle> &attribArray,
-                                std::vector <AttributeValue_t> &valueArray,
+                                const std::vector <AttributeHandle> &attribArray,
+                                const std::vector <AttributeValue_t> &valueArray,
                                 uint16_t attribArraySize,
                                 FederationTime theTime,
                                 const std::string& theTag,
@@ -81,8 +81,8 @@
                                 TypeException &e);
 
    void reflectAttributeValues(ObjectHandle theObjectHandle,
-                                std::vector <AttributeHandle> &attribArray,
-                                std::vector <AttributeValue_t> &valueArray,
+                                const std::vector <AttributeHandle> &attribArray,
+                                const std::vector <AttributeValue_t> &valueArray,
                                 uint16_t attribArraySize,
                                 const std::string& theTag,
                                 TypeException &e);
@@ -107,8 +107,8 @@
                     TypeException &e);
 
     void receiveInteraction(InteractionClassHandle theInteraction,
-                            std::vector <ParameterHandle> &paramArray,
-                            std::vector <ParameterValue_t> &valueArray,
+                            const std::vector <ParameterHandle> &paramArray,
+                            const std::vector <ParameterValue_t> &valueArray,
                             uint16_t paramArraySize,
                             FederationTime theTime,
                             const std::string& theTag,
@@ -116,8 +116,8 @@
                             TypeException &e);
 
     void receiveInteraction(InteractionClassHandle theInteraction,
-                            std::vector <ParameterHandle> &paramArray,
-                            std::vector <ParameterValue_t> &valueArray,
+                            const std::vector <ParameterHandle> &paramArray,
+                            const std::vector <ParameterValue_t> &valueArray,
                             uint16_t paramArraySize,
                             const std::string& theTag,
                             TypeException &e);
@@ -178,7 +178,7 @@
                                       TypeException &e);
 
     void provideAttributeValueUpdate(ObjectHandle theObject,
-                                      std::vector <AttributeHandle> &theAttributes,
+                                      const std::vector <AttributeHandle> &theAttributes,
                                       uint16_t attribArraySize,
                                      TypeException &e);
 
Index: RTIA/ObjectManagement.cc
===================================================================
RCS file: /sources/certi/certi/RTIA/ObjectManagement.cc,v
retrieving revision 3.66
diff -u -r3.66 ObjectManagement.cc
--- RTIA/ObjectManagement.cc	7 Mar 2010 21:30:30 -0000	3.66
+++ RTIA/ObjectManagement.cc	18 Mar 2010 18:31:08 -0000
@@ -46,22 +46,22 @@
 
 const ObjectManagement::TransportTypeList
 ObjectManagement::transportTypeList[] = {
-    { "HLAreliable", RELIABLE },
-    { "HLAbestEffort", BEST_EFFORT }
+		{ "HLAreliable", RELIABLE },
+		{ "HLAbestEffort", BEST_EFFORT }
 };
 
 const ObjectManagement::OrderTypeList
 ObjectManagement::orderTypeList[] = {
-    { "Receive", RECEIVE },
-    { "Timestamp", TIMESTAMP }
+		{ "Receive", RECEIVE },
+		{ "Timestamp", TIMESTAMP }
 };
 
 ObjectManagement::ObjectManagement(Communications *GC,
-                                   FederationManagement *GF,
-                                   RootObject *theRootObj)
-    : comm(GC),
-      fm(GF),
-      rootObject(theRootObj) { }
+		FederationManagement *GF,
+		RootObject *theRootObj)
+: comm(GC),
+  fm(GF),
+  rootObject(theRootObj) { }
 
 ObjectManagement::~ObjectManagement() { }
 
@@ -70,32 +70,32 @@
 //! registerObject
 ObjectHandle
 ObjectManagement::registerObject(ObjectClassHandle the_class,
-                                 const std::string& theObjectName,
-                                 FederationTime,
-                                 FederationTime,
-                                 TypeException & e)
-{
-    NM_Register_Object req;
-
-    req.federate    = fm->federate ;
-    req.federation  = fm->_numero_federation ;
-    req.objectClass = the_class ;
-    req.setLabel(theObjectName);
-
-    comm->sendMessage(&req);
-
-    std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::REGISTER_OBJECT, req.federate));
-
-    e = rep->getException() ;
-
-    if (e == e_NO_EXCEPTION) {
-        rootObject->registerObjectInstance(fm->federate, the_class, rep->object,
-                                           rep->getLabel());
-        return rep->object ;
-    }
-    else {
-        return 0;
-    }
+		const std::string& theObjectName,
+		FederationTime,
+		FederationTime,
+		TypeException & e)
+{
+	NM_Register_Object req;
+
+	req.federate    = fm->federate ;
+	req.federation  = fm->_numero_federation ;
+	req.setObjectClass(the_class);
+	req.setLabel(theObjectName);
+
+	comm->sendMessage(&req);
+
+	std::auto_ptr<NM_Register_Object> rep(static_cast<NM_Register_Object*>(comm->waitMessage(NetworkMessage::REGISTER_OBJECT, req.federate)));
+
+	e = rep->getException() ;
+
+	if (e == e_NO_EXCEPTION) {
+		rootObject->registerObjectInstance(fm->federate, the_class, rep->getObject(),
+				rep->getLabel());
+		return rep->getObject() ;
+	}
+	else {
+		return 0;
+	}
 }
 
 // ----------------------------------------------------------------------------
@@ -108,60 +108,58 @@
     @param theTime time of the federation
     @param theTag user tag (pointer)
     @param e exception address (may be modified)
-*/
+ */
 EventRetractionHandle
 ObjectManagement::updateAttributeValues(ObjectHandle theObjectHandle,
-                                        const std::vector<AttributeHandle> &attribArray,
-                                        const std::vector<AttributeValue_t> &valueArray,
-                                        uint32_t attribArraySize,
-                                        FederationTime theTime,
-                                        const std::string& theTag,
-                                        TypeException &e)
-{
-    NM_Update_Attribute_Values req;
-    bool validCall ;
-    EventRetractionHandle evtrHandle;
-
-    G.Out(pdGendoc,"enter ObjectManagement::updateAttributeValues with time");
-    validCall = tm->testValidTime(theTime) ;
-    if (validCall) {
+		const std::vector<AttributeHandle> &attribArray,
+		const std::vector<AttributeValue_t> &valueArray,
+		uint32_t attribArraySize,
+		FederationTime theTime,
+		const std::string& theTag,
+		TypeException &e)
+{
+	NM_Update_Attribute_Values req;
+	bool validCall ;
+	EventRetractionHandle evtrHandle;
+
+	G.Out(pdGendoc,"enter ObjectManagement::updateAttributeValues with time");
+	validCall = tm->testValidTime(theTime) ;
+	if (validCall) {
 
 		// Building request (req NetworkMessage)
-    	req.federation = fm->_numero_federation ;
-    	req.federate = fm->federate ;
-    	req.object = theObjectHandle ;
-    	// set Date for UAV with time
-    	req.setDate(theTime);
-        req.handleArray.resize(attribArraySize) ;
-    	req.handleArraySize = attribArraySize ;
-        req.sizeValueArray(attribArraySize) ;
-
-        for (uint32_t i = 0 ; i < attribArraySize ; i++) {
-            req.handleArray[i] = attribArray[i] ;
-            req.valueArray[i] = valueArray[i] ;
-        }
-
-    	req.setLabel(theTag);
-
-       	comm->sendMessage(&req);
-    	std::auto_ptr<NetworkMessage> rep(comm->waitMessage(req.getType(), req.federate));
-    	e = rep->getException() ;
-    	evtrHandle = rep->eventRetraction;
-    }
-    else {
-       std::stringstream errorMsg;
-       errorMsg << "UAV InvalidFederationTime: "<<std::endl;
-       errorMsg << " providedTime =" << theTime<<std::endl;
-       errorMsg << " currentTime  =" << tm->requestFederateTime()<<std::endl;
-       errorMsg << " lookahead    =" << tm->requestLookahead()<<std::endl;
-
-       D.Out(pdDebug,errorMsg.str().c_str());
-       e = e_InvalidFederationTime;
-    }
-
-    // FIXME returned evtrHandle carry uninitialized value
-    G.Out(pdGendoc,"exit ObjectManagement::updateAttributeValues with time");
-    return evtrHandle ;
+		req.federation = fm->_numero_federation ;
+		req.federate = fm->federate ;
+		req.setObject(theObjectHandle);
+		// set Date for UAV with time
+		req.setDate(theTime);
+		req.setAttributesSize(attribArraySize);
+		req.setValuesSize(attribArraySize);
+		for (uint32_t i = 0 ; i < attribArraySize ; i++) {
+			req.setAttributes(attribArray[i],i) ;
+			req.setValues(valueArray[i],i) ;
+		}
+
+		req.setLabel(theTag);
+
+		comm->sendMessage(&req);
+		std::auto_ptr<NM_Update_Attribute_Values> rep(static_cast<NM_Update_Attribute_Values*>(comm->waitMessage(req.getType(), req.federate)));
+		e = rep->getException() ;
+		evtrHandle = rep->getEvent();
+	}
+	else {
+		std::stringstream errorMsg;
+		errorMsg << "UAV InvalidFederationTime: "<<std::endl;
+		errorMsg << " providedTime =" << theTime<<std::endl;
+		errorMsg << " currentTime  =" << tm->requestFederateTime()<<std::endl;
+		errorMsg << " lookahead    =" << tm->requestLookahead()<<std::endl;
+
+		D.Out(pdDebug,errorMsg.str().c_str());
+		e = e_InvalidFederationTime;
+	}
+
+	// FIXME returned evtrHandle carry uninitialized value
+	G.Out(pdGendoc,"exit ObjectManagement::updateAttributeValues with time");
+	return evtrHandle ;
 }
 
 // ----------------------------------------------------------------------------
@@ -173,241 +171,238 @@
     @param attribArraySize attribute and value array size
     @param theTag user tag (pointer)
     @param e exception address (may be modified)
-*/
+ */
 void
 ObjectManagement::updateAttributeValues(ObjectHandle theObjectHandle,
-                                        const std::vector<AttributeHandle> &attribArray,
-                                        const std::vector<AttributeValue_t> &valueArray,
-                                        uint32_t attribArraySize,
-                                        const std::string& theTag,
-                                        TypeException &e)
-{
-    NM_Update_Attribute_Values req;
-
-    G.Out(pdGendoc,"enter ObjectManagement::updateAttributeValues without time");
-    // Building request (req NetworkMessage)
-    req.federation = fm->_numero_federation ;
-    req.federate = fm->federate ;
-    req.object = theObjectHandle ;
-    // Do no set Date if without time
-    req.handleArray.resize(attribArraySize) ;
-    req.handleArraySize = attribArraySize ;
-    req.sizeValueArray(attribArraySize) ;
-
-    for (uint32_t i = 0 ; i < attribArraySize ; i++) {
-        req.handleArray[i] = attribArray[i] ;
-        req.valueArray[i] = valueArray[i];
-    }
+		const std::vector<AttributeHandle> &attribArray,
+		const std::vector<AttributeValue_t> &valueArray,
+		uint32_t attribArraySize,
+		const std::string& theTag,
+		TypeException &e)
+{
+	NM_Update_Attribute_Values req;
+
+	G.Out(pdGendoc,"enter ObjectManagement::updateAttributeValues without time");
+	// Building request (req NetworkMessage)
+	req.federation = fm->_numero_federation ;
+	req.federate = fm->federate ;
+	req.setObject(theObjectHandle);
+	// Do no set Date if without time
+	req.setAttributesSize(attribArraySize) ;
+	req.setValuesSize(attribArraySize);
+
+	for (uint32_t i = 0 ; i < attribArraySize ; i++) {
+		req.setAttributes(attribArray[i],i) ;
+		req.setValues(valueArray[i],i);
+	}
 
-    req.setLabel(theTag);
+	req.setLabel(theTag);
 
-    comm->sendMessage(&req);
-    std::auto_ptr<NetworkMessage> rep(comm->waitMessage(req.getType(), req.federate));
+	comm->sendMessage(&req);
+	std::auto_ptr<NetworkMessage> rep(comm->waitMessage(req.getType(), req.federate));
 
-    e = rep->getException() ;
-    G.Out(pdGendoc,"exit  ObjectManagement::updateAttributeValues without time");
+	e = rep->getException() ;
+	G.Out(pdGendoc,"exit  ObjectManagement::updateAttributeValues without time");
 }
 
 // ----------------------------------------------------------------------------
 //! discoverObject.
 void
 ObjectManagement::discoverObject(ObjectHandle the_object,
-                                 ObjectClassHandle the_class,
-                                 const std::string& the_name,
-                                 FederationTime the_time,
-                                 EventRetractionHandle the_event,
-                                 TypeException &)
-{
-    M_Discover_Object_Instance req;
-    EventRetraction  event;
-
-    req.setObject(the_object);
-    req.setObjectClass(the_class);
-    req.setDate(the_time);
-    event.setSN(the_event);
-    req.setEventRetraction(event);
-    req.setObjectName(the_name);
-
-    comm->requestFederateService(&req);
-
-    /* FIXME
-     *
-     * discoverObject tries to auto-registrate a discovered object instance,
-     * if the object is already discovered through a previous invocation of
-     * discoverObject the exceptiobn ObjectAlreadyRegistered is raised.
-     *
-     * This behaviour needs further investigation. 
-     * Is it useful to call registerObjectInstance within a federate service?
-     */
-
-    try {
-      // Adding discovered object in federate internal object list.
-      rootObject->registerObjectInstance(fm->federate, the_class, the_object,
-                                         req.getObjectName());
-    } 
-    catch (ObjectAlreadyRegistered) {
-    }
+		ObjectClassHandle the_class,
+		const std::string& the_name,
+		FederationTime the_time,
+		EventRetractionHandle the_event,
+		TypeException &)
+{
+	M_Discover_Object_Instance req;
+	EventRetraction  event;
+
+	req.setObject(the_object);
+	req.setObjectClass(the_class);
+	req.setDate(the_time);
+	event.setSN(the_event);
+	req.setEventRetraction(event);
+	req.setObjectName(the_name);
+
+	comm->requestFederateService(&req);
+
+	/* FIXME
+	 *
+	 * discoverObject tries to auto-registrate a discovered object instance,
+	 * if the object is already discovered through a previous invocation of
+	 * discoverObject the exceptiobn ObjectAlreadyRegistered is raised.
+	 *
+	 * This behaviour needs further investigation.
+	 * Is it useful to call registerObjectInstance within a federate service?
+	 */
+
+	try {
+		// Adding discovered object in federate internal object list.
+		rootObject->registerObjectInstance(fm->federate, the_class, the_object,
+				req.getObjectName());
+	}
+	catch (ObjectAlreadyRegistered) {
+	}
 }
 
 // ----------------------------------------------------------------------------
 //! reflectAttributeValues with time
 void
 ObjectManagement::reflectAttributeValues(ObjectHandle the_object,
-                                         std::vector <AttributeHandle> &the_attributes,
-                                         std::vector <AttributeValue_t> &the_values,
-                                         uint16_t the_size,
-                                         FederationTime the_time,
-                                         const std::string& the_tag,
-                                         EventRetractionHandle the_event,
-                                         TypeException &)
-{
-    M_Reflect_Attribute_Values req;
-    EventRetraction event;
-
-    G.Out(pdGendoc,"enter ObjectManagement::reflectAttributeValues with time");
-    req.setObject(the_object);
-    req.setDate(the_time);
-    event.setSN(the_event);
-    req.setEventRetraction(event);
-    req.setTag(the_tag);
-
-    req.setValuesSize(the_size);
-    req.setAttributesSize(the_size);
-    for (int i=0; i<the_size;++i) {
-    	req.setValues(the_values[i],i);
-    	req.setAttributes(the_attributes[i],i);
-    }
+		const std::vector <AttributeHandle> &the_attributes,
+		const std::vector <AttributeValue_t> &the_values,
+		uint16_t the_size,
+		FederationTime the_time,
+		const std::string& the_tag,
+		EventRetractionHandle the_event,
+		TypeException &)
+{
+	M_Reflect_Attribute_Values req;
+	EventRetraction event;
+
+	G.Out(pdGendoc,"enter ObjectManagement::reflectAttributeValues with time");
+	req.setObject(the_object);
+	req.setDate(the_time);
+	event.setSN(the_event);
+	req.setEventRetraction(event);
+	req.setTag(the_tag);
+
+	req.setValuesSize(the_size);
+	req.setAttributesSize(the_size);
+	for (int i=0; i<the_size;++i) {
+		req.setValues(the_values[i],i);
+		req.setAttributes(the_attributes[i],i);
+	}
 
-    comm->requestFederateService(&req);
-    G.Out(pdGendoc,"exit  ObjectManagement::reflectAttributeValues with time");
+	comm->requestFederateService(&req);
+	G.Out(pdGendoc,"exit  ObjectManagement::reflectAttributeValues with time");
 }
 
 // ----------------------------------------------------------------------------
 //! reflectAttributeValues without time
 void
 ObjectManagement::reflectAttributeValues(ObjectHandle the_object,
-                                         std::vector <AttributeHandle> &the_attributes,
-                                         std::vector <AttributeValue_t> &the_values,
-                                         uint16_t the_size,
-                                         const std::string& the_tag,
-                                         TypeException &)
-{
-    M_Reflect_Attribute_Values req;
-
-    G.Out(pdGendoc,"enter ObjectManagement::reflectAttributeValues without time");
-    req.setObject(the_object);
-    req.setTag(the_tag);
-
-    req.setValuesSize(the_size);
-    req.setAttributesSize(the_size);
-        for (int i=0; i<the_size;++i) {
-        	req.setValues(the_values[i],i);
-        	req.setAttributes(the_attributes[i],i);
-        }
+		const std::vector <AttributeHandle> &the_attributes,
+		const std::vector <AttributeValue_t> &the_values,
+		uint16_t the_size,
+		const std::string& the_tag,
+		TypeException &)
+{
+	M_Reflect_Attribute_Values req;
+
+	G.Out(pdGendoc,"enter ObjectManagement::reflectAttributeValues without time");
+	req.setObject(the_object);
+	req.setTag(the_tag);
+
+	req.setValuesSize(the_size);
+	req.setAttributesSize(the_size);
+	for (int i=0; i<the_size;++i) {
+		req.setValues(the_values[i],i);
+		req.setAttributes(the_attributes[i],i);
+	}
 
 
-    comm->requestFederateService(&req);
-    G.Out(pdGendoc,"exit  ObjectManagement::reflectAttributeValues without time");
+	comm->requestFederateService(&req);
+	G.Out(pdGendoc,"exit  ObjectManagement::reflectAttributeValues without time");
 }
 
 // ----------------------------------------------------------------------------
 //! sendInteraction with time
 EventRetractionHandle
 ObjectManagement::sendInteraction(InteractionClassHandle theInteraction,
-                                  const std::vector <ParameterHandle> &paramArray,
-                                  const std::vector <ParameterValue_t> &valueArray,
-                                  uint32_t paramArraySize,
-                                  FederationTime theTime,
-                                  const std::string& theTag,
-				  RegionHandle region,
-                                  TypeException &e)
-{
-    NM_Send_Interaction req;
-    bool validCall ;
-    EventRetractionHandle evtrHandle;
-
-    validCall = tm->testValidTime(theTime) ;
-    if (validCall) {
-
-       G.Out(pdGendoc,"ObjectManagement::sendInteraction with time") ;
-       // Local test to know if interaction is correct.
-       rootObject->Interactions->isReady(fm->federate,
-                                         theInteraction,
-                                         paramArray,
-                                         paramArraySize);
-
-       // Building network message (req) to RTIG.
-       req.interactionClass = theInteraction ;
-       // true for UAV with time
-       req.setDate(theTime);
-       req.region = region ;
-       req.federation = fm->_numero_federation ;
-       req.federate = fm->federate ;
-       req.handleArray.resize(paramArraySize) ;
-       req.handleArraySize = paramArraySize ;
-       req.sizeValueArray(paramArraySize) ;
-
-       for (unsigned int i=0 ; i<paramArraySize ; i++) {
-        	req.handleArray[i] = paramArray[i] ;
-                req.valueArray[i] = valueArray[i];
-       }
-
-       req.setLabel(theTag);
-
-       // Send network message and then wait for answer.
-       comm->sendMessage(&req);
-       std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::SEND_INTERACTION, req.federate));
-       e = rep->getException() ;
-       evtrHandle = rep->eventRetraction;
-    }
-    else {
-       e = e_InvalidFederationTime ;
-    }
+		const std::vector <ParameterHandle> &paramArray,
+		const std::vector <ParameterValue_t> &valueArray,
+		uint32_t paramArraySize,
+		FederationTime theTime,
+		const std::string& theTag,
+		RegionHandle region,
+		TypeException &e)
+{
+	NM_Send_Interaction req;
+	bool validCall ;
+	EventRetractionHandle evtrHandle;
+
+	validCall = tm->testValidTime(theTime) ;
+	if (validCall) {
+
+		G.Out(pdGendoc,"ObjectManagement::sendInteraction with time") ;
+		// Local test to know if interaction is correct.
+		rootObject->Interactions->isReady(fm->federate,
+				theInteraction,
+				paramArray,
+				paramArraySize);
+
+		// Building network message (req) to RTIG.
+		req.setInteractionClass(theInteraction);
+		// true for UAV with time
+		req.setDate(theTime);
+		req.setRegion(region);
+		req.federation = fm->_numero_federation ;
+		req.federate = fm->federate ;
+		req.setParametersSize(paramArraySize);
+		req.setValuesSize(paramArraySize);
+
+		for (uint32_t i=0 ; i<paramArraySize ; i++) {
+			req.setParameters(paramArray[i],i) ;
+			req.setValues(valueArray[i],i);
+		}
+
+		req.setLabel(theTag);
+
+		// Send network message and then wait for answer.
+		comm->sendMessage(&req);
+		std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::SEND_INTERACTION, req.federate));
+		e = rep->getException() ;
+		evtrHandle = rep->eventRetraction;
+	}
+	else {
+		e = e_InvalidFederationTime ;
+	}
 
-    // FIXME returned evtrHandle carry uninitialized value
-    return evtrHandle ;
+	// FIXME returned evtrHandle carry uninitialized value
+	return evtrHandle ;
 }
 
 // ----------------------------------------------------------------------------
 //! sendInteraction without time
 void
 ObjectManagement::sendInteraction(InteractionClassHandle theInteraction,
-                                  const std::vector <ParameterHandle> &paramArray,
-                                  const std::vector <ParameterValue_t> &valueArray,
-                                  uint32_t paramArraySize,
-                                  const std::string& theTag,
-				  RegionHandle region,
-                                  TypeException &e)
-{
-    NM_Send_Interaction req;
-    G.Out(pdGendoc,"ObjectManagement::sendInteraction without time");
-    // Local test to know if interaction is correct.
-    rootObject->Interactions->isReady(fm->federate,
-                                      theInteraction,
-                                      paramArray,
-                                      paramArraySize);
-
-    // Building network message (req) to RTIG.
-    req.interactionClass = theInteraction ;
-    req.region     = region ;
-    req.federation = fm->_numero_federation ;
-    req.federate   = fm->federate ;
-    req.handleArray.resize(paramArraySize) ;
-    req.handleArraySize = paramArraySize ;
-    req.sizeValueArray(paramArraySize) ;
-
-    for (unsigned int i=0 ; i<paramArraySize ; i++) {
-        	req.handleArray[i] = paramArray[i] ;
-                req.valueArray[i] = valueArray[i];
-    }
-
-    req.setLabel(theTag);
-
-    // Send network message and then wait for answer.
-    comm->sendMessage(&req);
-    std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::SEND_INTERACTION, req.federate));
+		const std::vector <ParameterHandle> &paramArray,
+		const std::vector <ParameterValue_t> &valueArray,
+		uint32_t paramArraySize,
+		const std::string& theTag,
+		RegionHandle region,
+		TypeException &e)
+{
+	NM_Send_Interaction req;
+	G.Out(pdGendoc,"ObjectManagement::sendInteraction without time");
+	// Local test to know if interaction is correct.
+	rootObject->Interactions->isReady(fm->federate,
+			theInteraction,
+			paramArray,
+			paramArraySize);
+
+	// Building network message (req) to RTIG.
+	req.setInteractionClass(theInteraction);
+	req.setRegion(region);
+	req.federation = fm->_numero_federation ;
+	req.federate   = fm->federate ;
+	req.setParametersSize(paramArraySize) ;
+	req.setValuesSize(paramArraySize) ;
+
+	for (uint32_t i=0 ; i<paramArraySize ; i++) {
+		req.setParameters(paramArray[i],i) ;
+		req.setValues(valueArray[i],i);
+	}
+
+	req.setLabel(theTag);
+
+	// Send network message and then wait for answer.
+	comm->sendMessage(&req);
+	std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::SEND_INTERACTION, req.federate));
 
-    e = rep->getException() ;
+	e = rep->getException() ;
 
 } /* end of sendInteraction */
 
@@ -415,284 +410,281 @@
 //! receiveInteraction with time
 void
 ObjectManagement::receiveInteraction(InteractionClassHandle the_interaction,
-                                     std::vector <ParameterHandle> &the_parameters,
-                                     std::vector <ParameterValue_t> &the_values,
-                                     uint16_t the_size,
-                                     FederationTime the_time,
-                                     const std::string& the_tag,
-                                     EventRetractionHandle the_event,
-                                     TypeException &)
-{
-    M_Receive_Interaction req;
-    EventRetraction  event;
-
-    req.setInteractionClass(the_interaction);
-    req.setDate(the_time);
-    event.setSN(the_event);
-    req.setEventRetraction(event);
-    req.setTag(the_tag);
-    req.setParametersSize(the_size);
-    req.setValuesSize(the_size);
-    for (uint32_t i=0;i<the_size;++i) {
-    	req.setParameters(the_parameters[i],i);
-    	req.setValues(the_values[i],i);
-    }
-    comm->requestFederateService(&req);
+		const std::vector <ParameterHandle> &the_parameters,
+		const std::vector <ParameterValue_t> &the_values,
+		uint16_t the_size,
+		FederationTime the_time,
+		const std::string& the_tag,
+		EventRetractionHandle the_event,
+		TypeException &)
+{
+	M_Receive_Interaction req;
+	EventRetraction  event;
+
+	req.setInteractionClass(the_interaction);
+	req.setDate(the_time);
+	event.setSN(the_event);
+	req.setEventRetraction(event);
+	req.setTag(the_tag);
+	req.setParametersSize(the_size);
+	req.setValuesSize(the_size);
+	for (uint32_t i=0;i<the_size;++i) {
+		req.setParameters(the_parameters[i],i);
+		req.setValues(the_values[i],i);
+	}
+	comm->requestFederateService(&req);
 }
 
 // ----------------------------------------------------------------------------
 //! receiveInteraction without time
 void
 ObjectManagement::receiveInteraction(InteractionClassHandle the_interaction,
-                                     std::vector <ParameterHandle> &the_parameters,
-                                     std::vector <ParameterValue_t> &the_values,
-                                     uint16_t the_size,
-                                     const std::string& the_tag,
-                                     TypeException &)
-{
-    M_Receive_Interaction req;
-
-    req.setInteractionClass(the_interaction);
-    req.setTag(the_tag);
-    req.setParametersSize(the_size);
-    req.setValuesSize(the_size);
-    for (uint32_t i=0;i<the_size;++i) {
-        	req.setParameters(the_parameters[i],i);
-        	req.setValues(the_values[i],i);
-    }
-    comm->requestFederateService(&req);
+		const std::vector <ParameterHandle> &the_parameters,
+		const std::vector <ParameterValue_t> &the_values,
+		uint16_t the_size,
+		const std::string& the_tag,
+		TypeException &)
+{
+	M_Receive_Interaction req;
+
+	req.setInteractionClass(the_interaction);
+	req.setTag(the_tag);
+	req.setParametersSize(the_size);
+	req.setValuesSize(the_size);
+	for (uint32_t i=0;i<the_size;++i) {
+		req.setParameters(the_parameters[i],i);
+		req.setValues(the_values[i],i);
+	}
+	comm->requestFederateService(&req);
 }
 
 // ----------------------------------------------------------------------------
 //! deleteObject with time
 EventRetractionHandle
 ObjectManagement::deleteObject(ObjectHandle theObjectHandle,
-			       FederationTime theTime,
-                               const std::string& theTag,
-                               TypeException &e)
+		FederationTime theTime,
+		const std::string& theTag,
+		TypeException &e)
 {
-    NM_Delete_Object req;
+	NM_Delete_Object req;
 
-    req.object     = theObjectHandle ;
-    req.setDate(theTime);
-    req.federation = fm->_numero_federation ;
-    req.federate   = fm->federate ;
+	req.setObject(theObjectHandle);
+	req.setDate(theTime);
+	req.federation = fm->_numero_federation ;
+	req.federate   = fm->federate ;
 
-    req.setLabel(theTag);
-    comm->sendMessage(&req);
-    std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DELETE_OBJECT, req.federate));
+	req.setLabel(theTag);
+	comm->sendMessage(&req);
+	std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DELETE_OBJECT, req.federate));
 
-    e = rep->getException() ;
+	e = rep->getException() ;
 
-    if (e == e_NO_EXCEPTION) {
-        rootObject->deleteObjectInstance(fm->federate, theObjectHandle, theTag);
-    }
+	if (e == e_NO_EXCEPTION) {
+		rootObject->deleteObjectInstance(fm->federate, theObjectHandle, theTag);
+	}
 
-    return rep->eventRetraction ;
+	return rep->eventRetraction ;
 } /* end deleteObject */
 
 // ----------------------------------------------------------------------------
 //! deleteObject without time
 void
 ObjectManagement::deleteObject(ObjectHandle theObjectHandle,
-                               const std::string& theTag,
-                               TypeException &e)
+		const std::string& theTag,
+		TypeException &e)
 {
-    NM_Delete_Object req;
+	NM_Delete_Object req;
 
-    req.object     = theObjectHandle ;
-    req.federation = fm->_numero_federation ;
-    req.federate   = fm->federate ;
+	req.setObject(theObjectHandle);
+	req.federation = fm->_numero_federation ;
+	req.federate   = fm->federate ;
 
-    req.setLabel(theTag);
-    comm->sendMessage(&req);
-    std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DELETE_OBJECT, req.federate));
+	req.setLabel(theTag);
+	comm->sendMessage(&req);
+	std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DELETE_OBJECT, req.federate));
 
-    e = rep->getException() ;
+	e = rep->getException() ;
 
-    if (e == e_NO_EXCEPTION) {
-        rootObject->deleteObjectInstance(fm->federate, theObjectHandle, theTag);
-    }
+	if (e == e_NO_EXCEPTION) {
+		rootObject->deleteObjectInstance(fm->federate, theObjectHandle, theTag);
+	}
 } /* end of deleteObject */
 
 // ----------------------------------------------------------------------------
 //! removeObject with time
 void
 ObjectManagement::removeObject(ObjectHandle the_object,
-                               FederateHandle the_federate,
-			                   FederationTime theTime,
-                               const std::string& the_tag,
-                               EventRetractionHandle the_event,
-                               TypeException &)
+		FederateHandle the_federate,
+		FederationTime theTime,
+		const std::string& the_tag,
+		EventRetractionHandle the_event,
+		TypeException &)
 
 {
-    M_Remove_Object_Instance req;
-    EventRetraction    event;
+	M_Remove_Object_Instance req;
+	EventRetraction    event;
 
-    req.setObject(the_object);
-    event.setSN(the_event);
-    req.setEventRetraction(event);
-    req.setTag(the_tag);
-    req.setDate(theTime);
+	req.setObject(the_object);
+	event.setSN(the_event);
+	req.setEventRetraction(event);
+	req.setTag(the_tag);
+	req.setDate(theTime);
 
-    comm->requestFederateService(&req);
+	comm->requestFederateService(&req);
 
-    rootObject->deleteObjectInstance(the_federate, the_object, theTime, the_tag);
+	rootObject->deleteObjectInstance(the_federate, the_object, theTime, the_tag);
 }
 
 // ----------------------------------------------------------------------------
 //! removeObject without time
 void
 ObjectManagement::removeObject(ObjectHandle the_object,
-                               FederateHandle the_federate,
-                               const std::string& the_tag,
-                               TypeException &)
+		FederateHandle the_federate,
+		const std::string& the_tag,
+		TypeException &)
 {
-    M_Remove_Object_Instance req;
+	M_Remove_Object_Instance req;
 
-    req.setObject(the_object);
-    req.setTag(the_tag);
+	req.setObject(the_object);
+	req.setTag(the_tag);
 
-    comm->requestFederateService(&req);
+	comm->requestFederateService(&req);
 
-    rootObject->deleteObjectInstance(the_federate, the_object, the_tag);
+	rootObject->deleteObjectInstance(the_federate, the_object, the_tag);
 }
 
 // ----------------------------------------------------------------------------
 //! changeAttributeTransportType
 EventRetractionHandle
 ObjectManagement::changeAttributeTransportType(ObjectHandle theObjectHandle,
-                                               const std::vector <AttributeHandle> &attribArray,
-                                               uint32_t attribArraySize,
-                                               TransportType theType,
-                                               TypeException &e)
+		const std::vector <AttributeHandle> &attribArray,
+		uint32_t attribArraySize,
+		TransportType theType,
+		TypeException &e)
 {
-    NM_Change_Attribute_Transport_Type req;
-    uint32_t i ;
+	NM_Change_Attribute_Transport_Type req;
+	uint32_t i ;
 
-    req.object = theObjectHandle ;
-    req.federation = fm->_numero_federation ;
-    req.federate = fm->federate ;
-    req.transport = theType ;
-    req.handleArray.resize(attribArraySize) ;
+	req.setObject(theObjectHandle);
+	req.federation = fm->_numero_federation ;
+	req.federate = fm->federate ;
+	req.setTransport(theType);
+	req.setAttributesSize(attribArraySize);
 
-    for (i = 0 ; i < attribArraySize ; i++)
-        req.handleArray[i] = attribArray[i] ;
+	for (i = 0 ; i < attribArraySize ; i++)
+		req.setAttributes(attribArray[i],i) ;
 
-    comm->sendMessage(&req);
+	comm->sendMessage(&req);
 
-    std::auto_ptr<NetworkMessage> rep(comm->waitMessage(
-                      NetworkMessage::CHANGE_ATTRIBUTE_TRANSPORT_TYPE,
-                      req.federate));
+	std::auto_ptr<NetworkMessage> rep(comm->waitMessage(
+			NetworkMessage::CHANGE_ATTRIBUTE_TRANSPORT_TYPE,
+			req.federate));
 
-    e = rep->getException() ;
+	e = rep->getException() ;
 
-    return rep->eventRetraction ;
+	return rep->eventRetraction ;
 }
 
 // ----------------------------------------------------------------------------
 //! changeAttributeOrderType
 EventRetractionHandle
 ObjectManagement::changeAttributeOrderType(ObjectHandle theObjectHandle,
-                                           const std::vector <AttributeHandle> &attribArray,
-                                           uint32_t attribArraySize,
-                                           OrderType theType,
-                                           TypeException &e)
+		const std::vector <AttributeHandle> &attribArray,
+		uint32_t attribArraySize,
+		OrderType theType,
+		TypeException &e)
 {
-    NM_Change_Attribute_Order_Type req ;
-    uint32_t i ;
+	NM_Change_Attribute_Order_Type req ;
+	uint32_t i ;
 
-    req.object = theObjectHandle ;
-    req.federation = fm->_numero_federation ;
-    req.federate = fm->federate ;
-    req.order = theType ;
-    req.handleArraySize = attribArraySize ;
-    req.handleArray.resize(attribArraySize) ;
+	req.setObject(theObjectHandle);
+	req.federation = fm->_numero_federation ;
+	req.federate = fm->federate ;
+	req.setOrder(theType);
+	req.setAttributesSize(attribArraySize);
 
-    for (i = 0 ; i < attribArraySize ; i++)
-        req.handleArray[i] = attribArray[i] ;
+	for (i = 0 ; i < attribArraySize ; i++)
+		req.setAttributes(attribArray[i],i) ;
 
+	comm->sendMessage(&req);
 
-    comm->sendMessage(&req);
+	std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::CHANGE_ATTRIBUTE_ORDER_TYPE, req.federate));
 
-    std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::CHANGE_ATTRIBUTE_ORDER_TYPE, req.federate));
+	e = rep->getException() ;
 
-    e = rep->getException() ;
-
-    return rep->eventRetraction ;
+	return rep->eventRetraction ;
 }
 
 // ----------------------------------------------------------------------------
 //! changeInteractionTransportType
 EventRetractionHandle
 ObjectManagement::changeInteractionTransportType(InteractionClassHandle id,
-                                                 TransportType theType,
-                                                 TypeException &e)
+		TransportType theType,
+		TypeException &e)
 {
-    NM_Change_Interaction_Transport_Type req;
+	NM_Change_Interaction_Transport_Type req;
 
-    req.interactionClass = id ;
-    req.federation = fm->_numero_federation ;
-    req.federate = fm->federate ;
-    req.transport = theType ;
+	req.setInteractionClass(id);
+	req.federation = fm->_numero_federation ;
+	req.federate = fm->federate ;
+	req.setTransport(theType);
 
-    comm->sendMessage(&req);
-    std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::CHANGE_INTERACTION_TRANSPORT_TYPE, req.federate));
-    e = rep->getException() ;
+	comm->sendMessage(&req);
+	std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::CHANGE_INTERACTION_TRANSPORT_TYPE, req.federate));
+	e = rep->getException() ;
 
-    return rep->eventRetraction ;
+	return rep->eventRetraction ;
 }
 
 // ----------------------------------------------------------------------------
 //! changeInteractionOrderType
 EventRetractionHandle
 ObjectManagement::changeInteractionOrderType(InteractionClassHandle id,
-                                             OrderType theType,
-                                             TypeException &e)
+		OrderType theType,
+		TypeException &e)
 {
-    NM_Change_Interaction_Order_Type req;
+	NM_Change_Interaction_Order_Type req;
 
-    req.interactionClass = id ;
-    req.federation = fm->_numero_federation ;
-    req.federate = fm->federate ;
-    req.order = theType ;
+	req.setInteractionClass(id);
+	req.federation = fm->_numero_federation ;
+	req.federate = fm->federate ;
+	req.setOrder(theType);
 
-    comm->sendMessage(&req);
+	comm->sendMessage(&req);
 
-    std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::CHANGE_INTERACTION_ORDER_TYPE, req.federate));
+	std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::CHANGE_INTERACTION_ORDER_TYPE, req.federate));
 
-    e = rep->getException() ;
+	e = rep->getException() ;
 
-    return rep->eventRetraction ;
+	return rep->eventRetraction ;
 } /* end of changeInteractionOrderType */
 
 // ----------------------------------------------------------------------------
 //! requestObjectAttributeValueUpdate
 void
 ObjectManagement::requestObjectAttributeValueUpdate(ObjectHandle handle,
-                                                    const std::vector <AttributeHandle> &attribs,
-                                                    uint32_t attribArraySize,
-                                                    TypeException &e)
-{
-    NM_Request_Object_Attribute_Value_Update req;
-
-    G.Out(pdGendoc,"enter ObjectManagement::requestObjectAttributeValueUpdate");
-
-    req.object = handle ;
-    req.federation = fm->_numero_federation ;
-    req.federate = fm->federate ;
-    req.handleArray.resize(attribArraySize) ;
-
-    for (uint32_t i = 0 ; i < attribArraySize ; i++) {
-        req.handleArray[i] = attribs[i] ;
-    }
-
-    req.handleArraySize = attribArraySize ;
-    comm->sendMessage(&req);
-    std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::REQUEST_OBJECT_ATTRIBUTE_VALUE_UPDATE,
-                      req.federate));
-    e = rep->getException() ;
-    G.Out(pdGendoc,"exit  ObjectManagement::requestObjectAttributeValueUpdate");
+		const std::vector <AttributeHandle> &attribs,
+		uint32_t attribArraySize,
+		TypeException &e)
+{
+	NM_Request_Object_Attribute_Value_Update req;
+
+	G.Out(pdGendoc,"enter ObjectManagement::requestObjectAttributeValueUpdate");
+
+	req.setObject(handle);
+	req.federation = fm->_numero_federation ;
+	req.federate = fm->federate ;
+	req.setAttributesSize(attribArraySize);
+
+	for (uint32_t i = 0 ; i < attribArraySize ; i++) {
+		req.setAttributes(attribs[i],i) ;
+	}
+
+	comm->sendMessage(&req);
+	std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::REQUEST_OBJECT_ATTRIBUTE_VALUE_UPDATE,
+			req.federate));
+	e = rep->getException() ;
+	G.Out(pdGendoc,"exit  ObjectManagement::requestObjectAttributeValueUpdate");
 
 } /* end of requestObjectAttributeValueUpdate */
 
@@ -703,22 +695,22 @@
 
 void
 ObjectManagement::provideAttributeValueUpdate(ObjectHandle the_object,
-                                              std::vector <AttributeHandle> &the_attributes,
-                                              uint16_t attribArraySize,
-                                              TypeException &)
-{
-    M_Provide_Attribute_Value_Update req;
-
-    G.Out(pdGendoc,"enter ObjectManagement::provideAttributeValueUpdate");
-    req.setObject(the_object);
-    req.setAttributesSize(attribArraySize);
-
-    for (int i = 0 ; i < attribArraySize ; i++) {
-        req.setAttributes(the_attributes[i],i);
-    }
+		const std::vector <AttributeHandle> &the_attributes,
+		uint16_t attribArraySize,
+		TypeException &)
+{
+	M_Provide_Attribute_Value_Update req;
+
+	G.Out(pdGendoc,"enter ObjectManagement::provideAttributeValueUpdate");
+	req.setObject(the_object);
+	req.setAttributesSize(attribArraySize);
+
+	for (int i = 0 ; i < attribArraySize ; i++) {
+		req.setAttributes(the_attributes[i],i);
+	}
 
-    comm->requestFederateService(&req);
-    G.Out(pdGendoc,"exit  ObjectManagement::provideAttributeValueUpdate");
+	comm->requestFederateService(&req);
+	G.Out(pdGendoc,"exit  ObjectManagement::provideAttributeValueUpdate");
 }
 
 // ------------------
@@ -726,9 +718,9 @@
 // ------------------
 
 void ObjectManagement::retract(EventRetractionHandle /*theHandle*/,
-                               TypeException & /*e*/)
+		TypeException & /*e*/)
 {
-    throw RTIinternalError("ObjectManagement::retract not implemented.");
+	throw RTIinternalError("ObjectManagement::retract not implemented.");
 }
 
 
@@ -738,9 +730,9 @@
 
 void
 ObjectManagement::reflectRetraction(EventRetractionHandle,
-                                    TypeException &)
+		TypeException &)
 {
-    throw RTIinternalError("ObjectManagement::reflectRetraction not implemented.");
+	throw RTIinternalError("ObjectManagement::reflectRetraction not implemented.");
 }
 
 // ----------------------------------------------------------------------------
@@ -748,17 +740,17 @@
 ObjectClassHandle
 ObjectManagement::getObjectClassHandle(const std::string& theName)
 {
-    ObjectClassHandle handle ;
-    G.Out(pdGendoc,"enter ObjectManagement::getObjectClassHandle");
-    try {
-         handle = rootObject->ObjectClasses->getObjectClassHandle(theName);
-         G.Out(pdGendoc,"exit  ObjectManagement::getObjectClassHandle");
-         return handle;
-         }
-    catch (NameNotFound) {
-         G.Out(pdGendoc,"exit  ObjectManagement::getObjectClassHandle on NameNotFound");
-         throw NameNotFound(theName);
-         }
+	ObjectClassHandle handle ;
+	G.Out(pdGendoc,"enter ObjectManagement::getObjectClassHandle");
+	try {
+		handle = rootObject->ObjectClasses->getObjectClassHandle(theName);
+		G.Out(pdGendoc,"exit  ObjectManagement::getObjectClassHandle");
+		return handle;
+	}
+	catch (NameNotFound) {
+		G.Out(pdGendoc,"exit  ObjectManagement::getObjectClassHandle on NameNotFound");
+		throw NameNotFound(theName);
+	}
 }
 
 
@@ -767,7 +759,7 @@
 const std::string&
 ObjectManagement::getObjectClassName(ObjectClassHandle theHandle)
 {
-    return rootObject->ObjectClasses->getObjectClassName(theHandle);
+	return rootObject->ObjectClasses->getObjectClassName(theHandle);
 }
 
 // ----------------------------------------------------------------------------
@@ -775,7 +767,7 @@
 ObjectHandle
 ObjectManagement::getObjectInstanceHandle(const std::string& the_name)
 {
-    return rootObject->objects->getObjectInstanceHandle(the_name);
+	return rootObject->objects->getObjectInstanceHandle(the_name);
 }
 
 // ----------------------------------------------------------------------------
@@ -783,37 +775,37 @@
 const std::string&
 ObjectManagement::getObjectInstanceName(ObjectHandle the_object)
 {
-    return rootObject->objects->getObjectInstanceName(the_object);
+	return rootObject->objects->getObjectInstanceName(the_object);
 }
 
 // ----------------------------------------------------------------------------
 //! getAttributeHandle.
 AttributeHandle
 ObjectManagement::getAttributeHandle(const std::string& theName,
-                                     ObjectClassHandle theClassHandle)
+		ObjectClassHandle theClassHandle)
 {
-    AttributeHandle handle ;
-    G.Out(pdGendoc,"enter ObjectManagement::getAttributeHandle");
-    try {
-        handle = rootObject->ObjectClasses->getAttributeHandle(theName,
-                                                         theClassHandle);
-        G.Out(pdGendoc,"exit  ObjectManagement::getAttributeHandle");
-        return handle;
-        }
-     catch (NameNotFound) {
-         G.Out(pdGendoc,"exit  ObjectManagement::getAttributeHandle on NameNotFound");
-         throw NameNotFound(theName);
-        }
+	AttributeHandle handle ;
+	G.Out(pdGendoc,"enter ObjectManagement::getAttributeHandle");
+	try {
+		handle = rootObject->ObjectClasses->getAttributeHandle(theName,
+				theClassHandle);
+		G.Out(pdGendoc,"exit  ObjectManagement::getAttributeHandle");
+		return handle;
+	}
+	catch (NameNotFound) {
+		G.Out(pdGendoc,"exit  ObjectManagement::getAttributeHandle on NameNotFound");
+		throw NameNotFound(theName);
+	}
 }
 
 // ----------------------------------------------------------------------------
 //! getAttributeName.
 const std::string&
 ObjectManagement::getAttributeName(AttributeHandle theHandle,
-                                   ObjectClassHandle theClassHandle)
+		ObjectClassHandle theClassHandle)
 {
-    return rootObject->ObjectClasses->getAttributeName(theHandle,
-                                                       theClassHandle);
+	return rootObject->ObjectClasses->getAttributeName(theHandle,
+			theClassHandle);
 }
 
 // ----------------------------------------------------------------------------
@@ -821,7 +813,7 @@
 InteractionClassHandle
 ObjectManagement::getInteractionClassHandle(const std::string& theName)
 {
-    return rootObject->Interactions->getInteractionClassHandle(theName);
+	return rootObject->Interactions->getInteractionClassHandle(theName);
 }
 
 // ----------------------------------------------------------------------------
@@ -830,28 +822,28 @@
 ObjectManagement::
 getInteractionClassName(InteractionClassHandle theClassHandle)
 {
-    return
-        rootObject->Interactions->getInteractionClassName(theClassHandle);
+	return
+	rootObject->Interactions->getInteractionClassName(theClassHandle);
 }
 
 // ----------------------------------------------------------------------------
 //! getParameterHandle.
 ParameterHandle
 ObjectManagement::getParameterHandle(const std::string& theParameterName,
-                                     InteractionClassHandle theClassHandle)
+		InteractionClassHandle theClassHandle)
 {
-    return rootObject->Interactions->getParameterHandle(theParameterName,
-                                                        theClassHandle);
+	return rootObject->Interactions->getParameterHandle(theParameterName,
+			theClassHandle);
 }
 
 // ----------------------------------------------------------------------------
 //! getParameterName.
 const std::string&
 ObjectManagement::getParameterName(ParameterHandle theParameterHandle,
-                                   InteractionClassHandle theClassHandle)
+		InteractionClassHandle theClassHandle)
 {
-    return rootObject->Interactions->getParameterName(theParameterHandle,
-                                                      theClassHandle);
+	return rootObject->Interactions->getParameterName(theParameterHandle,
+			theClassHandle);
 }
 
 // ----------------------------------------------------------------------------
@@ -859,7 +851,7 @@
 ObjectClassHandle
 ObjectManagement::getObjectClass(ObjectHandle object)
 {
-    return rootObject->objects->getObjectClass(object);
+	return rootObject->objects->getObjectClass(object);
 }
 
 // ----------------------------------------------------------------------------
@@ -867,12 +859,12 @@
 TransportType
 ObjectManagement::getTransportationHandle(const std::string& theName)
 {
-    for(unsigned i = 0; i < sizeof(transportTypeList)/sizeof(transportTypeList[0]); ++i) {
-        if(theName == transportTypeList[i].name)
-            return transportTypeList[i].type;
-    }
+	for(unsigned i = 0; i < sizeof(transportTypeList)/sizeof(transportTypeList[0]); ++i) {
+		if(theName == transportTypeList[i].name)
+			return transportTypeList[i].type;
+	}
 
-    throw NameNotFound(theName);
+	throw NameNotFound(theName);
 }
 
 // ----------------------------------------------------------------------------
@@ -880,12 +872,12 @@
 const std::string&
 ObjectManagement::getTransportationName(TransportType theType)
 {
-    for(unsigned i = 0; i < sizeof(transportTypeList)/sizeof(transportTypeList[0]); ++i) {
-        if(theType == transportTypeList[i].type)
-            return transportTypeList[i].name;
-    }
+	for(unsigned i = 0; i < sizeof(transportTypeList)/sizeof(transportTypeList[0]); ++i) {
+		if(theType == transportTypeList[i].type)
+			return transportTypeList[i].name;
+	}
 
-    throw InvalidTransportationHandle("");
+	throw InvalidTransportationHandle("");
 }
 
 // ----------------------------------------------------------------------------
@@ -893,12 +885,12 @@
 OrderType
 ObjectManagement::getOrderingHandle(const std::string& theName)
 {
-    for(unsigned i = 0; i < sizeof(orderTypeList)/sizeof(orderTypeList[0]); ++i) {
-        if(theName == orderTypeList[i].name)
-            return orderTypeList[i].type;
-    }
+	for(unsigned i = 0; i < sizeof(orderTypeList)/sizeof(orderTypeList[0]); ++i) {
+		if(theName == orderTypeList[i].name)
+			return orderTypeList[i].type;
+	}
 
-    throw NameNotFound(theName);
+	throw NameNotFound(theName);
 }
 
 // ----------------------------------------------------------------------------
@@ -906,36 +898,36 @@
 const std::string&
 ObjectManagement::getOrderingName(OrderType theType)
 {
-    for(unsigned i = 0; i < sizeof(orderTypeList)/sizeof(orderTypeList[0]); ++i) {
-        if(theType == orderTypeList[i].type)
-            return orderTypeList[i].name;
-    }
+	for(unsigned i = 0; i < sizeof(orderTypeList)/sizeof(orderTypeList[0]); ++i) {
+		if(theType == orderTypeList[i].type)
+			return orderTypeList[i].name;
+	}
 
-    throw InvalidOrderingHandle("");
+	throw InvalidOrderingHandle("");
 }
 
 void
 ObjectManagement::
 setAttributeScopeAdvisorySwitch(bool state, TypeException &e) {
-    G.Out(pdGendoc,"enter ObjectManagement::setAttributeScopeAdvisorySwitch");
+	G.Out(pdGendoc,"enter ObjectManagement::setAttributeScopeAdvisorySwitch");
 
-    NM_Set_Attribute_Scope_Advisory_Switch msg ;
+	NM_Set_Attribute_Scope_Advisory_Switch msg ;
 
-    e = e_NO_EXCEPTION ;
+	e = e_NO_EXCEPTION ;
 
-    msg.federation = fm->_numero_federation ;
-    msg.federate = fm->federate ;
+	msg.federation = fm->_numero_federation ;
+	msg.federate = fm->federate ;
 
-    if (state) {
-        msg.attributeScopeAdvisorySwitchOn();
-    }
-    else {
-        msg.attributeScopeAdvisorySwitchOff();
-    }
+	if (state) {
+		msg.attributeScopeAdvisorySwitchOn();
+	}
+	else {
+		msg.attributeScopeAdvisorySwitchOff();
+	}
 
-    comm->sendMessage(&msg);
+	comm->sendMessage(&msg);
 
-    G.Out(pdGendoc,"exit ObjectManagement::setAttributeScopeAdvisorySwitch");
+	G.Out(pdGendoc,"exit ObjectManagement::setAttributeScopeAdvisorySwitch");
 }
 
 // --------------------------------------
@@ -944,23 +936,23 @@
 void
 ObjectManagement::
 attributesInScope(ObjectHandle theObject,
-                  const std::vector <AttributeHandle> &attribArray,
-                  const uint16_t attribArraySize,
-                  TypeException &e) {
+		const std::vector <AttributeHandle> &attribArray,
+		const uint16_t attribArraySize,
+		TypeException &e) {
 
-    M_Attributes_In_Scope req;
+	M_Attributes_In_Scope req;
 
-    G.Out(pdGendoc,"enter ObjectManagement::attributesInScope");
+	G.Out(pdGendoc,"enter ObjectManagement::attributesInScope");
 
-    req.setObject(theObject);
-    req.setAttributesSize(attribArraySize);
+	req.setObject(theObject);
+	req.setAttributesSize(attribArraySize);
 
-    for (int i = 0 ; i < attribArraySize ; i++)
-        req.setAttributes(attribArray[i],i);
+	for (int i = 0 ; i < attribArraySize ; i++)
+		req.setAttributes(attribArray[i],i);
 
-    comm->requestFederateService(&req);
+	comm->requestFederateService(&req);
 
-    G.Out(pdGendoc,"exit  ObjectManagement::attributesInScope");
+	G.Out(pdGendoc,"exit  ObjectManagement::attributesInScope");
 }
 
 // --------------------------------------
@@ -970,47 +962,47 @@
 void
 ObjectManagement::
 attributesOutOfScope(ObjectHandle theObject,
-                     const std::vector <AttributeHandle> &attribArray,
-                     const uint16_t attribArraySize,
-                     TypeException &e) {
+		const std::vector <AttributeHandle> &attribArray,
+		const uint16_t attribArraySize,
+		TypeException &e) {
 
-    M_Attributes_Out_Of_Scope req;
+	M_Attributes_Out_Of_Scope req;
 
-    G.Out(pdGendoc,"enter ObjectManagement::attributesOutScope");
+	G.Out(pdGendoc,"enter ObjectManagement::attributesOutScope");
 
-    req.setObject(theObject);
-    req.setAttributesSize(attribArraySize);
+	req.setObject(theObject);
+	req.setAttributesSize(attribArraySize);
 
-    for (int i = 0 ; i < attribArraySize ; i++)
-        req.setAttributes(attribArray[i],i);
+	for (int i = 0 ; i < attribArraySize ; i++)
+		req.setAttributes(attribArray[i],i);
 
-    comm->requestFederateService(&req);
+	comm->requestFederateService(&req);
 
-    G.Out(pdGendoc,"exit  ObjectManagement::attributesOutScope");
+	G.Out(pdGendoc,"exit  ObjectManagement::attributesOutScope");
 }
 
 void
 ObjectManagement::
 setAttributeRelevanceAdvisorySwitch(bool state, TypeException &e) {
-    G.Out(pdGendoc,"enter ObjectManagement::setAttributeRelevanceAdvisorySwitch");
+	G.Out(pdGendoc,"enter ObjectManagement::setAttributeRelevanceAdvisorySwitch");
 
-    NM_Set_Attribute_Relevance_Advisory_Switch msg ;
+	NM_Set_Attribute_Relevance_Advisory_Switch msg ;
 
-    e = e_NO_EXCEPTION ;
+	e = e_NO_EXCEPTION ;
 
-    msg.federation = fm->_numero_federation ;
-    msg.federate = fm->federate ;
+	msg.federation = fm->_numero_federation ;
+	msg.federate = fm->federate ;
 
-    if (state) {
-        msg.attributeRelevanceAdvisorySwitchOn();
-    }
-    else {
-        msg.attributeRelevanceAdvisorySwitchOff();
-    }
+	if (state) {
+		msg.attributeRelevanceAdvisorySwitchOn();
+	}
+	else {
+		msg.attributeRelevanceAdvisorySwitchOff();
+	}
 
-    comm->sendMessage(&msg);
+	comm->sendMessage(&msg);
 
-    G.Out(pdGendoc,"exit ObjectManagement::setAttributeRelevanceAdvisorySwitch");
+	G.Out(pdGendoc,"exit ObjectManagement::setAttributeRelevanceAdvisorySwitch");
 }
 
 // --------------------------------------
@@ -1020,23 +1012,23 @@
 void
 ObjectManagement::
 turnUpdatesOnForObjectInstance(ObjectHandle theObject,
-                           const std::vector <AttributeHandle> &attribArray,
-                           const uint16_t attribArraySize,
-                           TypeException &e) {
+		const std::vector <AttributeHandle> &attribArray,
+		const uint16_t attribArraySize,
+		TypeException &e) {
 
-    M_Turn_Updates_On_For_Object_Instance req;
+	M_Turn_Updates_On_For_Object_Instance req;
 
-    G.Out(pdGendoc,"enter ObjectManagement::turnUpdatesOnForObjectInstance");
+	G.Out(pdGendoc,"enter ObjectManagement::turnUpdatesOnForObjectInstance");
 
-    req.setObject(theObject);
-    req.setAttributesSize(attribArraySize);
+	req.setObject(theObject);
+	req.setAttributesSize(attribArraySize);
 
-    for (int i = 0 ; i < attribArraySize ; i++)
-        req.setAttributes(attribArray[i],i);
+	for (int i = 0 ; i < attribArraySize ; i++)
+		req.setAttributes(attribArray[i],i);
 
-    comm->requestFederateService(&req);
+	comm->requestFederateService(&req);
 
-    G.Out(pdGendoc,"exit  ObjectManagement::turnUpdatesOnForObjectInstance");
+	G.Out(pdGendoc,"exit  ObjectManagement::turnUpdatesOnForObjectInstance");
 }
 
 // --------------------------------------
@@ -1046,23 +1038,23 @@
 void
 ObjectManagement::
 turnUpdatesOffForObjectInstance(ObjectHandle theObject,
-                         const std::vector <AttributeHandle> &attribArray,
-                         const uint16_t attribArraySize,
-                         TypeException &e) {
+		const std::vector <AttributeHandle> &attribArray,
+		const uint16_t attribArraySize,
+		TypeException &e) {
 
-    M_Turn_Updates_Off_For_Object_Instance req;
+	M_Turn_Updates_Off_For_Object_Instance req;
 
-    G.Out(pdGendoc,"enter ObjectManagement::turnUpdatesOffForObjectInstance");
+	G.Out(pdGendoc,"enter ObjectManagement::turnUpdatesOffForObjectInstance");
 
-    req.setObject(theObject);
-    req.setAttributesSize(attribArraySize);
+	req.setObject(theObject);
+	req.setAttributesSize(attribArraySize);
 
-    for (int i = 0 ; i < attribArraySize ; i++)
-        req.setAttributes(attribArray[i],i);
+	for (int i = 0 ; i < attribArraySize ; i++)
+		req.setAttributes(attribArray[i],i);
 
-    comm->requestFederateService(&req);
+	comm->requestFederateService(&req);
 
-    G.Out(pdGendoc,"exit  ObjectManagement::turnUpdatesOffForObjectInstance");
+	G.Out(pdGendoc,"exit  ObjectManagement::turnUpdatesOffForObjectInstance");
 }
 
 }} // namespace certi/rtia
Index: RTIA/TimeManagement.cc
===================================================================
RCS file: /sources/certi/certi/RTIA/TimeManagement.cc,v
retrieving revision 3.55
diff -u -r3.55 TimeManagement.cc
--- RTIA/TimeManagement.cc	14 Mar 2010 14:38:27 -0000	3.55
+++ RTIA/TimeManagement.cc	18 Mar 2010 18:31:08 -0000
@@ -165,8 +165,9 @@
 
       case NetworkMessage::DISCOVER_OBJECT:
         try {
-            om->discoverObject(msg.object,
-                               msg.objectClass,
+        	NM_Discover_Object& DO=static_cast<NM_Discover_Object&>(msg);
+            om->discoverObject(DO.getObject(),
+                               DO.getObjectClass(),
                                msg.getLabel(),
                                msg.getDate(),
                                msg.eventRetraction,
@@ -181,20 +182,21 @@
 
       case NetworkMessage::REFLECT_ATTRIBUTE_VALUES:
       {
+    	  NM_Reflect_Attribute_Values& RAV = static_cast<NM_Reflect_Attribute_Values&>(msg);
           if (msg.isDated())
-             om->reflectAttributeValues(msg.object,
-                                        msg.handleArray,
-                                        msg.valueArray,
-                                        msg.handleArraySize,
+             om->reflectAttributeValues(RAV.getObject(),
+                                        RAV.getAttributes(),
+                                        RAV.getValues(),
+                                        RAV.getAttributesSize(),
                                         msg.getDate(),
                                         msg.getLabel(),
                                         msg.eventRetraction,
                                         msg.getRefException());
           else
-            om->reflectAttributeValues(msg.object,
-                                        msg.handleArray,
-                                        msg.valueArray,
-                                        msg.handleArraySize,
+            om->reflectAttributeValues(RAV.getObject(),
+                                        RAV.getAttributes(),
+                                        RAV.getValues(),
+                                        RAV.getAttributesSize(),
                                         msg.getLabel(),
                                         msg.getRefException());
           break ;
@@ -202,9 +204,10 @@
 
       case NetworkMessage::PROVIDE_ATTRIBUTE_VALUE_UPDATE:
       {
-      om->provideAttributeValueUpdate(msg.object,
-                                      msg.handleArray,
-                                      msg.handleArraySize,
+      NM_Provide_Attribute_Value_Update& PAVU = static_cast<NM_Provide_Attribute_Value_Update&>	(msg);
+      om->provideAttributeValueUpdate(PAVU.getObject(),
+                                      PAVU.getAttributes(),
+                                      PAVU.getAttributesSize(),
                                       msg.getRefException());
       break;
       }
@@ -212,29 +215,31 @@
 
       case NetworkMessage::RECEIVE_INTERACTION:
       {
+    	  NM_Receive_Interaction& RI = static_cast<NM_Receive_Interaction&>(msg);
           if (msg.isDated())
-              om->receiveInteraction(msg.interactionClass,
-                                     msg.handleArray,
-                                     msg.valueArray,
-                                     msg.handleArraySize,
+              om->receiveInteraction(RI.getInteractionClass(),
+                                     RI.getParameters(),
+                                     RI.getValues(),
+                                     RI.getParametersSize(),
                                      msg.getDate(),
                                      msg.getLabel(),
                                      msg.eventRetraction,
                                      msg.getRefException());
           else
-              om->receiveInteraction(msg.interactionClass,
-                                     msg.handleArray,
-                                     msg.valueArray,
-                                     msg.handleArraySize,
+              om->receiveInteraction(RI.getInteractionClass(),
+                                     RI.getParameters(),
+                                     RI.getValues(),
+                                     RI.getParametersSize(),
                                      msg.getLabel(),
                                      msg.getRefException());
 
           break ;
       }
 
-      case NetworkMessage::REMOVE_OBJECT:
+      case NetworkMessage::REMOVE_OBJECT: {
+    	  NM_Remove_Object& RO=static_cast<NM_Remove_Object&>(msg);
           if (msg.isDated()) {
-        	om->removeObject(msg.object,
+        	om->removeObject(RO.getObject(),
                 		     msg.federate,
 				             msg.getDate(),
                          	 msg.getLabel(),
@@ -242,35 +247,40 @@
                          	 msg.getRefException());
 	  }
 	  else {
-        	om->removeObject(msg.object,
+        	om->removeObject(RO.getObject(),
                 		     msg.federate,
                          	 msg.getLabel(),
                          	 msg.getRefException());
 	  }
+      }
         break ;
 
-      case NetworkMessage::INFORM_ATTRIBUTE_OWNERSHIP:
-
+      case NetworkMessage::INFORM_ATTRIBUTE_OWNERSHIP: {
+    	 NM_Inform_Attribute_Ownership& IAO = static_cast<NM_Inform_Attribute_Ownership&>(msg);
         D.Out(pdInit, "m_REFLECT_ATTRIBUTE_VALUES Owner %u", msg.federate);
 
-        owm->informAttributeOwnership(msg.object,
-                                      msg.handleArray[0],
+        owm->informAttributeOwnership(IAO.getObject(),
+                                      IAO.getAttribute(),
                                       msg.federate,
                                       msg.getRefException());
+      }
         break ;
 
-      case NetworkMessage::ATTRIBUTE_IS_NOT_OWNED:
-        owm->attributeIsNotOwned(msg.object,
-                                 msg.handleArray[0],
+      case NetworkMessage::ATTRIBUTE_IS_NOT_OWNED: {
+    	  NM_Attribute_Is_Not_Owned& AINO = static_cast<NM_Attribute_Is_Not_Owned&>(msg);
+        owm->attributeIsNotOwned(AINO.getObject(),
+                                 AINO.getAttribute(),
                                  msg.federate,
                                  msg.getRefException());
+      }
         break ;
 
       case NetworkMessage::REQUEST_ATTRIBUTE_OWNERSHIP_ASSUMPTION:
           {
-        owm->requestAttributeOwnershipAssumption(msg.object,
-                                                 msg.handleArray,
-                                                 msg.handleArraySize,
+        NM_Request_Attribute_Ownership_Assumption& RAOA=static_cast<NM_Request_Attribute_Ownership_Assumption&>(msg);
+        owm->requestAttributeOwnershipAssumption(RAOA.getObject(),
+                                                 RAOA.getAttributes(),
+                                                 RAOA.getAttributesSize(),
                                                  msg.federate,
                                                  msg.getLabel(),
                                                  msg.getRefException());
@@ -279,9 +289,10 @@
 
       case NetworkMessage::ATTRIBUTE_OWNERSHIP_UNAVAILABLE:
         {
-        owm->attributeOwnershipUnavailable(msg.object,
-                                           msg.handleArray,
-                                           msg.handleArraySize,
+        NM_Attribute_Ownership_Unavailable& AOU = static_cast<NM_Attribute_Ownership_Unavailable&>(msg);
+        owm->attributeOwnershipUnavailable(AOU.getObject(),
+                                           AOU.getAttributes(),
+                                           AOU.getAttributesSize(),
                                            msg.federate,
                                            msg.getRefException());
         break ;
@@ -289,9 +300,10 @@
 
       case NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION_NOTIFICATION:
         {
-        owm->attributeOwnershipAcquisitionNotification(msg.object,
-                                                       msg.handleArray,
-                                                       msg.handleArraySize,
+        NM_Attribute_Ownership_Acquisition_Notification& AOAN = static_cast<NM_Attribute_Ownership_Acquisition_Notification&>(msg);
+        owm->attributeOwnershipAcquisitionNotification(AOAN.getObject(),
+                                                       AOAN.getAttributes(),
+                                                       AOAN.getAttributesSize(),
                                                        msg.federate,
                                                        msg.getRefException());
         break ;
@@ -299,18 +311,20 @@
 
       case NetworkMessage::ATTRIBUTE_OWNERSHIP_DIVESTITURE_NOTIFICATION:
         {
-        owm->attributeOwnershipDivestitureNotification(msg.object,
-                                                       msg.handleArray,
-                                                       msg.handleArraySize,
+        	NM_Attribute_Ownership_Divestiture_Notification& AODN = static_cast<NM_Attribute_Ownership_Divestiture_Notification&>(msg);
+        owm->attributeOwnershipDivestitureNotification(AODN.getObject(),
+                                                       AODN.getAttributes(),
+                                                       AODN.getAttributesSize(),
                                                        msg.getRefException());
         break ;
         }
 
       case NetworkMessage::REQUEST_ATTRIBUTE_OWNERSHIP_RELEASE:
         {
-        owm->requestAttributeOwnershipRelease(msg.object,
-                                              msg.handleArray,
-                                              msg.handleArraySize,
+        	NM_Request_Attribute_Ownership_Release& RAOR = static_cast<NM_Request_Attribute_Ownership_Release&>(msg);
+        owm->requestAttributeOwnershipRelease(RAOR.getObject(),
+                                              RAOR.getAttributes(),
+                                              RAOR.getAttributesSize(),
                                               msg.getLabel(),
                                               msg.getRefException());
         break ;
@@ -318,9 +332,10 @@
 
       case NetworkMessage::CONFIRM_ATTRIBUTE_OWNERSHIP_ACQUISITION_CANCELLATION:
         {
-        owm->confirmAttributeOwnershipAcquisitionCancellation(msg.object,
-                                                              msg.handleArray,
-                                                              msg.handleArraySize,
+        NM_Confirm_Attribute_Ownership_Acquisition_Cancellation& CAOAC= static_cast<NM_Confirm_Attribute_Ownership_Acquisition_Cancellation& >(msg);
+        owm->confirmAttributeOwnershipAcquisitionCancellation(CAOAC.getObject(),
+                                                              CAOAC.getAttributes(),
+                                                              CAOAC.getAttributesSize(),
                                                               msg.getRefException());
         break ;
         }
@@ -364,14 +379,16 @@
       case NetworkMessage::TIME_CONSTRAINED_ENABLED:
         this->timeConstrainedEnabled(msg.getDate(), msg.getRefException());
         break;
-      case NetworkMessage::START_REGISTRATION_FOR_OBJECT_CLASS:
-	dm->startRegistrationForObjectClass(msg.objectClass, msg.getRefException());
+      case NetworkMessage::START_REGISTRATION_FOR_OBJECT_CLASS: {
+    	  NM_Start_Registration_For_Object_Class& SRFOC = static_cast<NM_Start_Registration_For_Object_Class&>(msg);
+	dm->startRegistrationForObjectClass(SRFOC.getObjectClass(), msg.getRefException());
+      }
         break;
 
       default:
         D.Out(pdExcept, "Unknown message type in executeFederateService.");
         throw RTIinternalError(stringize() <<
-            "Unknown message <" <<  msg.getName() << "> in executeFederateService.");
+            "Unknown message <" <<  msg.getMessageName() << "> in executeFederateService.");
     }
     G.Out(pdGendoc,"exit  TimeManagement::executeFederateService");
     return true ;
Index: RTIA/DataDistribution.hh
===================================================================
RCS file: /sources/certi/certi/RTIA/DataDistribution.hh,v
retrieving revision 3.18
diff -u -r3.18 DataDistribution.hh
--- RTIA/DataDistribution.hh	27 Feb 2010 16:53:36 -0000	3.18
+++ RTIA/DataDistribution.hh	18 Mar 2010 18:31:07 -0000
@@ -67,7 +67,7 @@
 	throw (RegionNotKnown);
 
     ObjectHandle registerObject(ObjectClassHandle, const std::string&,
-				const std::vector <AttributeHandle> &, int,
+				const std::vector <AttributeHandle> &, uint32_t,
 				const std::vector<RegionHandle>,
 				TypeException &);
 
Index: RTIA/FederationManagement.cc
===================================================================
RCS file: /sources/certi/certi/RTIA/FederationManagement.cc,v
retrieving revision 3.82
diff -u -r3.82 FederationManagement.cc
--- RTIA/FederationManagement.cc	14 Mar 2010 15:35:53 -0000	3.82
+++ RTIA/FederationManagement.cc	18 Mar 2010 18:31:07 -0000
@@ -242,8 +242,8 @@
         requete.setFederationName(Federation);
         requete.setFederateName(Federate);
 
-        requete.bestEffortAddress = comm->getAddress();
-        requete.bestEffortPeer = comm->getPort();
+        requete.setBestEffortAddress(comm->getAddress());
+        requete.setBestEffortPeer(comm->getPort());
 
         G.Out(pdGendoc,"joinFederationExecution====>send Message to RTIG");
 
@@ -269,7 +269,7 @@
             comm->CreerSocketMC(reponse->AdresseMulticast, MC_PORT);
 #endif
 
-            nb = reponse->numberOfRegulators ;
+            nb = joinResponse->getNumberOfRegulators() ;
             for (i=0 ; i<nb ; i++) {
                 reponse.reset(comm->waitMessage(NetworkMessage::MESSAGE_NULL, 0));
                 assert(tm != NULL);
@@ -374,7 +374,7 @@
         req.setLabel(label);
         req.setTag(tag);
         // no federates set so boolean must be false
-        req.setDoesNotExist();
+        req.setExists(false);
 
         G.Out(pdGendoc,"      registerSynchronization====> send Message to RTIG");
 
@@ -414,11 +414,10 @@
         req.setLabel(label);
         req.setTag(tag);
         /* the synchronization point concerns a set of federate */
-        req.setExist();
-        req.handleArraySize = array_size ;
-        req.handleArray.resize(array_size) ;
+        req.setExists(true);
+        req.setFederatesSize(array_size);
         for ( int j=0 ; j < array_size ; j++)
-            req.handleArray[j] = fed_array[j] ;
+            req.setFederates(fed_array[j],j) ;
 
         G.Out(pdGendoc,"      registerSynchronization====> send Message to RTIG");
 
Index: RTIA/DeclarationManagement.cc
===================================================================
RCS file: /sources/certi/certi/RTIA/DeclarationManagement.cc,v
retrieving revision 3.31
diff -u -r3.31 DeclarationManagement.cc
--- RTIA/DeclarationManagement.cc	7 Mar 2010 21:30:30 -0000	3.31
+++ RTIA/DeclarationManagement.cc	18 Mar 2010 18:31:07 -0000
@@ -82,14 +82,13 @@
 
     // Partie RTIG
     NM_Publish_Object_Class req ;    
-    req.objectClass     = theClassHandle ;
-    req.handleArraySize = attribArraySize ;
-    req.handleArray.resize(attribArraySize) ;
+    req.setObjectClass(theClassHandle);
+    req.setAttributesSize(attribArraySize);
     req.federation      = fm->_numero_federation ;
     req.federate        = fm->federate ;
 
     for (uint32_t i=0 ; i<attribArraySize ; i++)
-        req.handleArray[i] = attribArray[i] ;
+        req.setAttributes(attribArray[i],i) ;
 
     // Emission
     comm->sendMessage(&req);
@@ -133,7 +132,7 @@
    
     req.federation = fm->_numero_federation ;
     req.federate = fm->federate ;
-    req.objectClass = theClassHandle ;
+    req.setObjectClass(theClassHandle);
 
     // Emission de la requete vers le RTIG
     comm->sendMessage(&req);
@@ -168,7 +167,7 @@
     
     req.federation = fm->_numero_federation ;
     req.federate = fm->federate ;
-    req.interactionClass = theInteractionHandle ;
+    req.setInteractionClass(theInteractionHandle);
 
     comm->sendMessage(&req);    
     std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::PUBLISH_INTERACTION_CLASS, req.federate));
@@ -198,7 +197,7 @@
 
     // Partie RTIG
     NM_Unpublish_Interaction_Class req;   
-    req.interactionClass = theInteractionHandle ;
+    req.setInteractionClass(theInteractionHandle);
     req.federation = fm->_numero_federation ;
     req.federate = fm->federate ;
 
@@ -227,12 +226,11 @@
 
     req.federation      = fm->_numero_federation ;
     req.federate        = fm->federate ;
-    req.objectClass     = theClassHandle ;
-    req.handleArray.resize(attribArraySize) ;
-    req.handleArraySize = attribArraySize ;
+    req.setObjectClass(theClassHandle);
+    req.setAttributesSize(attribArraySize);
 
     for (uint32_t i=0 ; i<attribArraySize ; i++)
-        req.handleArray[i] = attribArray[i] ;
+        req.setAttributes(attribArray[i],i) ;
 
     // Emission
     G.Out(pdGendoc,"                              =====> send S_O_C to RTIG");
@@ -262,7 +260,7 @@
     // Pas de Partie Locale pour les abonnements
 
     // Partie RTIG    
-    req.objectClass = theClassHandle ;
+    req.setObjectClass(theClassHandle);
     req.federation = fm->_numero_federation ;
     req.federate = fm->federate ;
 
@@ -299,7 +297,7 @@
     }
 
     // Partie RTIG    
-    req.interactionClass = theClassHandle ;
+    req.setInteractionClass(theClassHandle);
     req.federation = fm->_numero_federation ;
     req.federate = fm->federate ;
 
@@ -335,7 +333,7 @@
     }
 
     // Partie RTIG    
-    req.interactionClass = theClassHandle ;
+    req.setInteractionClass(theClassHandle);
     req.federation = fm->_numero_federation ;
     req.federate = fm->federate ;
 
Index: RTIA/OwnershipManagement.cc
===================================================================
RCS file: /sources/certi/certi/RTIA/OwnershipManagement.cc,v
retrieving revision 3.23
diff -u -r3.23 OwnershipManagement.cc
--- RTIA/OwnershipManagement.cc	27 Feb 2010 16:53:36 -0000	3.23
+++ RTIA/OwnershipManagement.cc	18 Mar 2010 18:31:08 -0000
@@ -65,7 +65,7 @@
 
     req.federation = fm->_numero_federation ;
     req.federate = fm->federate ;
-    req.object = theObject ;
+    req.setObject(theObject);
     req.setAttribute(theAttribute);
 
     D.Out(pdDebug, "Federate %u ", fm->federate);
@@ -100,10 +100,8 @@
 
     req.federation = fm->_numero_federation ;
     req.federate = fm->federate ;
-    req.object = theObject ;
-    req.handleArray.resize(1) ;
-    req.handleArray[0] = theAttribute ;
-    req.handleArraySize = 1 ;
+    req.setObject(theObject);
+    req.setAttribute(theAttribute);
 
     D.Out(pdDebug, "Federate %u ", fm->federate);
 
@@ -130,12 +128,11 @@
 
     req.federation = fm->_numero_federation ;
     req.federate = fm->federate ;
-    req.object = theObject ;
-    req.handleArray.resize(attribArraySize) ;
-    req.handleArraySize = attribArraySize ;
+    req.setObject(theObject);
+    req.setAttributesSize(attribArraySize) ;
 
     for (uint32_t i = 0 ; i < attribArraySize ; i++)
-        req.handleArray[i] = attribArray[i] ;
+        req.setAttributes(attribArray[i],i) ;
 
     req.setLabel(theTag);
 
@@ -162,12 +159,11 @@
 
     req.federation = fm->_numero_federation ;
     req.federate = fm->federate ;
-    req.object = theObject ;
-    req.handleArray.resize(attribArraySize) ;
-    req.handleArraySize = attribArraySize ;
+    req.setObject(theObject);
+    req.setAttributesSize(attribArraySize) ;
 
     for (uint32_t i = 0 ; i < attribArraySize ; i++)
-        req.handleArray[i] = attribArray[i] ;
+        req.setAttributes(attribArray[i],i) ;
 
     D.Out(pdDebug, "CANCEL_NEGOTIATED_DIVESTITURE Federate %u ",
           fm->federate);
@@ -194,12 +190,11 @@
     
     req.federation = fm->_numero_federation ;
     req.federate = fm->federate ;
-    req.object = theObject ;
-    req.handleArray.resize(attribArraySize) ;
-    req.handleArraySize = attribArraySize ;
+    req.setObject(theObject);
+    req.setAttributesSize(attribArraySize) ;
 
     for (uint32_t i = 0 ; i < attribArraySize ; i++)
-        req.handleArray[i] = attribArray[i] ;
+        req.setAttributes(attribArray[i],i) ;
 
     D.Out(pdDebug, "AcquisitionIfAvailable Federate %u ", fm->federate);
 
@@ -224,12 +219,11 @@
 
     req.federation = fm->_numero_federation ;
     req.federate = fm->federate ;
-    req.object = theObject ;
-    req.handleArray.resize(attribArraySize) ;
-    req.handleArraySize = attribArraySize ;
+    req.setObject(theObject);
+    req.setAttributesSize(attribArraySize) ;
 
     for (uint32_t i = 0 ; i < attribArraySize ; i++)
-        req.handleArray[i] = attribArray[i] ;
+        req.setAttributes(attribArray[i],i) ;
 
     D.Out(pdDebug, "UNCONDITIONAL_DIVESTITURE Federate %u ",
           fm->federate);
@@ -256,12 +250,11 @@
 
     req.federation = fm->_numero_federation ;
     req.federate = fm->federate ;
-    req.object = theObject ;
-    req.handleArray.resize(attribArraySize) ;
-    req.handleArraySize = attribArraySize ;
+    req.setObject(theObject);
+    req.setAttributesSize(attribArraySize) ;
 
     for (uint32_t i = 0 ; i < attribArraySize ; i++)
-        req.handleArray[i] = attribArray[i] ;
+        req.setAttributes(attribArray[i],i) ;
 
     req.setLabel(theTag);
 
@@ -288,31 +281,30 @@
 
     req.federation = fm->_numero_federation ;
     req.federate = fm->federate ;
-    req.object = theObject ;
-    req.handleArray.resize(attribArraySize) ;
-    req.handleArraySize = attribArraySize ;
+    req.setObject(theObject);
+    req.setAttributesSize(attribArraySize) ;
 
     D.Out(pdDebug, "RELEASE_RESPONSE Object %u handleArraySize %u",
-          theObject, req.handleArraySize);
+          theObject, req.getAttributesSize());
 
     for (uint32_t i = 0 ; i < attribArraySize ; i++) {
-        req.handleArray[i] = attribArray[i] ;
+        req.setAttributes(attribArray[i],i) ;
     }
 
 
     comm->sendMessage(&req);
 
-    std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::ATTRIBUTE_OWNERSHIP_RELEASE_RESPONSE,
-                      req.federate));
+    std::auto_ptr<NM_Attribute_Ownership_Release_Response> rep(static_cast<NM_Attribute_Ownership_Release_Response*>(comm->waitMessage(NetworkMessage::ATTRIBUTE_OWNERSHIP_RELEASE_RESPONSE,
+                      req.federate)));
 
     e = rep->getException() ;
 
     if (e == e_NO_EXCEPTION) {
         AttributeHandleSet *AttributeSet ;
-        AttributeSet = new AttributeHandleSet(rep->handleArraySize);
+        AttributeSet = new AttributeHandleSet(rep->getAttributesSize());
 
-        for (int i = 0 ; i < rep->handleArraySize ; i++) {
-            AttributeSet->add(rep->handleArray[i]);
+        for (uint32_t i = 0 ; i < rep->getAttributesSize() ; i++) {
+            AttributeSet->add(rep->getAttributes(i));
         }
 
         return(AttributeSet);
@@ -334,12 +326,11 @@
 
     req.federation = fm->_numero_federation ;
     req.federate = fm->federate ;
-    req.object = theObject ;
-    req.handleArray.resize(attribArraySize) ;
-    req.handleArraySize = attribArraySize ;
+    req.setObject(theObject);
+    req.setAttributesSize(attribArraySize);
 
     for (uint32_t i = 0 ; i < attribArraySize ; i++)
-        req.handleArray[i] = attribArray[i] ;
+        req.setAttributes(attribArray[i],i) ;
 
     D.Out(pdDebug, "CANCEL_ACQUISITION Federate %u ", fm->federate);
 
Index: RTIA/RTIA_network.cc
===================================================================
RCS file: /sources/certi/certi/RTIA/RTIA_network.cc,v
retrieving revision 3.34
diff -u -r3.34 RTIA_network.cc
--- RTIA/RTIA_network.cc	7 Mar 2010 21:30:30 -0000	3.34
+++ RTIA/RTIA_network.cc	18 Mar 2010 18:31:08 -0000
@@ -65,7 +65,7 @@
           D.Out(pdTrace,
                 "Receving Message from RTIG, type NetworkMessage::SET_TIME_REGULATING.");
 
-          if (static_cast<NM_Set_Time_Regulating*>(msg)->isRegulator())
+          if (static_cast<NM_Set_Time_Regulating*>(msg)->isRegulatorOn())
               tm->insert(msg->federate, msg->getDate());
           else
               tm->remove(msg->federate);
@@ -101,10 +101,11 @@
 
       case NetworkMessage::REFLECT_ATTRIBUTE_VALUES:
       {
+    	  NM_Reflect_Attribute_Values *RAV = static_cast<NM_Reflect_Attribute_Values*>(msg);
           OrderType updateOrder  ;
 
           D.Out(pdTrace,
-                "Receving Message from RTIG, "
+                "Receiving Message from RTIG, "
                 "type NetworkMessage::REFLECT_ATTRIBUTE_VALUES.");
 
          // It is important to note that several attributes may be updated at
@@ -128,10 +129,10 @@
              // Retrieve order type
              updateOrder = TIMESTAMP;
 
-             for (uint16_t i=0; i< msg->handleArraySize; ++i)
+             for (uint32_t i=0; i< RAV->getAttributesSize(); ++i)
                {
-                if (rootObject->ObjectClasses->getObjectFromHandle( msg->objectClass)
-                    ->getAttribute(msg->handleArray[i])->order != TIMESTAMP)
+                if (rootObject->ObjectClasses->getObjectFromHandle(RAV->getObject())
+                    ->getAttribute(RAV->getAttributes(i))->order != TIMESTAMP)
                 {
                    updateOrder = RECEIVE;
                    break;
@@ -156,6 +157,8 @@
 
       case NetworkMessage::RECEIVE_INTERACTION:
       {
+
+    	 NM_Receive_Interaction* RI = static_cast<NM_Receive_Interaction*>(msg);
          OrderType interactionOrder ;
 
          D.Out(pdTrace,
@@ -171,7 +174,7 @@
              {
              // Retrieve order type
              interactionOrder = rootObject->Interactions->
-                getObjectFromHandle(msg->interactionClass)->order;
+                getObjectFromHandle(RI->getInteractionClass())->order;
              }
 
          // Decide which queue will be used
Index: RTIA/DataDistribution.cc
===================================================================
RCS file: /sources/certi/certi/RTIA/DataDistribution.cc,v
retrieving revision 3.32
diff -u -r3.32 DataDistribution.cc
--- RTIA/DataDistribution.cc	27 Feb 2010 16:53:36 -0000	3.32
+++ RTIA/DataDistribution.cc	18 Mar 2010 18:31:07 -0000
@@ -47,17 +47,17 @@
 
 // ----------------------------------------------------------------------------
 DataDistribution::DataDistribution(RootObject *root_object,
-                                   FederationManagement *fed_management,
-                                   Communications *communications)
-    : rootObject(root_object),
-      fm(fed_management),
-      comm(communications) { }
+		FederationManagement *fed_management,
+		Communications *communications)
+: rootObject(root_object),
+  fm(fed_management),
+  comm(communications) { }
 
 // ----------------------------------------------------------------------------
 SpaceHandle
 DataDistribution::getRoutingSpaceHandle(const std::string& name) const
 {
-    return rootObject->getRoutingSpaceHandle(name);
+	return rootObject->getRoutingSpaceHandle(name);
 }
 
 // ----------------------------------------------------------------------------
@@ -66,7 +66,7 @@
 const std::string&
 DataDistribution::getRoutingSpaceName(SpaceHandle handle) const
 {
-    return rootObject->getRoutingSpaceName(handle);
+	return rootObject->getRoutingSpaceName(handle);
 }
 
 // ----------------------------------------------------------------------------
@@ -74,9 +74,9 @@
 //
 DimensionHandle
 DataDistribution::getDimensionHandle(const std::string& dimension, SpaceHandle space) const
-    throw (SpaceNotDefined, NameNotFound)
+throw (SpaceNotDefined, NameNotFound)
 {
-    return rootObject->getRoutingSpace(space).getDimensionHandle(dimension);
+	return rootObject->getRoutingSpace(space).getDimensionHandle(dimension);
 }
 
 // ----------------------------------------------------------------------------
@@ -84,10 +84,10 @@
 //
 const std::string&
 DataDistribution::getDimensionName(DimensionHandle dimension,
-				   SpaceHandle space) const
-    throw (SpaceNotDefined, DimensionNotDefined)
+		SpaceHandle space) const
+throw (SpaceNotDefined, DimensionNotDefined)
 {
-    return rootObject->getRoutingSpace(space).getDimensionName(dimension);
+	return rootObject->getRoutingSpace(space).getDimensionName(dimension);
 }
 
 // ----------------------------------------------------------------------------
@@ -95,12 +95,12 @@
 //
 SpaceHandle
 DataDistribution::getAttributeSpace(AttributeHandle attribute,
-                                    ObjectClassHandle object_class) const
-    throw (ObjectClassNotDefined, AttributeNotDefined)
+		ObjectClassHandle object_class) const
+throw (ObjectClassNotDefined, AttributeNotDefined)
 {
-std::cout<<"DataDistribution::getAttributeSpace"<<std::endl;
-    return rootObject->ObjectClasses->getObjectFromHandle(object_class)->
-        getAttribute(attribute)->getSpace();
+	std::cout<<"DataDistribution::getAttributeSpace"<<std::endl;
+	return rootObject->ObjectClasses->getObjectFromHandle(object_class)->
+			getAttribute(attribute)->getSpace();
 }
 
 // ----------------------------------------------------------------------------
@@ -108,9 +108,9 @@
 //
 SpaceHandle
 DataDistribution::getInteractionSpace(InteractionClassHandle interaction) const
-    throw (InteractionClassNotDefined)
+throw (InteractionClassNotDefined)
 {
-    return rootObject->Interactions->getObjectFromHandle(interaction)->getSpace();
+	return rootObject->Interactions->getObjectFromHandle(interaction)->getSpace();
 }
 
 // ----------------------------------------------------------------------------
@@ -118,35 +118,35 @@
 //
 long
 DataDistribution::createRegion(SpaceHandle space,
-                               unsigned long nb_extents,
-                               TypeException &e)
-    throw (SpaceNotDefined)
-{
-    Debug(D, pdDebug) << "Start creating region in space " << space << "..." << endl ;
-    NM_DDM_Create_Region req;
-
-    req.federation = fm->_numero_federation ;
-    req.federate = fm->federate ;
-    req.space = space ;
-    req.nbExtents = nb_extents ;
-
-    comm->sendMessage(&req);
-    std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_CREATE_REGION, req.federate));
-    e = rep->getException() ;
-
-    if (e == e_NO_EXCEPTION) {
-	Debug(D, pdDebug) << "Create region " << rep->region << endl ;
-        RTIRegion *region = new RTIRegion(rep->region,
-					  rootObject->getRoutingSpace(space),
-					  nb_extents);
-
-	assert(region->getNumberOfExtents() == nb_extents);
-        rootObject->addRegion(region);
-        return rep->region;
-    }
-    else {
-        return 0 ;
-    }
+		unsigned long nb_extents,
+		TypeException &e)
+throw (SpaceNotDefined)
+{
+	Debug(D, pdDebug) << "Start creating region in space " << space << "..." << endl ;
+	NM_DDM_Create_Region req;
+
+	req.federation = fm->_numero_federation ;
+	req.federate = fm->federate ;
+	req.setSpace(space);
+	req.setNbExtents(nb_extents);
+
+	comm->sendMessage(&req);
+	std::auto_ptr<NM_DDM_Create_Region> rep(static_cast<NM_DDM_Create_Region*>(comm->waitMessage(NetworkMessage::DDM_CREATE_REGION, req.federate)));
+	e = rep->getException();
+
+	if (e == e_NO_EXCEPTION) {
+		Debug(D, pdDebug) << "Create region " << rep->getRegion() << endl ;
+		RTIRegion *region = new RTIRegion(rep->getRegion(),
+				rootObject->getRoutingSpace(space),
+				nb_extents);
+
+		assert(region->getNumberOfExtents() == nb_extents);
+		rootObject->addRegion(region);
+		return rep->getRegion();
+	}
+	else {
+		return 0 ;
+	}
 } /* end of createRegion */
 
 // ----------------------------------------------------------------------------
@@ -154,30 +154,30 @@
 //
 void
 DataDistribution::modifyRegion(RegionHandle handle,
-			       const std::vector<Extent> &extents,
-			       TypeException &e)
+		const std::vector<Extent> &extents,
+		TypeException &e)
 {
-    Debug(D, pdDebug) << "Modify region " << handle << "..." << endl ;
+	Debug(D, pdDebug) << "Modify region " << handle << "..." << endl ;
+
+	// check region
+	RTIRegion *region = rootObject->getRegion(handle);
+
+	// Request to RTIG
+	NM_DDM_Modify_Region req;
 
-    // check region
-    RTIRegion *region = rootObject->getRegion(handle);
+	req.federation = fm->_numero_federation ;
+	req.federate = fm->federate ;
+	req.setRegion(handle) ;
+	req.setExtents(extents);
 
-    // Request to RTIG
-    NM_DDM_Modify_Region req;
-
-    req.federation = fm->_numero_federation ;
-    req.federate = fm->federate ;
-    req.region = handle ;
-    req.setExtents(extents);
-
-    comm->sendMessage(&req);
-    std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_MODIFY_REGION, req.federate));
-    e = rep->getException() ;
-
-    if (e == e_NO_EXCEPTION) {
-	region->replaceExtents(extents);
-	Debug(D, pdDebug) << "Modified region " << handle << endl ;
-    }
+	comm->sendMessage(&req);
+	std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_MODIFY_REGION, req.federate));
+	e = rep->getException() ;
+
+	if (e == e_NO_EXCEPTION) {
+		region->replaceExtents(extents);
+		Debug(D, pdDebug) << "Modified region " << handle << endl ;
+	}
 } /* end of modifyRegion */
 
 // ----------------------------------------------------------------------------
@@ -185,229 +185,235 @@
 //
 void
 DataDistribution::deleteRegion(long handle, TypeException &e)
-    throw (RegionNotKnown, RegionInUse)
+throw (RegionNotKnown, RegionInUse)
 {
-    Debug(D, pdDebug) << "Delete region " << handle << "..." << endl ;
+	Debug(D, pdDebug) << "Delete region " << handle << "..." << endl ;
 
-    // check region
-    rootObject->getRegion(handle);
+	// check region
+	rootObject->getRegion(handle);
 
-    // Request to RTIG
-    NM_DDM_Delete_Region req;
+	// Request to RTIG
+	NM_DDM_Delete_Region req;
 
-    req.federation = fm->_numero_federation ;
-    req.federate = fm->federate ;
-    req.region = handle ;
+	req.federation = fm->_numero_federation ;
+	req.federate = fm->federate ;
+	req.setRegion(handle);
 
-    comm->sendMessage(&req);
-    std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_DELETE_REGION, req.federate));
-    e = rep->getException() ;
+	comm->sendMessage(&req);
+	std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_DELETE_REGION, req.federate));
+	e = rep->getException() ;
 
-    if (e == e_NO_EXCEPTION) {
-        rootObject->deleteRegion(handle);
-        Debug(D, pdDebug) << "Deleted region " << handle << endl ;
-    }
+	if (e == e_NO_EXCEPTION) {
+		rootObject->deleteRegion(handle);
+		Debug(D, pdDebug) << "Deleted region " << handle << endl ;
+	}
 } /* end of deleteRegion */
 
 // ----------------------------------------------------------------------------
 void
 DataDistribution::associateRegion(ObjectHandle object,
-				  RegionHandle region,
-				  const std::vector <AttributeHandle> &attr,
-				  uint32_t nb,
-				  TypeException &e)
-    throw (RegionNotKnown)
-{
-    Debug(D, pdDebug) << "Associate Region " << region << std::endl ;
-
-    RTIRegion *r = rootObject->getRegion(region);
-
-    Debug(D, pdDebug) << "- unassociate object " << object << std::endl ;
-    rootObject->getObject(object)->unassociate(r);
-    for (uint32_t i = 0 ; i < nb ; ++i) {
-	Debug(D, pdDebug) << "- associate attribute " << attr[i] << std::endl ;
-	rootObject->getObjectAttribute(object, attr[i])->associate(r);
-    }
+		RegionHandle region,
+		const std::vector <AttributeHandle> &attr,
+		uint32_t nb,
+		TypeException &e)
+throw (RegionNotKnown)
+{
+	Debug(D, pdDebug) << "Associate Region " << region << std::endl ;
+
+	RTIRegion *r = rootObject->getRegion(region);
+
+	Debug(D, pdDebug) << "- unassociate object " << object << std::endl ;
+	rootObject->getObject(object)->unassociate(r);
+	for (uint32_t i = 0 ; i < nb ; ++i) {
+		Debug(D, pdDebug) << "- associate attribute " << attr[i] << std::endl ;
+		rootObject->getObjectAttribute(object, attr[i])->associate(r);
+	}
 
-    NM_DDM_Associate_Region req;
+	NM_DDM_Associate_Region req;
 
-    req.federation = fm->_numero_federation ;
-    req.federate = fm->federate ;
-    req.object = object ;
-    req.region = region ;
+	req.federation = fm->_numero_federation ;
+	req.federate = fm->federate ;
+	req.setObject(object);
+	req.setRegion(region) ;
 
-    req.setAHS(attr, nb);
+	for (uint32_t i=0;i<nb;++i) {
+		req.setAttributes(attr[i],i);
+	}
 
-    comm->sendMessage(&req);
-    std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_ASSOCIATE_REGION,req.federate));
+	comm->sendMessage(&req);
+	std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_ASSOCIATE_REGION,req.federate));
 
-    e = rep->getException() ;
+	e = rep->getException() ;
 
 } /* end of associateRegion */
 
 // ----------------------------------------------------------------------------
 ObjectHandle
 DataDistribution::registerObject(ObjectClassHandle class_handle,
-				 const std::string& name,
-				 const std::vector <AttributeHandle> &attrs,
-				 int nb,
-				 const std::vector<RegionHandle> regions,
-				 TypeException &e)
-{
-    Debug(D, pdDebug) << "Register object of class " << class_handle << " with "
-	       << regions.size() << " region(s)." << std::endl ;
-
-    NM_DDM_Register_Object req;
-
-    req.federation = fm->_numero_federation ;
-    req.federate = fm->federate ;
-    req.objectClass = class_handle ;
-    req.setTag(name);
-    req.setAHS(attrs, nb);
-    req.setRegions(regions);
-
-    comm->sendMessage(&req);
-    std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_REGISTER_OBJECT,req.federate));
-
-    e = rep->getException() ;
-
-    if (e == e_NO_EXCEPTION) {
-        rootObject->registerObjectInstance(fm->federate, class_handle, rep->object,
-                                           rep->getLabel());
-	for (int i = 0 ; i < nb ; ++i) {
-	    Debug(D, pdDebug) << "Register attribute [" << i << "] Attr: " << attrs[i]
-		       << " Region: " << regions[i] << std::endl ;
-
-	    ObjectAttribute *attribute = rootObject->getObjectAttribute(rep->object, attrs[i]);
-	    RTIRegion *region = rootObject->getRegion(regions[i]);
-	    attribute->associate(region);
+		const std::string& name,
+		const std::vector <AttributeHandle> &attrs,
+		uint32_t nb,
+		const std::vector<RegionHandle> regions,
+		TypeException &e)
+{
+	Debug(D, pdDebug) << "Register object of class " << class_handle << " with "
+			<< regions.size() << " region(s)." << std::endl ;
+
+	NM_DDM_Register_Object req;
+
+	req.federation = fm->_numero_federation ;
+	req.federate = fm->federate ;
+	req.setObjectClass(class_handle);
+	req.setTag(name);
+	for (uint32_t i=0;i<nb;++i) {
+		req.setAttributes(attrs[i],i);
 	}
-	    return rep->object;
-    }
-    else return 0 ;
+	req.setRegions(regions);
+
+	comm->sendMessage(&req);
+	std::auto_ptr<NM_DDM_Register_Object> rep(static_cast<NM_DDM_Register_Object*>(comm->waitMessage(NetworkMessage::DDM_REGISTER_OBJECT,req.federate)));
+	e = rep->getException() ;
+
+
+	if (e == e_NO_EXCEPTION) {
+		rootObject->registerObjectInstance(fm->federate, class_handle, rep->getObject(),
+				rep->getLabel());
+		for (uint32_t i = 0 ; i < nb ; ++i) {
+			Debug(D, pdDebug) << "Register attribute [" << i << "] Attr: " << attrs[i]
+			                                                                        << " Region: " << regions[i] << std::endl ;
+
+			ObjectAttribute *attribute = rootObject->getObjectAttribute(rep->getObject(), attrs[i]);
+			RTIRegion *region = rootObject->getRegion(regions[i]);
+			attribute->associate(region);
+		}
+		return rep->getObject();
+	}
+	else return 0 ;
 } /* end of registerObject */
 
 // ----------------------------------------------------------------------------
 void
 DataDistribution::unassociateRegion(ObjectHandle object,
-				    RegionHandle region,
-				    TypeException &e)
-    throw (ObjectNotKnown, InvalidRegionContext, RegionNotKnown)
+		RegionHandle region,
+		TypeException &e)
+throw (ObjectNotKnown, InvalidRegionContext, RegionNotKnown)
 {
-    Debug(D, pdDebug) << "Unassociate Region " << region << std::endl ;
+	Debug(D, pdDebug) << "Unassociate Region " << region << std::endl ;
 
-    RTIRegion *r = rootObject->getRegion(region);
+	RTIRegion *r = rootObject->getRegion(region);
 
-    rootObject->getObject(object)->unassociate(r);
+	rootObject->getObject(object)->unassociate(r);
 
-    NM_DDM_Unassociate_Region req;
+	NM_DDM_Unassociate_Region req;
 
-    req.federation = fm->_numero_federation ;
-    req.federate = fm->federate ;
-    req.object = object ;
-    req.region = region ;
+	req.federation = fm->_numero_federation ;
+	req.federate = fm->federate ;
+	req.setObject(object);
+	req.setRegion(region) ;
 
-    comm->sendMessage(&req);
-    std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_UNASSOCIATE_REGION,
-		      req.federate));
+	comm->sendMessage(&req);
+	std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_UNASSOCIATE_REGION,
+			req.federate));
 
-   e = rep->getException() ;
+	e = rep->getException() ;
 } /* end of unassociateRegion */
 
 // ----------------------------------------------------------------------------
 void
 DataDistribution::subscribe(ObjectClassHandle obj_class,
-			    RegionHandle region,
-			    const std::vector <AttributeHandle> &attr,
-			    uint32_t nb,
-			    TypeException &e)
-    throw (RegionNotKnown)
-{
-    Debug(D, pdDebug) << "Subscribe attributes with region " << region << endl ;
-    rootObject->getRegion(region);
-
-    NM_DDM_Subscribe_Attributes req;
-
-    req.federation = fm->_numero_federation ;
-    req.federate = fm->federate ;
-    req.objectClass = obj_class ;
-    req.region = region ;
-    req.setAHS(attr, nb);
-
-    comm->sendMessage(&req);
-    std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_SUBSCRIBE_ATTRIBUTES,
-		      req.federate));
+		RegionHandle region,
+		const std::vector <AttributeHandle> &attr,
+		uint32_t nb,
+		TypeException &e)
+throw (RegionNotKnown)
+{
+	Debug(D, pdDebug) << "Subscribe attributes with region " << region << endl ;
+	rootObject->getRegion(region);
+
+	NM_DDM_Subscribe_Attributes req;
+
+	req.federation = fm->_numero_federation ;
+	req.federate = fm->federate ;
+	req.setObjectClass(obj_class);
+	req.setRegion(region);
+	for (uint32_t i=0;i<nb;++i) {
+		req.setAttributes(attr[i],i);
+	}
+
+	comm->sendMessage(&req);
+	std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_SUBSCRIBE_ATTRIBUTES,
+			req.federate));
 
-    e = rep->getException() ;
+	e = rep->getException() ;
 } /* end of subscribe */
 
 // ----------------------------------------------------------------------------
 void
 DataDistribution::unsubscribeAttributes(ObjectClassHandle obj_class,
-					RegionHandle region,
-					TypeException &e)
-    throw (RegionNotKnown)
-{
-    Debug(D, pdDebug) << "Unsubscribe class " << obj_class
-	       << " with region " << region << endl ;
-    rootObject->getRegion(region);
-
-    NM_DDM_Unsubscribe_Attributes req;
-
-    req.federation = fm->_numero_federation ;
-    req.federate = fm->federate ;
-    req.objectClass = obj_class ;
-    req.region = region ;
-
-    comm->sendMessage(&req);
-    std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_UNSUBSCRIBE_ATTRIBUTES,
-		      req.federate));
+		RegionHandle region,
+		TypeException &e)
+throw (RegionNotKnown)
+{
+	Debug(D, pdDebug) << "Unsubscribe class " << obj_class
+			<< " with region " << region << endl ;
+	rootObject->getRegion(region);
+
+	NM_DDM_Unsubscribe_Attributes req;
+
+	req.federation = fm->_numero_federation ;
+	req.federate = fm->federate ;
+	req.setObjectClass(obj_class);
+	req.setRegion(region);
+
+	comm->sendMessage(&req);
+	std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_UNSUBSCRIBE_ATTRIBUTES,
+			req.federate));
 
-    e = rep->getException() ;
+	e = rep->getException() ;
 } /* end of unsubscribeAttributes */
 
 // ----------------------------------------------------------------------------
 void
 DataDistribution::subscribeInteraction(InteractionClassHandle int_class,
-				       RegionHandle region,
-				       TypeException &e)
-    throw (RegionNotKnown)
+		RegionHandle region,
+		TypeException &e)
+throw (RegionNotKnown)
 {
-    Debug(D, pdDebug) << "Subscribe interaction with region " << region << endl ;
-    rootObject->getRegion(region);
+	Debug(D, pdDebug) << "Subscribe interaction with region " << region << endl ;
+	rootObject->getRegion(region);
 
-    NM_DDM_Subscribe_Interaction req;
+	NM_DDM_Subscribe_Interaction req;
 
-    req.interactionClass = int_class ;
-    req.region = region ;
+	req.setInteractionClass(int_class);
+	req.setRegion(region);
 
-    comm->sendMessage(&req);
-    std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_SUBSCRIBE_INTERACTION,
-		      req.federate));
+	comm->sendMessage(&req);
+	std::auto_ptr<NetworkMessage> rep(comm->waitMessage(NetworkMessage::DDM_SUBSCRIBE_INTERACTION,
+			req.federate));
 
-    e = rep->getException() ;
+	e = rep->getException() ;
 } /* end of subscribeInteraction */
 
 // ----------------------------------------------------------------------------
 void
 DataDistribution::unsubscribeInteraction(InteractionClassHandle int_class,
-					 RegionHandle region,
-					 TypeException &e)
-    throw (RegionNotKnown)
+		RegionHandle region,
+		TypeException &e)
+throw (RegionNotKnown)
 {
-    Debug(D, pdDebug) << "Unsubscribe interaction with region " << region << endl ;
-    rootObject->getRegion(region);
+	Debug(D, pdDebug) << "Unsubscribe interaction with region " << region << endl ;
+	rootObject->getRegion(region);
 
-    NM_DDM_Unsubscribe_Interaction req;
+	NM_DDM_Unsubscribe_Interaction req;
 
-    req.interactionClass = int_class ;
-    req.region = region ;
+	req.setInteractionClass(int_class);
+	req.setRegion(region);
 
-    comm->sendMessage(&req);
-    std::auto_ptr<NetworkMessage>  rep(comm->waitMessage(NetworkMessage::DDM_UNSUBSCRIBE_INTERACTION,
-		      req.federate));
+	comm->sendMessage(&req);
+	std::auto_ptr<NetworkMessage>  rep(comm->waitMessage(NetworkMessage::DDM_UNSUBSCRIBE_INTERACTION,
+			req.federate));
 
-    e = rep->getException() ;
+	e = rep->getException() ;
 } /* end of unsubscribeInteraction */
 
 }} // namespace certi::rtia
Index: libCERTI/NM_Classes.hh
===================================================================
RCS file: /sources/certi/certi/libCERTI/NM_Classes.hh,v
retrieving revision 3.15
diff -u -r3.15 NM_Classes.hh
--- libCERTI/NM_Classes.hh	18 Nov 2009 18:50:49 -0000	3.15
+++ libCERTI/NM_Classes.hh	18 Mar 2010 18:31:10 -0000
@@ -1,3 +1,18 @@
+// Generated on 2010 March Thu, 18 at 17:48:38 by the CERTI message generator
+#ifndef NM_CLASSES_HH
+#define NM_CLASSES_HH
+// ****-**** Global System includes ****-****
+#include <vector>
+#include <string>
+// ****-**** Includes coming from native types ****-****
+// Network message is the base class
+// for message exchanged between RTIA and RTIG
+// AKA CERTI Network Message
+#include "NetworkMessage.hh"
+
+#include "FedTimeD.hh"
+
+#include "certi.hh"
 // ----------------------------------------------------------------------------
 // CERTI - HLA RunTime Infrastructure
 // Copyright (C) 2002-2008  ONERA
@@ -18,1704 +33,1858 @@
 // USA
 //
 // ----------------------------------------------------------------------------
-
-#ifndef CERTI_NM_CLASSES_HH
-#define CERTI_NM_CLASSES_HH
-#include "NetworkMessage.hh"
-#include <vector>
-
+// CERTI Network Messages description
+// ----------------------------------------------------------------------------
+// The messages related classes will be placed in the certi package
 namespace certi {
-/**
- * Network Message factory
- */
-class CERTI_EXPORT NM_Factory {
-public:
-	static NetworkMessage* create(NetworkMessage::Message_T type) throw (RTIinternalError);
-	static NetworkMessage* receive(Socket* socket) throw (NetworkError,RTIinternalError);
-private:
-};
-
-class CERTI_EXPORT NM_WithHandleArray : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_WithHandleArray();
-	virtual ~NM_WithHandleArray();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);	
-	/* specific Getter/Setter */	
-	AttributeHandle getHandle(int i) const {return handleArray[i];};
-	void setHandle(AttributeHandle h, int i) {handleArray[i]=h;};
-protected:
-	/* specific field */
-private:	
-};
-
-class CERTI_EXPORT NM_DDM_Base : public NM_WithHandleArray {
-public:
-	typedef NM_WithHandleArray Super;
-	NM_DDM_Base();
-	virtual ~NM_DDM_Base();
-	virtual void serialize(MessageBuffer& msgBuffer)   = 0;
-	virtual void deserialize(MessageBuffer& msgBuffer) = 0;	
-	/* specific Getter/Setter */	
-	const SpaceHandle getSpace() const {return space;};
-	void setSpace(SpaceHandle newSpace) {space=newSpace;};
-
-	const int32_t geNbExtents() const {return nbExtents;};
-	void setNbExtents(int32_t newNbExtents) {nbExtents=newNbExtents;};
-
-	const int32_t getRegion() const {return region;};
-	void setRegion(int32_t newRegion) {region=newRegion;};	
-
-	const ObjectHandle getObject() const {return object;};
-	void setObject(ObjectHandle newObject) {object=newObject;};
-
-	const ObjectClassHandle getObjectClass() const {return objectClass;};
-	void setObjectClass(ObjectClassHandle newObjectClass) {objectClass=newObjectClass;};
-
-	const InteractionClassHandle getInteractionClass() const {return interactionClass;};
-	void setInteractionClass(InteractionClassHandle newInteractionClass) {interactionClass=newInteractionClass;};
-protected:
-	/* specific field */
-	bool DDM_bool;
-private:
-};
-
-
-/*<BEGIN>---------- Not_Used ------------<BEGIN>*/
-class CERTI_EXPORT NM_Not_Used : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Not_Used();
-	virtual ~NM_Not_Used();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Not_Used ------------<END>*/
-
-/*<BEGIN>---------- Close_Connexion ------------<BEGIN>*/
-class CERTI_EXPORT NM_Close_Connexion : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Close_Connexion();
-	virtual ~NM_Close_Connexion();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Close_Connexion ------------<END>*/
-
-/*<BEGIN>---------- Message_Null ------------<BEGIN>*/
-class CERTI_EXPORT NM_Message_Null : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Message_Null();
-	virtual ~NM_Message_Null();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Message_Null ------------<END>*/
-
-/*<BEGIN>---------- FOM_Dimension ------------<BEGIN>*/
-class CERTI_EXPORT NM_FOM_Dimension {
-public:
-        NM_FOM_Dimension() : _handle(0) {}
-	void serialize(MessageBuffer& msgBuffer);
-	void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-	const DimensionHandle& getHandle() const {return _handle;}
-	void setHandle(const DimensionHandle& handle) {_handle=handle;}
-	const std::string& getName() const {return _name;}
-	void setName(const std::string& name) {_name=name;}
-protected:
-	/* specific field */
-        DimensionHandle _handle;
-        std::string _name;
-private:
-};
-
-/*<END>---------- FOM_Dimension ------------<END>*/
-
-/*<BEGIN>---------- FOM_Routing_Space ------------<BEGIN>*/
-class CERTI_EXPORT NM_FOM_Routing_Space {
-public:
-        NM_FOM_Routing_Space() : _handle(0) {}
-	void serialize(MessageBuffer& msgBuffer);
-	void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-	const SpaceHandle& getHandle() const {return _handle;}
-	void setHandle(const SpaceHandle& handle) {_handle=handle;}
-	const std::string& getName() const {return _name;}
-	void setName(const std::string& name) {_name=name;}
-        uint32_t getNumDimensions() const { return _dimensions.size(); }
-        void setNumDimensions(uint32_t num) { _dimensions.resize(num); }
-        const NM_FOM_Dimension& getDimension(uint32_t index) const { return _dimensions[index]; }
-        NM_FOM_Dimension& getDimension(uint32_t index) { return _dimensions[index]; }
-        void setDimension(uint32_t index, const NM_FOM_Dimension& dimension) { _dimensions[index] = dimension; }
-protected:
-	/* specific field */
-        SpaceHandle _handle;
-        std::string _name;
-        std::vector<NM_FOM_Dimension> _dimensions;
-private:
-};
-
-/*<END>---------- FOM_Routing_Space ------------<END>*/
-
-/*<BEGIN>---------- FOM_Attribute ------------<BEGIN>*/
-class CERTI_EXPORT NM_FOM_Attribute {
-public:
-        NM_FOM_Attribute() : _handle(0), _spaceHandle(0), _order(0), _transport(0) {}
-	void serialize(MessageBuffer& msgBuffer);
-	void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-	const AttributeHandle& getHandle() const {return _handle;}
-	void setHandle(const AttributeHandle& handle) {_handle=handle;}
-	const std::string& getName() const {return _name;}
-	void setName(const std::string& name) {_name=name;}
-	const SpaceHandle& getSpaceHandle() const {return _spaceHandle;}
-	void setSpaceHandle(const SpaceHandle& spaceHandle) {_spaceHandle=spaceHandle;}
-	const OrderType& getOrder() const {return _order;}
-	void setOrder(const OrderType& order) {_order=order;}
-	const TransportType& getTransport() const {return _transport;}
-	void setTransport(const TransportType& transport) {_transport=transport;}
-protected:
-	/* specific field */
-        AttributeHandle _handle;
-        std::string _name;
-        SpaceHandle _spaceHandle;
-        OrderType _order;
-        TransportType _transport;
-private:
-};
-
-/*<END>---------- FOM_Attribute ------------<END>*/
-
-/*<BEGIN>---------- FOM_Object_Class ------------<BEGIN>*/
-class CERTI_EXPORT NM_FOM_Object_Class {
-public:
-        NM_FOM_Object_Class() : _handle(0), _superclassHandle(0) {}
-	void serialize(MessageBuffer& msgBuffer);
-	void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-	const ObjectClassHandle& getHandle() const {return _handle;}
-	void setHandle(const ObjectClassHandle& handle) {_handle=handle;}
-	const std::string& getName() const {return _name;}
-	void setName(const std::string& name) {_name=name;}
-	const ObjectClassHandle& getSuperclassHandle() const {return _superclassHandle;}
-	void setSuperclassHandle(const ObjectClassHandle& superclassHandle) {_superclassHandle=superclassHandle;}
-        uint32_t getNumAttributes() const { return _attributes.size(); }
-        void setNumAttributes(uint32_t num) { _attributes.resize(num); }
-        const NM_FOM_Attribute& getAttribute(uint32_t index) const { return _attributes[index]; }
-        NM_FOM_Attribute& getAttribute(uint32_t index) { return _attributes[index]; }
-        void setAttribute(uint32_t index, const NM_FOM_Attribute& attribute) { _attributes[index] = attribute; }
-protected:
-	/* specific field */
-        ObjectClassHandle _handle;
-        std::string _name;
-        ObjectClassHandle _superclassHandle;
-        std::vector<NM_FOM_Attribute> _attributes;
-private:
-};
-
-/*<END>---------- FOM_Object_Class ------------<END>*/
-
-/*<BEGIN>---------- FOM_Parameter ------------<BEGIN>*/
-class CERTI_EXPORT NM_FOM_Parameter {
-public:
-        NM_FOM_Parameter() : _handle(0) {}
-	void serialize(MessageBuffer& msgBuffer);
-	void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-	const ParameterHandle& getHandle() const {return _handle;}
-	void setHandle(const ParameterHandle& handle) {_handle=handle;}
-	const std::string& getName() const {return _name;}
-	void setName(const std::string& name) {_name=name;}
-protected:
-	/* specific field */
-        ParameterHandle _handle;
-        std::string _name;
-private:
-};
-
-/*<END>---------- FOM_Parameter ------------<END>*/
-
-/*<BEGIN>---------- FOM_Interaction_Class ------------<BEGIN>*/
-class CERTI_EXPORT NM_FOM_Interaction_Class {
-public:
-        NM_FOM_Interaction_Class() : _handle(0), _superclassHandle(0), _spaceHandle(0), _order(0), _transport(0) {}
-	void serialize(MessageBuffer& msgBuffer);
-	void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-	const InteractionClassHandle& getHandle() const {return _handle;}
-	void setHandle(const InteractionClassHandle& handle) {_handle=handle;}
-	const std::string& getName() const {return _name;}
-	void setName(const std::string& name) {_name=name;}
-	const InteractionClassHandle& getSuperclassHandle() const {return _superclassHandle;}
-	void setSuperclassHandle(const InteractionClassHandle& superclassHandle) {_superclassHandle=superclassHandle;}
-	const SpaceHandle& getSpaceHandle() const {return _spaceHandle;}
-	void setSpaceHandle(const SpaceHandle& spaceHandle) {_spaceHandle=spaceHandle;}
-	const OrderType& getOrder() const {return _order;}
-	void setOrder(const OrderType& order) {_order=order;}
-	const TransportType& getTransport() const {return _transport;}
-	void setTransport(const TransportType& transport) {_transport=transport;}
-        uint32_t getNumParameters() const { return _parameters.size(); }
-        void setNumParameters(uint32_t num) { _parameters.resize(num); }
-        const NM_FOM_Parameter& getParameter(uint32_t index) const { return _parameters[index]; }
-        NM_FOM_Parameter& getParameter(uint32_t index) { return _parameters[index]; }
-        void setParameter(uint32_t index, const NM_FOM_Parameter& parameter) { _parameters[index] = parameter; }
-protected:
-	/* specific field */
-        InteractionClassHandle _handle;
-        std::string _name;
-        InteractionClassHandle _superclassHandle;
-        SpaceHandle _spaceHandle;
-        OrderType _order;
-        TransportType _transport;
-        std::vector<NM_FOM_Parameter> _parameters;
-private:
-};
-
-/*<END>---------- FOM_Interaction_Class ------------<END>*/
-
-/*<BEGIN>---------- Create_Federation_Execution ------------<BEGIN>*/
-class CERTI_EXPORT NM_Create_Federation_Execution : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Create_Federation_Execution();
-	virtual ~NM_Create_Federation_Execution();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-	std::string getFederationName() {return federationName;};
-	void setFederationName(std::string newFederationName) {federationName=newFederationName;};
-	std::string getFEDid() {return FEDid;};
-	void setFEDid(std::string newFEDid) {FEDid=newFEDid;};
-protected:
-	/* specific field */	  
-	std::string federationName ;
-	std::string FEDid ;
-private:
-};
-
-/*<END>---------- Create_Federation_Execution ------------<END>*/
-
-/*<BEGIN>---------- Destroy_Federation_Execution ------------<BEGIN>*/
-class CERTI_EXPORT NM_Destroy_Federation_Execution : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Destroy_Federation_Execution();
-	virtual ~NM_Destroy_Federation_Execution();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-	std::string getFederationName() {return federationName;};
-		void setFederationName(std::string newFederationName) {federationName=newFederationName;};
-protected:
-	/* specific field */	 
-	std::string federationName;
-private:
-};
-
-/*<END>---------- Destroy_Federation_Execution ------------<END>*/
-
-/*<BEGIN>---------- Join_Federation_Execution ------------<BEGIN>*/
-class CERTI_EXPORT NM_Join_Federation_Execution : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Join_Federation_Execution();
-	virtual ~NM_Join_Federation_Execution();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	std::string getFederateName() {return federateName;};
-	void setFederateName(std::string newFederateName) {federateName=newFederateName;};
-	std::string getFederationName() {return federationName;};
-	void setFederationName(std::string newFederationName) {federationName=newFederationName;};
-	/* specific Getter/Setter */
-        uint32_t getNumRoutingSpaces() const { return _routingSpaces.size(); }
-        void setNumRoutingSpaces(uint32_t num) { _routingSpaces.resize(num); }
-        const NM_FOM_Routing_Space& getRoutingSpace(uint32_t index) const { return _routingSpaces[index]; }
-        NM_FOM_Routing_Space& getRoutingSpace(uint32_t index) { return _routingSpaces[index]; }
-        void setRoutingSpace(uint32_t index, const NM_FOM_Routing_Space& routingSpace) { _routingSpaces[index] = routingSpace; }
-        uint32_t getNumObjectClasses() const { return _objectClasses.size(); }
-        void setNumObjectClasses(uint32_t num) { _objectClasses.resize(num); }
-        const NM_FOM_Object_Class& getObjectClass(uint32_t index) const { return _objectClasses[index]; }
-        NM_FOM_Object_Class& getObjectClass(uint32_t index) { return _objectClasses[index]; }
-        void setObjectClass(uint32_t index, const NM_FOM_Object_Class& objectClass) { _objectClasses[index] = objectClass; }
-        uint32_t getNumInteractionClasses() const { return _interactionClasses.size(); }
-        void setNumInteractionClasses(uint32_t num) { _interactionClasses.resize(num); }
-        const NM_FOM_Interaction_Class& getInteractionClass(uint32_t index) const { return _interactionClasses[index]; }
-        NM_FOM_Interaction_Class& getInteractionClass(uint32_t index) { return _interactionClasses[index]; }
-        void setInteractionClass(uint32_t index, const NM_FOM_Interaction_Class& interactionClass) { _interactionClasses[index] = interactionClass; }
-protected:
-	/* specific field */
-	//	int32_t  numberOfRegulators;
-	//	uint32_t multicastAddress;
-	//	uint32_t bestEffortAddress;
-	//	uint32_t bestEffortPeer;
-	std::string federationName;
-	std::string federateName;
-        std::vector<NM_FOM_Routing_Space> _routingSpaces;
-        std::vector<NM_FOM_Object_Class> _objectClasses;
-        std::vector<NM_FOM_Interaction_Class> _interactionClasses;
-private:
-};
-
-/*<END>---------- Join_Federation_Execution ------------<END>*/
-
-/*<BEGIN>---------- Resign_Federation_Execution ------------<BEGIN>*/
-class CERTI_EXPORT NM_Resign_Federation_Execution : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Resign_Federation_Execution();
-	virtual ~NM_Resign_Federation_Execution();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Resign_Federation_Execution ------------<END>*/
-
-/*<BEGIN>---------- Set_Time_Regulating ------------<BEGIN>*/
-class CERTI_EXPORT NM_Set_Time_Regulating : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Set_Time_Regulating();
-	virtual ~NM_Set_Time_Regulating();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-	void regulatorOn() {regulator=true;};
-	void regulatorOff() {regulator=false;};	
-	bool isRegulator() {return regulator;};
-protected:
-	/* specific field */
-	/**
-	 * Toggle which indicates if federate
-	 * wants to become regulator or leave
-	 * its regulator state
-	 */
-	bool regulator ;
-private:
-};
-
-/*<END>---------- Set_Time_Regulating ------------<END>*/
-
-/*<BEGIN>---------- Set_Time_Constrained ------------<BEGIN>*/
-class CERTI_EXPORT NM_Set_Time_Constrained : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Set_Time_Constrained();
-	virtual ~NM_Set_Time_Constrained();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-	void constrainedOn() {constrained=true;};
-	void constrainedOff() {constrained=false;};		
-	bool isConstrained() {return constrained;};
-protected:
-	/* specific field */	
-	/**
-	 * Toggle which indicates if federate
-	 * wants to become constrained or leave
-	 * its constrained state
-	 */
-	bool constrained;
-private:
-};
-
-/*<END>---------- Set_Time_Constrained ------------<END>*/
-
-/*<BEGIN>---------- Time_Regulation_Enabled ------------<BEGIN>*/
-class CERTI_EXPORT NM_Time_Regulation_Enabled : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Time_Regulation_Enabled();
-	virtual ~NM_Time_Regulation_Enabled();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */	 
-
-private:
-};
-
-/*<END>---------- Time_Regulation_Enabled ------------<END>*/
-
-/*<BEGIN>---------- Time_Constrained_Enabled ------------<BEGIN>*/
-class CERTI_EXPORT NM_Time_Constrained_Enabled : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Time_Constrained_Enabled();
-	virtual ~NM_Time_Constrained_Enabled();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */	 
-
-private:
-};
-
-/*<END>---------- Time_Constrained_Enabled ------------<END>*/
-
-/*<BEGIN>---------- Start_Registration_For_Object_Class  ------------<BEGIN>*/
-class CERTI_EXPORT NM_Start_Registration_For_Object_Class : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Start_Registration_For_Object_Class();
-	virtual ~NM_Start_Registration_For_Object_Class();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	const ObjectClassHandle getObjectClass() const {return objectClass;};
-	void setObjectClass(ObjectClassHandle newObjectClass) {objectClass=newObjectClass;};
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Start_Registration_For_Object_Class ------------<END>*/
-
-/*<BEGIN>---------- Stop_Registration_For_Object_Class  ------------<BEGIN>*/
-class CERTI_EXPORT NM_Stop_Registration_For_Object_Class : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Stop_Registration_For_Object_Class();
-	virtual ~NM_Stop_Registration_For_Object_Class();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Stop_Registration_For_Object_Class ------------<END>*/
-
-/*<BEGIN>---------- Set_Class_Relevance_Advisory_Switch ------------<BEGIN>*/
-class CERTI_EXPORT NM_Set_Class_Relevance_Advisory_Switch : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Set_Class_Relevance_Advisory_Switch();
-	virtual ~NM_Set_Class_Relevance_Advisory_Switch();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-	void classRelevanceAdvisorySwitchOn() {classRelevanceAdvisorySwitch=true;};
-	void classRelevanceAdvisorySwitchOff() {classRelevanceAdvisorySwitch=false;};	
-	bool getClassRelevanceAdvisorySwitch() {return classRelevanceAdvisorySwitch;};
-protected:
-	/* specific field */
-	/* value of CRA switch */
-	bool classRelevanceAdvisorySwitch ;
-private:
-};
-
-/*<END>---------- Set_Class_Relevance_Advisory_Switch ------------<END>*/
-
-/*<BEGIN>---------- Set_Interaction_Relevance_Advisory_Switch ------------<BEGIN>*/
-class CERTI_EXPORT NM_Set_Interaction_Relevance_Advisory_Switch : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Set_Interaction_Relevance_Advisory_Switch();
-	virtual ~NM_Set_Interaction_Relevance_Advisory_Switch();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-	void interactionRelevanceAdvisorySwitchOn() { 
-		interactionRelevanceAdvisorySwitch=true;};
-	void interactionRelevanceAdvisorySwitchOff() { 
-		interactionRelevanceAdvisorySwitch=false;};	
-	bool getInteractionRelevanceAdvisorySwitch() {
-		return interactionRelevanceAdvisorySwitch;};
-protected:
-	/* specific field */
-	/* value of IRA switch */
-	bool interactionRelevanceAdvisorySwitch ;
-private:
-};
-
-/*<END>---------- Set_Interaction_Relevance_Advisory_Switch ------------<END>*/
-
-/*<BEGIN>---------- Set_Attribute_Relevance_Advisory_Switch ------------<BEGIN>*/
-class CERTI_EXPORT NM_Set_Attribute_Relevance_Advisory_Switch : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Set_Attribute_Relevance_Advisory_Switch();
-	virtual ~NM_Set_Attribute_Relevance_Advisory_Switch();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-	void attributeRelevanceAdvisorySwitchOn() {
-			attributeRelevanceAdvisorySwitch=true;};
-	void attributeRelevanceAdvisorySwitchOff() {
-			attributeRelevanceAdvisorySwitch=false;};	
-	bool getAttributeRelevanceAdvisorySwitch() {return 
-		attributeRelevanceAdvisorySwitch;};
-protected:
-	/* specific field */
-	/* value of ARA switch */
-	bool attributeRelevanceAdvisorySwitch ;
-private:
-};
-
-/*<END>---------- Set_Attribute_Relevance_Advisory_Switch ------------<END>*/
-
-/*<BEGIN>---------- Set_Attribute_Scope_Advisory_Switch ------------<BEGIN>*/
-class CERTI_EXPORT NM_Set_Attribute_Scope_Advisory_Switch : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Set_Attribute_Scope_Advisory_Switch();
-	virtual ~NM_Set_Attribute_Scope_Advisory_Switch();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-	void attributeScopeAdvisorySwitchOn() {attributeScopeAdvisorySwitch=true;};
-	void attributeScopeAdvisorySwitchOff() {attributeScopeAdvisorySwitch=false;};	
-	bool getAttributeScopeAdvisorySwitch() {return attributeScopeAdvisorySwitch;};
-protected:
-	/* specific field */
-	/* value of ASA switch */
-	bool attributeScopeAdvisorySwitch ;
-private:
-};
-
-/*<END>---------- Set_Attribute_Scope_Advisory_Switch ------------<END>*/
-
-/*<BEGIN>---------- Register_Federation_Synchronization_Point ------------<BEGIN>*/
-class CERTI_EXPORT NM_Register_Federation_Synchronization_Point : public NM_WithHandleArray {
-public:
-	typedef NM_WithHandleArray Super;
-	NM_Register_Federation_Synchronization_Point();
-	virtual ~NM_Register_Federation_Synchronization_Point();	
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);	
-	/* specific Getter/Setter */
-	void setExist() {_setExist=true;};
-	void setDoesNotExist() {_setExist=false;};		
-	bool doesSetExist() {return _setExist;};
-protected:
-	/* specific field */
-	/* tell whether if the synchronization set is specified or not */
-	bool _setExist;
-private:
-};
-
-/*<END>---------- Register_Federation_Synchronization_Point ------------<END>*/
-
-
-/*<BEGIN>---------- Synchronization_Point_Registration_Succeeded ------------<BEGIN>*/
-class CERTI_EXPORT NM_Synchronization_Point_Registration_Succeeded : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Synchronization_Point_Registration_Succeeded();
-	virtual ~NM_Synchronization_Point_Registration_Succeeded();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */	 
-
-private:
-};
-
-/*<END>---------- Synchronization_Point_Registration_Succeeded ------------<END>*/
-
-/*<BEGIN>---------- Announce_Synchronization_Point ------------<BEGIN>*/
-class CERTI_EXPORT NM_Announce_Synchronization_Point : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Announce_Synchronization_Point();
-	virtual ~NM_Announce_Synchronization_Point();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */	  
-private:
-};
-
-/*<END>---------- Announce_Synchronization_Point ------------<END>*/
-
-/*<BEGIN>---------- Synchronization_Point_Achieved ------------<BEGIN>*/
-class CERTI_EXPORT NM_Synchronization_Point_Achieved : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Synchronization_Point_Achieved();
-	virtual ~NM_Synchronization_Point_Achieved();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */	  
-private:
-};
-
-/*<END>---------- Synchronization_Point_Achieved ------------<END>*/
-
-/*<BEGIN>---------- Federation_Synchronized ------------<BEGIN>*/
-class CERTI_EXPORT NM_Federation_Synchronized : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Federation_Synchronized();
-	virtual ~NM_Federation_Synchronized();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */	 
-private:
-};
-
-/*<END>---------- Federation_Synchronized ------------<END>*/
-
-/*<BEGIN>---------- Request_Federation_Save ------------<BEGIN>*/
-class CERTI_EXPORT NM_Request_Federation_Save : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Request_Federation_Save();
-	virtual ~NM_Request_Federation_Save();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Request_Federation_Save ------------<END>*/
-
-/*<BEGIN>---------- Federate_Save_Begun ------------<BEGIN>*/
-class CERTI_EXPORT NM_Federate_Save_Begun : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Federate_Save_Begun();
-	virtual ~NM_Federate_Save_Begun();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-
-private:
-};
-
-/*<END>---------- Federate_Save_Begun ------------<END>*/
-
-/*<BEGIN>---------- Federate_Save_Complete ------------<BEGIN>*/
-class CERTI_EXPORT NM_Federate_Save_Complete : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Federate_Save_Complete();
-	virtual ~NM_Federate_Save_Complete();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Federate_Save_Complete ------------<END>*/
-
-/*<BEGIN>---------- Federate_Save_Not_Complete ------------<BEGIN>*/
-class CERTI_EXPORT NM_Federate_Save_Not_Complete : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Federate_Save_Not_Complete();
-	virtual ~NM_Federate_Save_Not_Complete();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Federate_Save_Not_Complete ------------<END>*/
-
-/*<BEGIN>---------- Initiate_Federate_Save ------------<BEGIN>*/
-class CERTI_EXPORT NM_Initiate_Federate_Save : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Initiate_Federate_Save();
-	virtual ~NM_Initiate_Federate_Save();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Initiate_Federate_Save ------------<END>*/
-
-/*<BEGIN>---------- Federation_Saved ------------<BEGIN>*/
-class CERTI_EXPORT NM_Federation_Saved : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Federation_Saved();
-	virtual ~NM_Federation_Saved();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Federation_Saved ------------<END>*/
-
-/*<BEGIN>---------- Federation_Not_Saved ------------<BEGIN>*/
-class CERTI_EXPORT NM_Federation_Not_Saved : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Federation_Not_Saved();
-	virtual ~NM_Federation_Not_Saved();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Federation_Not_Saved ------------<END>*/
-
-/*<BEGIN>---------- Request_Federation_Restore ------------<BEGIN>*/
-class CERTI_EXPORT NM_Request_Federation_Restore : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Request_Federation_Restore();
-	virtual ~NM_Request_Federation_Restore();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-
-private:
-};
-
-/*<END>---------- Request_Federation_Restore ------------<END>*/
-
-/*<BEGIN>---------- Federate_Restore_Complete ------------<BEGIN>*/
-class CERTI_EXPORT NM_Federate_Restore_Complete : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Federate_Restore_Complete();
-	virtual ~NM_Federate_Restore_Complete();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Federate_Restore_Complete ------------<END>*/
-
-/*<BEGIN>---------- Federate_Restore_Not_Complete ------------<BEGIN>*/
-class CERTI_EXPORT NM_Federate_Restore_Not_Complete : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Federate_Restore_Not_Complete();
-	virtual ~NM_Federate_Restore_Not_Complete();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Federate_Restore_Not_Complete ------------<END>*/
-
-/*<BEGIN>---------- Request_Federation_Restore_Succeeded ------------<BEGIN>*/
-class CERTI_EXPORT NM_Request_Federation_Restore_Succeeded : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Request_Federation_Restore_Succeeded();
-	virtual ~NM_Request_Federation_Restore_Succeeded();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Request_Federation_Restore_Succeeded ------------<END>*/
-
-/*<BEGIN>---------- Request_Federation_Restore_Failed ------------<BEGIN>*/
-class CERTI_EXPORT NM_Request_Federation_Restore_Failed : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Request_Federation_Restore_Failed();
-	virtual ~NM_Request_Federation_Restore_Failed();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Request_Federation_Restore_Failed ------------<END>*/
-
-/*<BEGIN>---------- Federation_Restore_Begun ------------<BEGIN>*/
-class CERTI_EXPORT NM_Federation_Restore_Begun : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Federation_Restore_Begun();
-	virtual ~NM_Federation_Restore_Begun();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Federation_Restore_Begun ------------<END>*/
-
-/*<BEGIN>---------- Initiate_Federate_Restore ------------<BEGIN>*/
-class CERTI_EXPORT NM_Initiate_Federate_Restore : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Initiate_Federate_Restore();
-	virtual ~NM_Initiate_Federate_Restore();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Initiate_Federate_Restore ------------<END>*/
-
-/*<BEGIN>---------- Federation_Restored ------------<BEGIN>*/
-class CERTI_EXPORT NM_Federation_Restored : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Federation_Restored();
-	virtual ~NM_Federation_Restored();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Federation_Restored ------------<END>*/
-
-/*<BEGIN>---------- Federation_Not_Restored ------------<BEGIN>*/
-class CERTI_EXPORT NM_Federation_Not_Restored : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Federation_Not_Restored();
-	virtual ~NM_Federation_Not_Restored();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Federation_Not_Restored ------------<END>*/
-
-/*<BEGIN>---------- Publish_Object_Class ------------<BEGIN>*/
-class CERTI_EXPORT NM_Publish_Object_Class : public NM_WithHandleArray {
-public:
-	typedef NM_WithHandleArray Super;
-	NM_Publish_Object_Class();
-	virtual ~NM_Publish_Object_Class();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-	//ObjectClassHandle objectClass;
-private:
-};
-
-/*<END>---------- Publish_Object_Class ------------<END>*/
-
-/*<BEGIN>---------- Unpublish_Object_Class ------------<BEGIN>*/
-class CERTI_EXPORT NM_Unpublish_Object_Class : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Unpublish_Object_Class();
-	virtual ~NM_Unpublish_Object_Class();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-	//	ObjectClassHandle objectClass;
-private:
-};
-
-/*<END>---------- Unpublish_Object_Class ------------<END>*/
-
-/*<BEGIN>---------- Publish_Interaction_Class ------------<BEGIN>*/
-class CERTI_EXPORT NM_Publish_Interaction_Class : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Publish_Interaction_Class();
-	virtual ~NM_Publish_Interaction_Class();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-	const InteractionClassHandle getInteractionClassHandle() const {return interactionClass;};
-	void setInteractionClassHandle(InteractionClassHandle newInteractionClass) {interactionClass=newInteractionClass;};
-protected:
-	/* specific field */
-	//	InteractionClassHandle interactionClass;
-private:
-};
-
-/*<END>---------- Publish_Interaction_Class ------------<END>*/
-
-/*<BEGIN>---------- Unpublish_Interaction_Class ------------<BEGIN>*/
-class CERTI_EXPORT NM_Unpublish_Interaction_Class : public NM_Publish_Interaction_Class {
-public:
-	typedef NM_Publish_Interaction_Class Super;
-	NM_Unpublish_Interaction_Class();
-	virtual ~NM_Unpublish_Interaction_Class();	
-	/* specific Getter/Setter */
-protected:
-	/* specific field */	
-private:
-};
-
-/*<END>---------- Unpublish_Interaction_Class ------------<END>*/
-
-/*<BEGIN>---------- Subscribe_Object_Class ------------<BEGIN>*/
-class CERTI_EXPORT NM_Subscribe_Object_Class : public NM_WithHandleArray {
-public:
-	typedef NM_WithHandleArray Super;
-	NM_Subscribe_Object_Class();
-	virtual ~NM_Subscribe_Object_Class();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-	//ObjectClassHandle objectClass;
-private:
-};
-
-/*<END>---------- Subscribe_Object_Class ------------<END>*/
-
-/*<BEGIN>---------- Unsubscribe_Object_Class ------------<BEGIN>*/
-class CERTI_EXPORT NM_Unsubscribe_Object_Class : public NM_Unpublish_Object_Class {
-public:
-	typedef NM_Unpublish_Object_Class Super;
-	NM_Unsubscribe_Object_Class();
-	virtual ~NM_Unsubscribe_Object_Class();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */	
-private:
-};
-
-/*<END>---------- Unsubscribe_Object_Class ------------<END>*/
-
-/*<BEGIN>---------- Subscribe_Interaction_Class ------------<BEGIN>*/
-class CERTI_EXPORT NM_Subscribe_Interaction_Class : public NM_Publish_Interaction_Class {
-public:
-	typedef NM_Publish_Interaction_Class Super;
-	NM_Subscribe_Interaction_Class();
-	virtual ~NM_Subscribe_Interaction_Class();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Subscribe_Interaction_Class ------------<END>*/
-
-/*<BEGIN>---------- Unsubscribe_Interaction_Class ------------<BEGIN>*/
-class CERTI_EXPORT NM_Unsubscribe_Interaction_Class : public NM_Publish_Interaction_Class {
-public:
-	typedef NM_Publish_Interaction_Class Super;
-	NM_Unsubscribe_Interaction_Class();
-	virtual ~NM_Unsubscribe_Interaction_Class();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Unsubscribe_Interaction_Class ------------<END>*/
-
-/*<BEGIN>---------- Turn_Interactions_On ------------<BEGIN>*/
-class CERTI_EXPORT NM_Turn_Interactions_On : public NM_Publish_Interaction_Class {
-public:
-	typedef NM_Publish_Interaction_Class Super;
-	NM_Turn_Interactions_On();
-	virtual ~NM_Turn_Interactions_On();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Turn_Interactions_On ------------<END>*/
-
-/*<BEGIN>---------- Turn_Interactions_Off ------------<BEGIN>*/
-class CERTI_EXPORT NM_Turn_Interactions_Off : public NM_Publish_Interaction_Class {
-public:
-	typedef NM_Publish_Interaction_Class Super;
-	NM_Turn_Interactions_Off();
-	virtual ~NM_Turn_Interactions_Off();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Turn_Interactions_Off ------------<END>*/
-
-/*<BEGIN>---------- Register_Object ------------<BEGIN>*/
-class CERTI_EXPORT NM_Register_Object : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Register_Object();
-	virtual ~NM_Register_Object();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-	//	ObjectHandle object;
-private:
-};
-
-/*<END>---------- Register_Object ------------<END>*/
-
-/*<BEGIN>---------- Discover_Object ------------<BEGIN>*/
-class CERTI_EXPORT NM_Discover_Object : public NM_Register_Object {
-public:
-	typedef NM_Register_Object Super;
-	NM_Discover_Object();
-	virtual ~NM_Discover_Object();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Discover_Object ------------<END>*/
-
-/*<BEGIN>---------- Update_Attribute_Values ------------<BEGIN>*/
-class CERTI_EXPORT NM_Update_Attribute_Values : public NM_WithHandleArray {
-public:
-	typedef NM_WithHandleArray Super;
-	NM_Update_Attribute_Values();
-	virtual ~NM_Update_Attribute_Values();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-	//	ObjectClassHandle objectClass;	
-private:
-};
-
-/*<END>---------- Update_Attribute_Values ------------<END>*/
-
-/*<BEGIN>---------- Reflect_Attribute_Values ------------<BEGIN>*/
-class CERTI_EXPORT NM_Reflect_Attribute_Values : public NM_Update_Attribute_Values {
-public:
-	typedef NM_Update_Attribute_Values Super;
-	NM_Reflect_Attribute_Values();
-	virtual ~NM_Reflect_Attribute_Values();       
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Reflect_Attribute_Values ------------<END>*/
-
-/*<BEGIN>---------- Send_Interaction ------------<BEGIN>*/
-class CERTI_EXPORT NM_Send_Interaction : public NM_WithHandleArray {
-public:
-	typedef NM_WithHandleArray Super;
-	NM_Send_Interaction();
-	virtual ~NM_Send_Interaction();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-	//	InteractionClassHandle interactionClass;	
-private:
-};
-
-/*<END>---------- Send_Interaction ------------<END>*/
-
-/*<BEGIN>---------- Receive_Interaction ------------<BEGIN>*/
-class CERTI_EXPORT NM_Receive_Interaction : public NM_Send_Interaction {
-public:
-	typedef NM_Send_Interaction Super;
-	NM_Receive_Interaction();
-	virtual ~NM_Receive_Interaction();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Receive_Interaction ------------<END>*/
-
-/*<BEGIN>---------- Delete_Object ------------<BEGIN>*/
-class CERTI_EXPORT NM_Delete_Object : public NM_Register_Object {
-public:
-	typedef NM_Register_Object Super;
-	NM_Delete_Object();
-	virtual ~NM_Delete_Object();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-
-private:
-};
-
-/*<END>---------- Delete_Object ------------<END>*/
-
-/*<BEGIN>---------- Remove_Object ------------<BEGIN>*/
-class CERTI_EXPORT NM_Remove_Object : public NM_Delete_Object {
-public:
-	typedef NM_Delete_Object Super;
-	NM_Remove_Object();
-	virtual ~NM_Remove_Object();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Remove_Object ------------<END>*/
-
-/*<BEGIN>---------- Change_Attribute_Transport_Type ------------<BEGIN>*/
-class CERTI_EXPORT NM_Change_Attribute_Transport_Type : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Change_Attribute_Transport_Type();
-	virtual ~NM_Change_Attribute_Transport_Type();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Change_Attribute_Transport_Type ------------<END>*/
-
-/*<BEGIN>---------- Change_Attribute_Order_Type ------------<BEGIN>*/
-class CERTI_EXPORT NM_Change_Attribute_Order_Type : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Change_Attribute_Order_Type();
-	virtual ~NM_Change_Attribute_Order_Type();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Change_Attribute_Order_Type ------------<END>*/
-
-/*<BEGIN>---------- Change_Interaction_Transport_Type ------------<BEGIN>*/
-class CERTI_EXPORT NM_Change_Interaction_Transport_Type : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Change_Interaction_Transport_Type();
-	virtual ~NM_Change_Interaction_Transport_Type();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Change_Interaction_Transport_Type ------------<END>*/
-
-/*<BEGIN>---------- Change_Interaction_Order_Type ------------<BEGIN>*/
-class CERTI_EXPORT NM_Change_Interaction_Order_Type : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Change_Interaction_Order_Type();
-	virtual ~NM_Change_Interaction_Order_Type();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Change_Interaction_Order_Type ------------<END>*/
-
-/*<BEGIN>---------- Request_Class_Attribute_Value_Update ------------<BEGIN>*/
-class CERTI_EXPORT NM_Request_Class_Attribute_Value_Update : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Request_Class_Attribute_Value_Update();
-	virtual ~NM_Request_Class_Attribute_Value_Update();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Request_Class_Attribute_Value_Update ------------<END>*/
-
-/*<BEGIN>---------- Request_Object_Attribute_Value_Update ------------<BEGIN>*/
-class CERTI_EXPORT NM_Request_Object_Attribute_Value_Update : public NM_WithHandleArray {
-public:
-	typedef NM_WithHandleArray Super;
-	NM_Request_Object_Attribute_Value_Update();
-	virtual ~NM_Request_Object_Attribute_Value_Update();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-	const ObjectHandle getObject() const {return object;};
-	void setObject(ObjectHandle newObject) {object=newObject;};
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Request_Object_Attribute_Value_Update ------------<END>*/
-
-/*<BEGIN>---------- Is_Attribute_Owned_By_Federate ------------<BEGIN>*/
-class CERTI_EXPORT NM_Is_Attribute_Owned_By_Federate : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Is_Attribute_Owned_By_Federate();
-	virtual ~NM_Is_Attribute_Owned_By_Federate();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-	AttributeHandle getAttribute() const {return attribute;};
-	void setAttribute(AttributeHandle newAttribute) {attribute=newAttribute;};
-protected:
-	/* specific field */
-	//	ObjectHandle    object;
-	AttributeHandle attribute;
-private:
-};
-
-/*<END>---------- Is_Attribute_Owned_By_Federate ------------<END>*/
-
-/*<BEGIN>---------- Query_Attribute_Ownership ------------<BEGIN>*/
-class CERTI_EXPORT NM_Query_Attribute_Ownership : public NM_Is_Attribute_Owned_By_Federate {
-public:
-	typedef NM_Is_Attribute_Owned_By_Federate Super;
-	NM_Query_Attribute_Ownership();
-	virtual ~NM_Query_Attribute_Ownership();      
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Query_Attribute_Ownership ------------<END>*/
-
-/*<BEGIN>---------- Attribute_Is_Not_Owned ------------<BEGIN>*/
-class CERTI_EXPORT NM_Attribute_Is_Not_Owned : public NM_Is_Attribute_Owned_By_Federate {
-public:
-	typedef NM_Is_Attribute_Owned_By_Federate Super;
-	NM_Attribute_Is_Not_Owned();
-	virtual ~NM_Attribute_Is_Not_Owned();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Attribute_Is_Not_Owned ------------<END>*/
-
-/*<BEGIN>---------- Inform_Attribute_Ownership ------------<BEGIN>*/
-class CERTI_EXPORT NM_Inform_Attribute_Ownership : public NM_Is_Attribute_Owned_By_Federate {
-public:
-	typedef NM_Is_Attribute_Owned_By_Federate Super;
-	NM_Inform_Attribute_Ownership();
-	virtual ~NM_Inform_Attribute_Ownership();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Inform_Attribute_Ownership ------------<END>*/
-
-/*<BEGIN>---------- Negotiated_Attribute_Ownership_Divestiture ------------<BEGIN>*/
-class CERTI_EXPORT NM_Negotiated_Attribute_Ownership_Divestiture : public NM_Request_Object_Attribute_Value_Update {
-public:
-	typedef NM_Request_Object_Attribute_Value_Update Super;
-	NM_Negotiated_Attribute_Ownership_Divestiture();
-	virtual ~NM_Negotiated_Attribute_Ownership_Divestiture();
-	/* specific Getter/Setter */	
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Negotiated_Attribute_Ownership_Divestiture ------------<END>*/
-
-/*<BEGIN>---------- Attribute_Ownership_Acquisition_Notification ------------<BEGIN>*/
-class CERTI_EXPORT NM_Attribute_Ownership_Acquisition_Notification : public NM_Request_Object_Attribute_Value_Update {
-public:
-	typedef NM_Request_Object_Attribute_Value_Update Super;
-	NM_Attribute_Ownership_Acquisition_Notification();
-	virtual ~NM_Attribute_Ownership_Acquisition_Notification();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Attribute_Ownership_Acquisition_Notification ------------<END>*/
-
-/*<BEGIN>---------- Attribute_Ownership_Divestiture_Notification ------------<BEGIN>*/
-class CERTI_EXPORT NM_Attribute_Ownership_Divestiture_Notification : public NM_Request_Object_Attribute_Value_Update {
-public:
-	typedef NM_Request_Object_Attribute_Value_Update Super;
-	NM_Attribute_Ownership_Divestiture_Notification();
-	virtual ~NM_Attribute_Ownership_Divestiture_Notification();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Attribute_Ownership_Divestiture_Notification ------------<END>*/
-
-/*<BEGIN>---------- Request_Attribute_Ownership_Assumption ------------<BEGIN>*/
-class CERTI_EXPORT NM_Request_Attribute_Ownership_Assumption : public NM_Negotiated_Attribute_Ownership_Divestiture {
-public:
-	typedef NM_Negotiated_Attribute_Ownership_Divestiture Super;
-	NM_Request_Attribute_Ownership_Assumption();
-	virtual ~NM_Request_Attribute_Ownership_Assumption();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Request_Attribute_Ownership_Assumption ------------<END>*/
-
-/*<BEGIN>---------- Attribute_Ownership_Unavailable ------------<BEGIN>*/
-class CERTI_EXPORT NM_Attribute_Ownership_Unavailable : public NM_Request_Object_Attribute_Value_Update {
-public:
-	typedef NM_Request_Object_Attribute_Value_Update Super;
-	NM_Attribute_Ownership_Unavailable();
-	virtual ~NM_Attribute_Ownership_Unavailable();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Attribute_Ownership_Unavailable ------------<END>*/
-
-/*<BEGIN>---------- Attribute_Ownership_Acquisition_If_Available ------------<BEGIN>*/
-class CERTI_EXPORT NM_Attribute_Ownership_Acquisition_If_Available : public NM_Request_Object_Attribute_Value_Update {
-public:
-	typedef NM_Request_Object_Attribute_Value_Update Super;
-	NM_Attribute_Ownership_Acquisition_If_Available();
-	virtual ~NM_Attribute_Ownership_Acquisition_If_Available();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Attribute_Ownership_Acquisition_If_Available ------------<END>*/
-
-/*<BEGIN>---------- Unconditional_Attribute_Ownership_Divestiture ------------<BEGIN>*/
-class CERTI_EXPORT NM_Unconditional_Attribute_Ownership_Divestiture : public NM_Request_Object_Attribute_Value_Update {
-public:
-	typedef NM_Request_Object_Attribute_Value_Update Super;
-	NM_Unconditional_Attribute_Ownership_Divestiture();
-	virtual ~NM_Unconditional_Attribute_Ownership_Divestiture();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Unconditional_Attribute_Ownership_Divestiture ------------<END>*/
-
-/*<BEGIN>---------- Attribute_Ownership_Acquisition ------------<BEGIN>*/
-class CERTI_EXPORT NM_Attribute_Ownership_Acquisition : public NM_Negotiated_Attribute_Ownership_Divestiture {
-public:
-	typedef NM_Negotiated_Attribute_Ownership_Divestiture Super;
-	NM_Attribute_Ownership_Acquisition();
-	virtual ~NM_Attribute_Ownership_Acquisition();	
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Attribute_Ownership_Acquisition ------------<END>*/
-
-/*<BEGIN>---------- Request_Attribute_Ownership_Release ------------<BEGIN>*/
-class CERTI_EXPORT NM_Request_Attribute_Ownership_Release : public NM_Negotiated_Attribute_Ownership_Divestiture {
-public:
-	typedef NM_Negotiated_Attribute_Ownership_Divestiture Super;
-	NM_Request_Attribute_Ownership_Release();
-	virtual ~NM_Request_Attribute_Ownership_Release();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Request_Attribute_Ownership_Release ------------<END>*/
-
-/*<BEGIN>---------- Cancel_Negotiated_Attribute_Ownership_Divestiture ------------<BEGIN>*/
-class CERTI_EXPORT NM_Cancel_Negotiated_Attribute_Ownership_Divestiture : public NM_Request_Object_Attribute_Value_Update {
-public:
-	typedef NM_Request_Object_Attribute_Value_Update Super;
-	NM_Cancel_Negotiated_Attribute_Ownership_Divestiture();
-	virtual ~NM_Cancel_Negotiated_Attribute_Ownership_Divestiture();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Cancel_Negotiated_Attribute_Ownership_Divestiture ------------<END>*/
-
-/*<BEGIN>---------- Attribute_Ownership_Release_Response ------------<BEGIN>*/
-class CERTI_EXPORT NM_Attribute_Ownership_Release_Response : public NM_Request_Object_Attribute_Value_Update {
-public:
-	typedef NM_Request_Object_Attribute_Value_Update Super;
-	NM_Attribute_Ownership_Release_Response();
-	virtual ~NM_Attribute_Ownership_Release_Response();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Attribute_Ownership_Release_Response ------------<END>*/
-
-/*<BEGIN>---------- Cancel_Attribute_Ownership_Acquisition ------------<BEGIN>*/
-class CERTI_EXPORT NM_Cancel_Attribute_Ownership_Acquisition : public NM_Request_Object_Attribute_Value_Update {
-public:
-	typedef NM_Request_Object_Attribute_Value_Update Super;
-	NM_Cancel_Attribute_Ownership_Acquisition();
-	virtual ~NM_Cancel_Attribute_Ownership_Acquisition();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Cancel_Attribute_Ownership_Acquisition ------------<END>*/
-
-/*<BEGIN>---------- Confirm_Attribute_Ownership_Acquisition_Cancellation ------------<BEGIN>*/
-class CERTI_EXPORT NM_Confirm_Attribute_Ownership_Acquisition_Cancellation : public NM_Request_Object_Attribute_Value_Update {
-public:
-	typedef NM_Request_Object_Attribute_Value_Update Super;
-	NM_Confirm_Attribute_Ownership_Acquisition_Cancellation();
-	virtual ~NM_Confirm_Attribute_Ownership_Acquisition_Cancellation();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Confirm_Attribute_Ownership_Acquisition_Cancellation ------------<END>*/
-
-/*<BEGIN>---------- DDM_Create_Region ------------<BEGIN>*/
-class CERTI_EXPORT NM_DDM_Create_Region : public NM_DDM_Base {
-public:
-	typedef NM_DDM_Base Super;
-	NM_DDM_Create_Region();
-	virtual ~NM_DDM_Create_Region();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-	const SpaceHandle getSpace() const {return space;};
-	void setSpace(SpaceHandle newSpace) {space=newSpace;};	
-	const int32_t getRegion() const {return region;};
-	void setRegion(SpaceHandle newRegion) {region=newRegion;};
-protected:
-	/* specific field */
-	//	SpaceHandle space;
-	//	int32_t nbExtents;
-	//	int32_t region;	
-private:
-};
-
-/*<END>---------- DDM_Create_Region ------------<END>*/
-
-/*<BEGIN>---------- DDM_Modify_Region ------------<BEGIN>*/
-class CERTI_EXPORT NM_DDM_Modify_Region : public NM_DDM_Base {
-public:
-	typedef NM_DDM_Base Super;
-	NM_DDM_Modify_Region();
-	virtual ~NM_DDM_Modify_Region();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-	const int32_t getRegion() const {return region;};
-	void setRegion(SpaceHandle newRegion) {region=newRegion;};
-protected:
-	/* specific field */
-	//	int32_t region;
-private:
-};
-
-/*<END>---------- DDM_Modify_Region ------------<END>*/
-
-/*<BEGIN>---------- DDM_Delete_Region ------------<BEGIN>*/
-class CERTI_EXPORT NM_DDM_Delete_Region : public NM_DDM_Base {
-public:
-	typedef NM_DDM_Base Super;
-	NM_DDM_Delete_Region();
-	virtual ~NM_DDM_Delete_Region();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-	const int32_t getRegion() const {return region;};
-	void setRegion(SpaceHandle newRegion) {region=newRegion;};
-protected:
-	/* specific field */
-	//	int32_t region;	
-private:
-};
-
-/*<END>---------- DDM_Delete_Region ------------<END>*/
-
-/*<BEGIN>---------- DDM_Associate_Region ------------<BEGIN>*/
-class CERTI_EXPORT NM_DDM_Associate_Region : public NM_DDM_Base {
-public:
-	typedef NM_DDM_Base Super;
-	NM_DDM_Associate_Region();
-	virtual ~NM_DDM_Associate_Region();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-	const int32_t getRegion() const {return region;};
-	void setRegion(SpaceHandle newRegion) {region=newRegion;};
-	const ObjectHandle getObject() const {return object;};
-	void setObject(ObjectHandle newObject) {object=newObject;};
-protected:
-	/* specific field */
-	//	int32_t      region;
-	//	ObjectHandle object;
-private:
-};
-
-/*<END>---------- DDM_Associate_Region ------------<END>*/
-
-/*<BEGIN>---------- DDM_Register_Object ------------<BEGIN>*/
-class CERTI_EXPORT NM_DDM_Register_Object : public NM_DDM_Base {
-public:
-	typedef NM_DDM_Base Super;
-	NM_DDM_Register_Object();
-	virtual ~NM_DDM_Register_Object();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- DDM_Register_Object ------------<END>*/
-
-/*<BEGIN>---------- DDM_Unassociate_Region ------------<BEGIN>*/
-class CERTI_EXPORT NM_DDM_Unassociate_Region : public NM_DDM_Base {
-public:
-	typedef NM_DDM_Base Super;
-	NM_DDM_Unassociate_Region();
-	virtual ~NM_DDM_Unassociate_Region();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- DDM_Unassociate_Region ------------<END>*/
-
-/*<BEGIN>---------- DDM_Subscribe_Attributes ------------<BEGIN>*/
-class CERTI_EXPORT NM_DDM_Subscribe_Attributes : public NM_DDM_Base {
-public:
-	typedef NM_DDM_Base Super;
-	NM_DDM_Subscribe_Attributes();
-	virtual ~NM_DDM_Subscribe_Attributes();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- DDM_Subscribe_Attributes ------------<END>*/
-
-/*<BEGIN>---------- DDM_Unsubscribe_Attributes ------------<BEGIN>*/
-class CERTI_EXPORT NM_DDM_Unsubscribe_Attributes : public NM_DDM_Base {
-public:
-	typedef NM_DDM_Base Super;
-	NM_DDM_Unsubscribe_Attributes();
-	virtual ~NM_DDM_Unsubscribe_Attributes();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- DDM_Unsubscribe_Attributes ------------<END>*/
-
-/*<BEGIN>---------- DDM_Subscribe_Interaction ------------<BEGIN>*/
-class CERTI_EXPORT NM_DDM_Subscribe_Interaction : public NM_DDM_Base {
-public:
-	typedef NM_DDM_Base Super;
-	NM_DDM_Subscribe_Interaction();
-	virtual ~NM_DDM_Subscribe_Interaction();
-	virtual void serialize(MessageBuffer& msgBuffer);
-	virtual void deserialize(MessageBuffer& msgBuffer);
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- DDM_Subscribe_Interaction ------------<END>*/
-
-/*<BEGIN>---------- DDM_Unsubscribe_Interaction ------------<BEGIN>*/
-class CERTI_EXPORT NM_DDM_Unsubscribe_Interaction : public NM_DDM_Subscribe_Interaction {
-public:
-	typedef NM_DDM_Subscribe_Interaction Super;
-	NM_DDM_Unsubscribe_Interaction();
-	virtual ~NM_DDM_Unsubscribe_Interaction();	
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- DDM_Unsubscribe_Interaction ------------<END>*/
-
-/*<BEGIN>---------- Provide_Attribute_Value_Update ------------<BEGIN>*/
-class CERTI_EXPORT NM_Provide_Attribute_Value_Update : public NM_Request_Object_Attribute_Value_Update {
-public:
-	typedef NM_Request_Object_Attribute_Value_Update Super;
-	NM_Provide_Attribute_Value_Update();
-	virtual ~NM_Provide_Attribute_Value_Update();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Provide_Attribute_Value_Update ------------<END>*/
-
-/*<BEGIN>---------- Last ------------<BEGIN>*/
-class CERTI_EXPORT NM_Last : public NetworkMessage {
-public:
-	typedef NetworkMessage Super;
-	NM_Last();
-	virtual ~NM_Last();
-	/* specific Getter/Setter */
-protected:
-	/* specific field */
-private:
-};
-
-/*<END>---------- Last ------------<END>*/
 
-} /* end of namespace certi */
+   // Native types has been defined:
+   //     - by included headers (see above)
+   //     - with typedef (see below [if any])
+
+   typedef Socket* NMStreamType;
+
+   typedef NetworkMessage::Type NM_Type;
+   namespace CERTI_NetworkMessage {
+      static const uint32_t versionMajor = 1;
+      static const uint32_t versionMinor = 0;
+
+      typedef enum CERTI_NetworkMessage_MessageType {
+         NOT_USED = 0, 
+         NM_CLOSE_CONNEXION, 
+         NM_MESSAGE_NULL, 
+         NM_CREATE_FEDERATION_EXECUTION, 
+         NM_DESTROY_FEDERATION_EXECUTION, 
+         NM_JOIN_FEDERATION_EXECUTION, 
+         NM_RESIGN_FEDERATION_EXECUTION, 
+         NM_SET_TIME_REGULATING, 
+         NM_SET_TIME_CONSTRAINED, 
+         NM_TIME_REGULATION_ENABLED, 
+         NM_TIME_CONSTRAINED_ENABLED, 
+         NM_SET_CLASS_RELEVANCE_ADVISORY_SWITCH, 
+         NM_SET_INTERACTION_RELEVANCE_ADVISORY_SWITCH, 
+         NM_SET_ATTRIBUTE_RELEVANCE_ADVISORY_SWITCH, 
+         NM_SET_ATTRIBUTE_SCOPE_ADVISORY_SWITCH, 
+         NM_REGISTER_FEDERATION_SYNCHRONIZATION_POINT, 
+         NM_SYNCHRONIZATION_POINT_REGISTRATION_SUCCEEDED, 
+         NM_ANNOUNCE_SYNCHRONIZATION_POINT, 
+         NM_SYNCHRONIZATION_POINT_ACHIEVED, 
+         NM_FEDERATION_SYNCHRONIZED, 
+         NM_REQUEST_FEDERATION_SAVE, 
+         NM_FEDERATE_SAVE_BEGUN, 
+         NM_FEDERATE_SAVE_COMPLETE, 
+         NM_FEDERATE_SAVE_NOT_COMPLETE, 
+         NM_INITIATE_FEDERATE_SAVE, 
+         NM_FEDERATION_SAVED, 
+         NM_FEDERATION_NOT_SAVED, 
+         NM_REQUEST_FEDERATION_RESTORE, 
+         NM_FEDERATE_RESTORE_COMPLETE, 
+         NM_FEDERATE_RESTORE_NOT_COMPLETE, 
+         NM_REQUEST_FEDERATION_RESTORE_SUCCEEDED, 
+         NM_REQUEST_FEDERATION_RESTORE_FAILED, 
+         NM_FEDERATION_RESTORE_BEGUN, 
+         NM_INITIATE_FEDERATE_RESTORE, 
+         NM_FEDERATION_RESTORED, 
+         NM_FEDERATION_NOT_RESTORED, 
+         NM_PUBLISH_OBJECT_CLASS, 
+         NM_UNPUBLISH_OBJECT_CLASS, 
+         NM_PUBLISH_INTERACTION_CLASS, 
+         NM_UNPUBLISH_INTERACTION_CLASS, 
+         NM_SUBSCRIBE_OBJECT_CLASS, 
+         NM_UNSUBSCRIBE_OBJECT_CLASS, 
+         NM_SUBSCRIBE_INTERACTION_CLASS, 
+         NM_UNSUBSCRIBE_INTERACTION_CLASS, 
+         NM_TURN_INTERACTIONS_ON, 
+         NM_TURN_INTERACTIONS_OFF, 
+         NM_REGISTER_OBJECT, 
+         NM_DISCOVER_OBJECT, 
+         NM_UPDATE_ATTRIBUTE_VALUES, 
+         NM_REFLECT_ATTRIBUTE_VALUES, 
+         NM_SEND_INTERACTION, 
+         NM_RECEIVE_INTERACTION, 
+         NM_DELETE_OBJECT, 
+         NM_REMOVE_OBJECT, 
+         NM_CHANGE_ATTRIBUTE_TRANSPORT_TYPE, 
+         NM_CHANGE_ATTRIBUTE_ORDER_TYPE, 
+         NM_CHANGE_INTERACTION_TRANSPORT_TYPE, 
+         NM_CHANGE_INTERACTION_ORDER_TYPE, 
+         NM_REQUEST_CLASS_ATTRIBUTE_VALUE_UPDATE, 
+         NM_REQUEST_OBJECT_ATTRIBUTE_VALUE_UPDATE, 
+         NM_IS_ATTRIBUTE_OWNED_BY_FEDERATE, 
+         NM_QUERY_ATTRIBUTE_OWNERSHIP, 
+         NM_ATTRIBUTE_IS_NOT_OWNED, 
+         NM_INFORM_ATTRIBUTE_OWNERSHIP, 
+         NM_ATTRIBUTE_OWNERSHIP_BASE, 
+         NM_NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE, 
+         NM_ATTRIBUTE_OWNERSHIP_ACQUISITION_NOTIFICATION, 
+         NM_ATTRIBUTE_OWNERSHIP_DIVESTITURE_NOTIFICATION, 
+         NM_REQUEST_ATTRIBUTE_OWNERSHIP_ASSUMPTION, 
+         NM_ATTRIBUTE_OWNERSHIP_UNAVAILABLE, 
+         NM_ATTRIBUTE_OWNERSHIP_ACQUISITION_IF_AVAILABLE, 
+         NM_UNCONDITIONAL_ATTRIBUTE_OWNERSHIP_DIVESTITURE, 
+         NM_ATTRIBUTE_OWNERSHIP_ACQUISITION, 
+         NM_REQUEST_ATTRIBUTE_OWNERSHIP_RELEASE, 
+         NM_CANCEL_NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE, 
+         NM_ATTRIBUTE_OWNERSHIP_RELEASE_RESPONSE, 
+         NM_CANCEL_ATTRIBUTE_OWNERSHIP_ACQUISITION, 
+         NM_CONFIRM_ATTRIBUTE_OWNERSHIP_ACQUISITION_CANCELLATION, 
+         NM_DDM_CREATE_REGION, 
+         NM_DDM_MODIFY_REGION, 
+         NM_DDM_DELETE_REGION, 
+         NM_DDM_ASSOCIATE_REGION, 
+         NM_DDM_UNASSOCIATE_REGION, 
+         NM_DDM_REGISTER_OBJECT, 
+         NM_DDM_SUBSCRIBE_ATTRIBUTES, 
+         NM_DDM_UNSUBSCRIBE_ATTRIBUTES, 
+         NM_DDM_SUBSCRIBE_INTERACTION, 
+         NM_DDM_UNSUBSCRIBE_INTERACTION, 
+         NM_PROVIDE_ATTRIBUTE_VALUE_UPDATE, 
+         NM_START_REGISTRATION_FOR_OBJECT_CLASS, 
+         NM_STOP_REGISTRATION_FOR_OBJECT_CLASS, 
+         LAST 
+      } CERTI_NetworkMessage_MessageType_t; //end of enum CERTI_NetworkMessage_MessageType 
+   }
+   // The EventRetraction is not inheriting from base "Message"
+   // this is a plain message which may be used as field
+   // in messages merging from "Message". As such
+   // it won't appear in the generated factory method.
+   // It's a convenient way to describe a structured native
+   // message using "combine". 
+   //message EventRetraction {
+   //    required FederateHandle sendingFederate {default = 0}
+   //    required uint64         SN              {default = 0}
+   //}
+   class CERTI_EXPORT NM_FOM_Dimension {
+      public:
+         NM_FOM_Dimension();
+         ~NM_FOM_Dimension();
+         void serialize(MessageBuffer& msgBuffer);
+         void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const DimensionHandle& getHandle() const {return handle;}
+         void setHandle(const DimensionHandle& newHandle) {handle=newHandle;}
+         const std::string& getName() const {return name;}
+         void setName(const std::string& newName) {name=newName;}
+         // the show method
+         void show(std::ostream& out);
+      protected:
+         DimensionHandle handle;
+         std::string name;
+      private:
+   };
+
+   class CERTI_EXPORT NM_FOM_Routing_Space {
+      public:
+         NM_FOM_Routing_Space();
+         ~NM_FOM_Routing_Space();
+         void serialize(MessageBuffer& msgBuffer);
+         void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const SpaceHandle& getSpace() const {return space;}
+         void setSpace(const SpaceHandle& newSpace) {space=newSpace;}
+         const std::string& getName() const {return name;}
+         void setName(const std::string& newName) {name=newName;}
+         uint32_t getDimensionsSize() const {return dimensions.size();}
+         void setDimensionsSize(uint32_t num) {dimensions.resize(num);}
+         const std::vector<NM_FOM_Dimension>& getDimensions() const {return dimensions;}
+         const NM_FOM_Dimension& getDimensions(uint32_t rank) const {return dimensions[rank];}
+         NM_FOM_Dimension& getDimensions(uint32_t rank) {return dimensions[rank];}
+         void setDimensions(const NM_FOM_Dimension& newDimensions, uint32_t rank) {dimensions[rank]=newDimensions;}
+         void removeDimensions(uint32_t rank) {dimensions.erase(dimensions.begin() + rank);}
+         // the show method
+         void show(std::ostream& out);
+      protected:
+         SpaceHandle space;
+         std::string name;
+         std::vector<NM_FOM_Dimension> dimensions;
+      private:
+   };
+
+   class CERTI_EXPORT NM_FOM_Attribute {
+      public:
+         NM_FOM_Attribute();
+         ~NM_FOM_Attribute();
+         void serialize(MessageBuffer& msgBuffer);
+         void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const AttributeHandle& getHandle() const {return handle;}
+         void setHandle(const AttributeHandle& newHandle) {handle=newHandle;}
+         const std::string& getName() const {return name;}
+         void setName(const std::string& newName) {name=newName;}
+         const SpaceHandle& getSpaceHandle() const {return spaceHandle;}
+         void setSpaceHandle(const SpaceHandle& newSpaceHandle) {spaceHandle=newSpaceHandle;}
+         const OrderType& getOrder() const {return order;}
+         void setOrder(const OrderType& newOrder) {order=newOrder;}
+         const TransportType& getTransport() const {return transport;}
+         void setTransport(const TransportType& newTransport) {transport=newTransport;}
+         // the show method
+         void show(std::ostream& out);
+      protected:
+         AttributeHandle handle;
+         std::string name;
+         SpaceHandle spaceHandle;
+         OrderType order;
+         TransportType transport;
+      private:
+   };
+
+   class CERTI_EXPORT NM_FOM_Object_Class {
+      public:
+         NM_FOM_Object_Class();
+         ~NM_FOM_Object_Class();
+         void serialize(MessageBuffer& msgBuffer);
+         void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectClassHandle& getHandle() const {return handle;}
+         void setHandle(const ObjectClassHandle& newHandle) {handle=newHandle;}
+         const ObjectClassHandle& getSuperClass() const {return superClass;}
+         void setSuperClass(const ObjectClassHandle& newSuperClass) {superClass=newSuperClass;}
+         const std::string& getName() const {return name;}
+         void setName(const std::string& newName) {name=newName;}
+         uint32_t getAttributesSize() const {return attributes.size();}
+         void setAttributesSize(uint32_t num) {attributes.resize(num);}
+         const std::vector<NM_FOM_Attribute>& getAttributes() const {return attributes;}
+         const NM_FOM_Attribute& getAttributes(uint32_t rank) const {return attributes[rank];}
+         NM_FOM_Attribute& getAttributes(uint32_t rank) {return attributes[rank];}
+         void setAttributes(const NM_FOM_Attribute& newAttributes, uint32_t rank) {attributes[rank]=newAttributes;}
+         void removeAttributes(uint32_t rank) {attributes.erase(attributes.begin() + rank);}
+         // the show method
+         void show(std::ostream& out);
+      protected:
+         ObjectClassHandle handle;
+         ObjectClassHandle superClass;
+         std::string name;
+         std::vector<NM_FOM_Attribute> attributes;
+      private:
+   };
+
+   class CERTI_EXPORT NM_FOM_Parameter {
+      public:
+         NM_FOM_Parameter();
+         ~NM_FOM_Parameter();
+         void serialize(MessageBuffer& msgBuffer);
+         void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ParameterHandle& getHandle() const {return handle;}
+         void setHandle(const ParameterHandle& newHandle) {handle=newHandle;}
+         const std::string& getName() const {return name;}
+         void setName(const std::string& newName) {name=newName;}
+         // the show method
+         void show(std::ostream& out);
+      protected:
+         ParameterHandle handle;
+         std::string name;
+      private:
+   };
+
+   class CERTI_EXPORT NM_FOM_Interaction_Class {
+      public:
+         NM_FOM_Interaction_Class();
+         ~NM_FOM_Interaction_Class();
+         void serialize(MessageBuffer& msgBuffer);
+         void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const InteractionClassHandle& getInteractionClass() const {return interactionClass;}
+         void setInteractionClass(const InteractionClassHandle& newInteractionClass) {interactionClass=newInteractionClass;}
+         const std::string& getName() const {return name;}
+         void setName(const std::string& newName) {name=newName;}
+         const InteractionClassHandle& getSuperClass() const {return superClass;}
+         void setSuperClass(const InteractionClassHandle& newSuperClass) {superClass=newSuperClass;}
+         const SpaceHandle& getSpace() const {return space;}
+         void setSpace(const SpaceHandle& newSpace) {space=newSpace;}
+         const OrderType& getOrder() const {return order;}
+         void setOrder(const OrderType& newOrder) {order=newOrder;}
+         const TransportType& getTransport() const {return transport;}
+         void setTransport(const TransportType& newTransport) {transport=newTransport;}
+         uint32_t getParametersSize() const {return parameters.size();}
+         void setParametersSize(uint32_t num) {parameters.resize(num);}
+         const std::vector<NM_FOM_Parameter>& getParameters() const {return parameters;}
+         const NM_FOM_Parameter& getParameters(uint32_t rank) const {return parameters[rank];}
+         NM_FOM_Parameter& getParameters(uint32_t rank) {return parameters[rank];}
+         void setParameters(const NM_FOM_Parameter& newParameters, uint32_t rank) {parameters[rank]=newParameters;}
+         void removeParameters(uint32_t rank) {parameters.erase(parameters.begin() + rank);}
+         // the show method
+         void show(std::ostream& out);
+      protected:
+         InteractionClassHandle interactionClass;
+         std::string name;
+         InteractionClassHandle superClass;
+         SpaceHandle space;
+         OrderType order;
+         TransportType transport;
+         std::vector<NM_FOM_Parameter> parameters;
+      private:
+   };
+
+   class CERTI_EXPORT NM_Close_Connexion : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Close_Connexion();
+         virtual ~NM_Close_Connexion();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Message_Null : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Message_Null();
+         virtual ~NM_Message_Null();
+      protected:
+      private:
+   };
+   // Create the federation execution
+   class CERTI_EXPORT NM_Create_Federation_Execution : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Create_Federation_Execution();
+         virtual ~NM_Create_Federation_Execution();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const std::string& getFederationName() const {return federationName;}
+         void setFederationName(const std::string& newFederationName) {federationName=newFederationName;}
+         const std::string& getFEDid() const {return FEDid;}
+         void setFEDid(const std::string& newFEDid) {FEDid=newFEDid;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         std::string federationName;// the federation name
+         std::string FEDid;// the Federation ID which is in fact a filename
+      private:
+   };
+   // Destroy the federation execution
+   class CERTI_EXPORT NM_Destroy_Federation_Execution : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Destroy_Federation_Execution();
+         virtual ~NM_Destroy_Federation_Execution();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const std::string& getFederationName() const {return federationName;}
+         void setFederationName(const std::string& newFederationName) {federationName=newFederationName;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         std::string federationName;
+      private:
+   };
+   // Join the federation
+   class CERTI_EXPORT NM_Join_Federation_Execution : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Join_Federation_Execution();
+         virtual ~NM_Join_Federation_Execution();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const int32_t& getNumberOfRegulators() const {return numberOfRegulators;}
+         void setNumberOfRegulators(const int32_t& newNumberOfRegulators) {numberOfRegulators=newNumberOfRegulators;}
+         const uint32_t& getMulticastAddress() const {return multicastAddress;}
+         void setMulticastAddress(const uint32_t& newMulticastAddress) {multicastAddress=newMulticastAddress;}
+         const uint32_t& getBestEffortAddress() const {return bestEffortAddress;}
+         void setBestEffortAddress(const uint32_t& newBestEffortAddress) {bestEffortAddress=newBestEffortAddress;}
+         const uint32_t& getBestEffortPeer() const {return bestEffortPeer;}
+         void setBestEffortPeer(const uint32_t& newBestEffortPeer) {bestEffortPeer=newBestEffortPeer;}
+         const std::string& getFederationName() const {return federationName;}
+         void setFederationName(const std::string& newFederationName) {federationName=newFederationName;}
+         const std::string& getFederateName() const {return federateName;}
+         void setFederateName(const std::string& newFederateName) {federateName=newFederateName;}
+         uint32_t getRoutingSpacesSize() const {return routingSpaces.size();}
+         void setRoutingSpacesSize(uint32_t num) {routingSpaces.resize(num);}
+         const std::vector<NM_FOM_Routing_Space>& getRoutingSpaces() const {return routingSpaces;}
+         const NM_FOM_Routing_Space& getRoutingSpaces(uint32_t rank) const {return routingSpaces[rank];}
+         NM_FOM_Routing_Space& getRoutingSpaces(uint32_t rank) {return routingSpaces[rank];}
+         void setRoutingSpaces(const NM_FOM_Routing_Space& newRoutingSpaces, uint32_t rank) {routingSpaces[rank]=newRoutingSpaces;}
+         void removeRoutingSpaces(uint32_t rank) {routingSpaces.erase(routingSpaces.begin() + rank);}
+         uint32_t getObjectClassesSize() const {return objectClasses.size();}
+         void setObjectClassesSize(uint32_t num) {objectClasses.resize(num);}
+         const std::vector<NM_FOM_Object_Class>& getObjectClasses() const {return objectClasses;}
+         const NM_FOM_Object_Class& getObjectClasses(uint32_t rank) const {return objectClasses[rank];}
+         NM_FOM_Object_Class& getObjectClasses(uint32_t rank) {return objectClasses[rank];}
+         void setObjectClasses(const NM_FOM_Object_Class& newObjectClasses, uint32_t rank) {objectClasses[rank]=newObjectClasses;}
+         void removeObjectClasses(uint32_t rank) {objectClasses.erase(objectClasses.begin() + rank);}
+         uint32_t getInteractionClassesSize() const {return interactionClasses.size();}
+         void setInteractionClassesSize(uint32_t num) {interactionClasses.resize(num);}
+         const std::vector<NM_FOM_Interaction_Class>& getInteractionClasses() const {return interactionClasses;}
+         const NM_FOM_Interaction_Class& getInteractionClasses(uint32_t rank) const {return interactionClasses[rank];}
+         NM_FOM_Interaction_Class& getInteractionClasses(uint32_t rank) {return interactionClasses[rank];}
+         void setInteractionClasses(const NM_FOM_Interaction_Class& newInteractionClasses, uint32_t rank) {interactionClasses[rank]=newInteractionClasses;}
+         void removeInteractionClasses(uint32_t rank) {interactionClasses.erase(interactionClasses.begin() + rank);}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         int32_t numberOfRegulators;
+         uint32_t multicastAddress;
+         uint32_t bestEffortAddress;
+         uint32_t bestEffortPeer;
+         std::string federationName;// the federation name
+         std::string federateName;// the federate name (should be unique within a federation)
+         std::vector<NM_FOM_Routing_Space> routingSpaces;
+         std::vector<NM_FOM_Object_Class> objectClasses;
+         std::vector<NM_FOM_Interaction_Class> interactionClasses;
+      private:
+   };
+   // Resign from federation
+   class CERTI_EXPORT NM_Resign_Federation_Execution : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Resign_Federation_Execution();
+         virtual ~NM_Resign_Federation_Execution();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Set_Time_Regulating : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Set_Time_Regulating();
+         virtual ~NM_Set_Time_Regulating();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         void regulatorOn() {regulator = true;}
+         void regulatorOff() {regulator = false;}
+         bool isRegulatorOn() const {return regulator;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         bool regulator;
+      private:
+   };
+
+   class CERTI_EXPORT NM_Set_Time_Constrained : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Set_Time_Constrained();
+         virtual ~NM_Set_Time_Constrained();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         void constrainedOn() {constrained = true;}
+         void constrainedOff() {constrained = false;}
+         bool isConstrainedOn() const {return constrained;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         bool constrained;
+      private:
+   };
+
+   class CERTI_EXPORT NM_Time_Regulation_Enabled : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Time_Regulation_Enabled();
+         virtual ~NM_Time_Regulation_Enabled();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Time_Constrained_Enabled : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Time_Constrained_Enabled();
+         virtual ~NM_Time_Constrained_Enabled();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Set_Class_Relevance_Advisory_Switch : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Set_Class_Relevance_Advisory_Switch();
+         virtual ~NM_Set_Class_Relevance_Advisory_Switch();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         void classRelevanceAdvisorySwitchOn() {classRelevanceAdvisorySwitch = true;}
+         void classRelevanceAdvisorySwitchOff() {classRelevanceAdvisorySwitch = false;}
+         bool isClassRelevanceAdvisorySwitchOn() const {return classRelevanceAdvisorySwitch;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         bool classRelevanceAdvisorySwitch;// value of CRA switch 	
+      private:
+   };
+
+   class CERTI_EXPORT NM_Set_Interaction_Relevance_Advisory_Switch : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Set_Interaction_Relevance_Advisory_Switch();
+         virtual ~NM_Set_Interaction_Relevance_Advisory_Switch();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         void interactionRelevanceAdvisorySwitchOn() {interactionRelevanceAdvisorySwitch = true;}
+         void interactionRelevanceAdvisorySwitchOff() {interactionRelevanceAdvisorySwitch = false;}
+         bool isInteractionRelevanceAdvisorySwitchOn() const {return interactionRelevanceAdvisorySwitch;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         bool interactionRelevanceAdvisorySwitch;// value of IRA switch 	
+      private:
+   };
+
+   class CERTI_EXPORT NM_Set_Attribute_Relevance_Advisory_Switch : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Set_Attribute_Relevance_Advisory_Switch();
+         virtual ~NM_Set_Attribute_Relevance_Advisory_Switch();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         void attributeRelevanceAdvisorySwitchOn() {attributeRelevanceAdvisorySwitch = true;}
+         void attributeRelevanceAdvisorySwitchOff() {attributeRelevanceAdvisorySwitch = false;}
+         bool isAttributeRelevanceAdvisorySwitchOn() const {return attributeRelevanceAdvisorySwitch;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         bool attributeRelevanceAdvisorySwitch;// value of ARA switch 	
+      private:
+   };
+
+   class CERTI_EXPORT NM_Set_Attribute_Scope_Advisory_Switch : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Set_Attribute_Scope_Advisory_Switch();
+         virtual ~NM_Set_Attribute_Scope_Advisory_Switch();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         void attributeScopeAdvisorySwitchOn() {attributeScopeAdvisorySwitch = true;}
+         void attributeScopeAdvisorySwitchOff() {attributeScopeAdvisorySwitch = false;}
+         bool isAttributeScopeAdvisorySwitchOn() const {return attributeScopeAdvisorySwitch;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         bool attributeScopeAdvisorySwitch;// value of ASA switch 	
+      private:
+   };
+
+   class CERTI_EXPORT NM_Register_Federation_Synchronization_Point : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Register_Federation_Synchronization_Point();
+         virtual ~NM_Register_Federation_Synchronization_Point();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const bool& getExists() const {return exists;}
+         void setExists(const bool& newExists) {exists=newExists;}
+         uint32_t getFederatesSize() const {return federates.size();}
+         void setFederatesSize(uint32_t num) {federates.resize(num);}
+         const std::vector<FederateHandle>& getFederates() const {return federates;}
+         const FederateHandle& getFederates(uint32_t rank) const {return federates[rank];}
+         FederateHandle& getFederates(uint32_t rank) {return federates[rank];}
+         void setFederates(const FederateHandle& newFederates, uint32_t rank) {federates[rank]=newFederates;}
+         void removeFederates(uint32_t rank) {federates.erase(federates.begin() + rank);}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         bool exists;// tell whether if the synchronization set is specified or not
+         std::vector<FederateHandle> federates;// the federate set
+      private:
+   };
+
+   class CERTI_EXPORT NM_Synchronization_Point_Registration_Succeeded : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Synchronization_Point_Registration_Succeeded();
+         virtual ~NM_Synchronization_Point_Registration_Succeeded();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Announce_Synchronization_Point : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Announce_Synchronization_Point();
+         virtual ~NM_Announce_Synchronization_Point();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Synchronization_Point_Achieved : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Synchronization_Point_Achieved();
+         virtual ~NM_Synchronization_Point_Achieved();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Federation_Synchronized : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Federation_Synchronized();
+         virtual ~NM_Federation_Synchronized();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Request_Federation_Save : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Request_Federation_Save();
+         virtual ~NM_Request_Federation_Save();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Federate_Save_Begun : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Federate_Save_Begun();
+         virtual ~NM_Federate_Save_Begun();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Federate_Save_Complete : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Federate_Save_Complete();
+         virtual ~NM_Federate_Save_Complete();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Federate_Save_Not_Complete : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Federate_Save_Not_Complete();
+         virtual ~NM_Federate_Save_Not_Complete();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Initiate_Federate_Save : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Initiate_Federate_Save();
+         virtual ~NM_Initiate_Federate_Save();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Federation_Saved : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Federation_Saved();
+         virtual ~NM_Federation_Saved();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Federation_Not_Saved : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Federation_Not_Saved();
+         virtual ~NM_Federation_Not_Saved();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Request_Federation_Restore : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Request_Federation_Restore();
+         virtual ~NM_Request_Federation_Restore();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Federate_Restore_Complete : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Federate_Restore_Complete();
+         virtual ~NM_Federate_Restore_Complete();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Federate_Restore_Not_Complete : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Federate_Restore_Not_Complete();
+         virtual ~NM_Federate_Restore_Not_Complete();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Request_Federation_Restore_Succeeded : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Request_Federation_Restore_Succeeded();
+         virtual ~NM_Request_Federation_Restore_Succeeded();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Request_Federation_Restore_Failed : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Request_Federation_Restore_Failed();
+         virtual ~NM_Request_Federation_Restore_Failed();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Federation_Restore_Begun : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Federation_Restore_Begun();
+         virtual ~NM_Federation_Restore_Begun();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Initiate_Federate_Restore : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Initiate_Federate_Restore();
+         virtual ~NM_Initiate_Federate_Restore();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Federation_Restored : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Federation_Restored();
+         virtual ~NM_Federation_Restored();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Federation_Not_Restored : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Federation_Not_Restored();
+         virtual ~NM_Federation_Not_Restored();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Publish_Object_Class : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Publish_Object_Class();
+         virtual ~NM_Publish_Object_Class();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectClassHandle& getObjectClass() const {return objectClass;}
+         void setObjectClass(const ObjectClassHandle& newObjectClass) {objectClass=newObjectClass;}
+         uint32_t getAttributesSize() const {return attributes.size();}
+         void setAttributesSize(uint32_t num) {attributes.resize(num);}
+         const std::vector<AttributeHandle>& getAttributes() const {return attributes;}
+         const AttributeHandle& getAttributes(uint32_t rank) const {return attributes[rank];}
+         AttributeHandle& getAttributes(uint32_t rank) {return attributes[rank];}
+         void setAttributes(const AttributeHandle& newAttributes, uint32_t rank) {attributes[rank]=newAttributes;}
+         void removeAttributes(uint32_t rank) {attributes.erase(attributes.begin() + rank);}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         ObjectClassHandle objectClass;
+         std::vector<AttributeHandle> attributes;
+      private:
+   };
+
+   class CERTI_EXPORT NM_Unpublish_Object_Class : public NM_Publish_Object_Class {
+      public:
+         typedef NM_Publish_Object_Class Super;
+         NM_Unpublish_Object_Class();
+         virtual ~NM_Unpublish_Object_Class();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Publish_Interaction_Class : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Publish_Interaction_Class();
+         virtual ~NM_Publish_Interaction_Class();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const InteractionClassHandle& getInteractionClass() const {return interactionClass;}
+         void setInteractionClass(const InteractionClassHandle& newInteractionClass) {interactionClass=newInteractionClass;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         InteractionClassHandle interactionClass;// the interaction class
+      private:
+   };
+
+   class CERTI_EXPORT NM_Unpublish_Interaction_Class : public NM_Publish_Interaction_Class {
+      public:
+         typedef NM_Publish_Interaction_Class Super;
+         NM_Unpublish_Interaction_Class();
+         virtual ~NM_Unpublish_Interaction_Class();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Subscribe_Object_Class : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Subscribe_Object_Class();
+         virtual ~NM_Subscribe_Object_Class();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectClassHandle& getObjectClass() const {return objectClass;}
+         void setObjectClass(const ObjectClassHandle& newObjectClass) {objectClass=newObjectClass;}
+         uint32_t getAttributesSize() const {return attributes.size();}
+         void setAttributesSize(uint32_t num) {attributes.resize(num);}
+         const std::vector<AttributeHandle>& getAttributes() const {return attributes;}
+         const AttributeHandle& getAttributes(uint32_t rank) const {return attributes[rank];}
+         AttributeHandle& getAttributes(uint32_t rank) {return attributes[rank];}
+         void setAttributes(const AttributeHandle& newAttributes, uint32_t rank) {attributes[rank]=newAttributes;}
+         void removeAttributes(uint32_t rank) {attributes.erase(attributes.begin() + rank);}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         ObjectClassHandle objectClass;
+         std::vector<AttributeHandle> attributes;
+      private:
+   };
+
+   class CERTI_EXPORT NM_Unsubscribe_Object_Class : public NM_Subscribe_Object_Class {
+      public:
+         typedef NM_Subscribe_Object_Class Super;
+         NM_Unsubscribe_Object_Class();
+         virtual ~NM_Unsubscribe_Object_Class();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Subscribe_Interaction_Class : public NM_Publish_Interaction_Class {
+      public:
+         typedef NM_Publish_Interaction_Class Super;
+         NM_Subscribe_Interaction_Class();
+         virtual ~NM_Subscribe_Interaction_Class();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Unsubscribe_Interaction_Class : public NM_Publish_Interaction_Class {
+      public:
+         typedef NM_Publish_Interaction_Class Super;
+         NM_Unsubscribe_Interaction_Class();
+         virtual ~NM_Unsubscribe_Interaction_Class();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Turn_Interactions_On : public NM_Publish_Interaction_Class {
+      public:
+         typedef NM_Publish_Interaction_Class Super;
+         NM_Turn_Interactions_On();
+         virtual ~NM_Turn_Interactions_On();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Turn_Interactions_Off : public NM_Publish_Interaction_Class {
+      public:
+         typedef NM_Publish_Interaction_Class Super;
+         NM_Turn_Interactions_Off();
+         virtual ~NM_Turn_Interactions_Off();
+      protected:
+      private:
+   };
+   // HLA 1.3 §6.2
+   class CERTI_EXPORT NM_Register_Object : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Register_Object();
+         virtual ~NM_Register_Object();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectClassHandle& getObjectClass() const {return objectClass;}
+         void setObjectClass(const ObjectClassHandle& newObjectClass) {objectClass=newObjectClass;}
+         const std::string& getObjectName() const {return objectName;}
+         void setObjectName(const std::string& newObjectName) {
+            hasObjectName=true;
+            objectName=newObjectName;
+         }
+         const ObjectHandle& getObject() const {return object;}
+         void setObject(const ObjectHandle& newObject) {object=newObject;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         ObjectClassHandle objectClass;
+         std::string objectName;
+         bool hasObjectName;
+         ObjectHandle object;
+      private:
+   };
+   // HLA 1.3 §6.3
+   class CERTI_EXPORT NM_Discover_Object : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Discover_Object();
+         virtual ~NM_Discover_Object();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectClassHandle& getObjectClass() const {return objectClass;}
+         void setObjectClass(const ObjectClassHandle& newObjectClass) {objectClass=newObjectClass;}
+         const ObjectHandle& getObject() const {return object;}
+         void setObject(const ObjectHandle& newObject) {object=newObject;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         ObjectClassHandle objectClass;
+         ObjectHandle object;
+      private:
+   };
+   // HLA 1.3 §6.4
+   class CERTI_EXPORT NM_Update_Attribute_Values : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Update_Attribute_Values();
+         virtual ~NM_Update_Attribute_Values();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectHandle& getObject() const {return object;}
+         void setObject(const ObjectHandle& newObject) {object=newObject;}
+         uint32_t getAttributesSize() const {return attributes.size();}
+         void setAttributesSize(uint32_t num) {attributes.resize(num);}
+         const std::vector<AttributeHandle>& getAttributes() const {return attributes;}
+         const AttributeHandle& getAttributes(uint32_t rank) const {return attributes[rank];}
+         AttributeHandle& getAttributes(uint32_t rank) {return attributes[rank];}
+         void setAttributes(const AttributeHandle& newAttributes, uint32_t rank) {attributes[rank]=newAttributes;}
+         void removeAttributes(uint32_t rank) {attributes.erase(attributes.begin() + rank);}
+         uint32_t getValuesSize() const {return values.size();}
+         void setValuesSize(uint32_t num) {values.resize(num);}
+         const std::vector<AttributeValue_t>& getValues() const {return values;}
+         const AttributeValue_t& getValues(uint32_t rank) const {return values[rank];}
+         AttributeValue_t& getValues(uint32_t rank) {return values[rank];}
+         void setValues(const AttributeValue_t& newValues, uint32_t rank) {values[rank]=newValues;}
+         void removeValues(uint32_t rank) {values.erase(values.begin() + rank);}
+         const EventRetractionHandle& getEvent() const {return event;}
+         void setEvent(const EventRetractionHandle& newEvent) {
+            hasEvent=true;
+            event=newEvent;
+         }
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         ObjectHandle object;
+         std::vector<AttributeHandle> attributes;
+         std::vector<AttributeValue_t> values;
+         EventRetractionHandle event;
+         bool hasEvent;
+      private:
+   };
+   // HLA 1.3 §6.5
+   class CERTI_EXPORT NM_Reflect_Attribute_Values : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Reflect_Attribute_Values();
+         virtual ~NM_Reflect_Attribute_Values();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectHandle& getObject() const {return object;}
+         void setObject(const ObjectHandle& newObject) {object=newObject;}
+         uint32_t getAttributesSize() const {return attributes.size();}
+         void setAttributesSize(uint32_t num) {attributes.resize(num);}
+         const std::vector<AttributeHandle>& getAttributes() const {return attributes;}
+         const AttributeHandle& getAttributes(uint32_t rank) const {return attributes[rank];}
+         AttributeHandle& getAttributes(uint32_t rank) {return attributes[rank];}
+         void setAttributes(const AttributeHandle& newAttributes, uint32_t rank) {attributes[rank]=newAttributes;}
+         void removeAttributes(uint32_t rank) {attributes.erase(attributes.begin() + rank);}
+         uint32_t getValuesSize() const {return values.size();}
+         void setValuesSize(uint32_t num) {values.resize(num);}
+         const std::vector<AttributeValue_t>& getValues() const {return values;}
+         const AttributeValue_t& getValues(uint32_t rank) const {return values[rank];}
+         AttributeValue_t& getValues(uint32_t rank) {return values[rank];}
+         void setValues(const AttributeValue_t& newValues, uint32_t rank) {values[rank]=newValues;}
+         void removeValues(uint32_t rank) {values.erase(values.begin() + rank);}
+         const EventRetractionHandle& getEvent() const {return event;}
+         void setEvent(const EventRetractionHandle& newEvent) {
+            hasEvent=true;
+            event=newEvent;
+         }
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         ObjectHandle object;
+         std::vector<AttributeHandle> attributes;
+         std::vector<AttributeValue_t> values;
+         EventRetractionHandle event;
+         bool hasEvent;
+      private:
+   };
+   // HLA 1.3 §6.6
+   class CERTI_EXPORT NM_Send_Interaction : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Send_Interaction();
+         virtual ~NM_Send_Interaction();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const InteractionClassHandle& getInteractionClass() const {return interactionClass;}
+         void setInteractionClass(const InteractionClassHandle& newInteractionClass) {interactionClass=newInteractionClass;}
+         uint32_t getParametersSize() const {return parameters.size();}
+         void setParametersSize(uint32_t num) {parameters.resize(num);}
+         const std::vector<ParameterHandle>& getParameters() const {return parameters;}
+         const ParameterHandle& getParameters(uint32_t rank) const {return parameters[rank];}
+         ParameterHandle& getParameters(uint32_t rank) {return parameters[rank];}
+         void setParameters(const ParameterHandle& newParameters, uint32_t rank) {parameters[rank]=newParameters;}
+         void removeParameters(uint32_t rank) {parameters.erase(parameters.begin() + rank);}
+         uint32_t getValuesSize() const {return values.size();}
+         void setValuesSize(uint32_t num) {values.resize(num);}
+         const std::vector<ParameterValue_t>& getValues() const {return values;}
+         const ParameterValue_t& getValues(uint32_t rank) const {return values[rank];}
+         ParameterValue_t& getValues(uint32_t rank) {return values[rank];}
+         void setValues(const ParameterValue_t& newValues, uint32_t rank) {values[rank]=newValues;}
+         void removeValues(uint32_t rank) {values.erase(values.begin() + rank);}
+         const RegionHandle& getRegion() const {return region;}
+         void setRegion(const RegionHandle& newRegion) {region=newRegion;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         InteractionClassHandle interactionClass;
+         std::vector<ParameterHandle> parameters;
+         std::vector<ParameterValue_t> values;
+         RegionHandle region;// FIXME check this....
+      private:
+   };
+   // HLA 1.3 §6.7
+   class CERTI_EXPORT NM_Receive_Interaction : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Receive_Interaction();
+         virtual ~NM_Receive_Interaction();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const InteractionClassHandle& getInteractionClass() const {return interactionClass;}
+         void setInteractionClass(const InteractionClassHandle& newInteractionClass) {interactionClass=newInteractionClass;}
+         uint32_t getParametersSize() const {return parameters.size();}
+         void setParametersSize(uint32_t num) {parameters.resize(num);}
+         const std::vector<ParameterHandle>& getParameters() const {return parameters;}
+         const ParameterHandle& getParameters(uint32_t rank) const {return parameters[rank];}
+         ParameterHandle& getParameters(uint32_t rank) {return parameters[rank];}
+         void setParameters(const ParameterHandle& newParameters, uint32_t rank) {parameters[rank]=newParameters;}
+         void removeParameters(uint32_t rank) {parameters.erase(parameters.begin() + rank);}
+         uint32_t getValuesSize() const {return values.size();}
+         void setValuesSize(uint32_t num) {values.resize(num);}
+         const std::vector<ParameterValue_t>& getValues() const {return values;}
+         const ParameterValue_t& getValues(uint32_t rank) const {return values[rank];}
+         ParameterValue_t& getValues(uint32_t rank) {return values[rank];}
+         void setValues(const ParameterValue_t& newValues, uint32_t rank) {values[rank]=newValues;}
+         void removeValues(uint32_t rank) {values.erase(values.begin() + rank);}
+         const EventRetractionHandle& getEvent() const {return event;}
+         void setEvent(const EventRetractionHandle& newEvent) {
+            hasEvent=true;
+            event=newEvent;
+         }
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         InteractionClassHandle interactionClass;
+         std::vector<ParameterHandle> parameters;
+         std::vector<ParameterValue_t> values;
+         EventRetractionHandle event;
+         bool hasEvent;
+      private:
+   };
+   // HLA 1.3 §6.8 Delete Object Instance
+   class CERTI_EXPORT NM_Delete_Object : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Delete_Object();
+         virtual ~NM_Delete_Object();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectHandle& getObject() const {return object;}
+         void setObject(const ObjectHandle& newObject) {object=newObject;}
+         const EventRetractionHandle& getEvent() const {return event;}
+         void setEvent(const EventRetractionHandle& newEvent) {
+            hasEvent=true;
+            event=newEvent;
+         }
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         ObjectHandle object;
+         EventRetractionHandle event;
+         bool hasEvent;
+      private:
+   };
+   // HLA 1.3 §6.9 Remove Object Instance
+   class CERTI_EXPORT NM_Remove_Object : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Remove_Object();
+         virtual ~NM_Remove_Object();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectHandle& getObject() const {return object;}
+         void setObject(const ObjectHandle& newObject) {object=newObject;}
+         const ObjectClassHandle& getObjectClass() const {return objectClass;}
+         void setObjectClass(const ObjectClassHandle& newObjectClass) {objectClass=newObjectClass;}
+         const EventRetractionHandle& getEvent() const {return event;}
+         void setEvent(const EventRetractionHandle& newEvent) {
+            hasEvent=true;
+            event=newEvent;
+         }
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         ObjectHandle object;
+         ObjectClassHandle objectClass;
+         EventRetractionHandle event;
+         bool hasEvent;
+      private:
+   };
+
+   class CERTI_EXPORT NM_Change_Attribute_Transport_Type : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Change_Attribute_Transport_Type();
+         virtual ~NM_Change_Attribute_Transport_Type();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectHandle& getObject() const {return object;}
+         void setObject(const ObjectHandle& newObject) {object=newObject;}
+         uint32_t getAttributesSize() const {return attributes.size();}
+         void setAttributesSize(uint32_t num) {attributes.resize(num);}
+         const std::vector<AttributeHandle>& getAttributes() const {return attributes;}
+         const AttributeHandle& getAttributes(uint32_t rank) const {return attributes[rank];}
+         AttributeHandle& getAttributes(uint32_t rank) {return attributes[rank];}
+         void setAttributes(const AttributeHandle& newAttributes, uint32_t rank) {attributes[rank]=newAttributes;}
+         void removeAttributes(uint32_t rank) {attributes.erase(attributes.begin() + rank);}
+         const TransportType& getTransport() const {return transport;}
+         void setTransport(const TransportType& newTransport) {transport=newTransport;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         ObjectHandle object;
+         std::vector<AttributeHandle> attributes;
+         TransportType transport;
+      private:
+   };
+
+   class CERTI_EXPORT NM_Change_Attribute_Order_Type : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Change_Attribute_Order_Type();
+         virtual ~NM_Change_Attribute_Order_Type();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectHandle& getObject() const {return object;}
+         void setObject(const ObjectHandle& newObject) {object=newObject;}
+         uint32_t getAttributesSize() const {return attributes.size();}
+         void setAttributesSize(uint32_t num) {attributes.resize(num);}
+         const std::vector<AttributeHandle>& getAttributes() const {return attributes;}
+         const AttributeHandle& getAttributes(uint32_t rank) const {return attributes[rank];}
+         AttributeHandle& getAttributes(uint32_t rank) {return attributes[rank];}
+         void setAttributes(const AttributeHandle& newAttributes, uint32_t rank) {attributes[rank]=newAttributes;}
+         void removeAttributes(uint32_t rank) {attributes.erase(attributes.begin() + rank);}
+         const OrderType& getOrder() const {return order;}
+         void setOrder(const OrderType& newOrder) {order=newOrder;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         ObjectHandle object;
+         std::vector<AttributeHandle> attributes;
+         OrderType order;
+      private:
+   };
+
+   class CERTI_EXPORT NM_Change_Interaction_Transport_Type : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Change_Interaction_Transport_Type();
+         virtual ~NM_Change_Interaction_Transport_Type();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const InteractionClassHandle& getInteractionClass() const {return interactionClass;}
+         void setInteractionClass(const InteractionClassHandle& newInteractionClass) {interactionClass=newInteractionClass;}
+         const TransportType& getTransport() const {return transport;}
+         void setTransport(const TransportType& newTransport) {transport=newTransport;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         InteractionClassHandle interactionClass;
+         TransportType transport;
+      private:
+   };
+
+   class CERTI_EXPORT NM_Change_Interaction_Order_Type : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Change_Interaction_Order_Type();
+         virtual ~NM_Change_Interaction_Order_Type();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const InteractionClassHandle& getInteractionClass() const {return interactionClass;}
+         void setInteractionClass(const InteractionClassHandle& newInteractionClass) {interactionClass=newInteractionClass;}
+         const OrderType& getOrder() const {return order;}
+         void setOrder(const OrderType& newOrder) {order=newOrder;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         InteractionClassHandle interactionClass;
+         OrderType order;
+      private:
+   };
+
+   class CERTI_EXPORT NM_Request_Class_Attribute_Value_Update : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Request_Class_Attribute_Value_Update();
+         virtual ~NM_Request_Class_Attribute_Value_Update();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectClassHandle& getObjectClass() const {return objectClass;}
+         void setObjectClass(const ObjectClassHandle& newObjectClass) {objectClass=newObjectClass;}
+         uint32_t getAttributesSize() const {return attributes.size();}
+         void setAttributesSize(uint32_t num) {attributes.resize(num);}
+         const std::vector<AttributeHandle>& getAttributes() const {return attributes;}
+         const AttributeHandle& getAttributes(uint32_t rank) const {return attributes[rank];}
+         AttributeHandle& getAttributes(uint32_t rank) {return attributes[rank];}
+         void setAttributes(const AttributeHandle& newAttributes, uint32_t rank) {attributes[rank]=newAttributes;}
+         void removeAttributes(uint32_t rank) {attributes.erase(attributes.begin() + rank);}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         ObjectClassHandle objectClass;
+         std::vector<AttributeHandle> attributes;
+      private:
+   };
+
+   class CERTI_EXPORT NM_Request_Object_Attribute_Value_Update : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Request_Object_Attribute_Value_Update();
+         virtual ~NM_Request_Object_Attribute_Value_Update();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectHandle& getObject() const {return object;}
+         void setObject(const ObjectHandle& newObject) {object=newObject;}
+         uint32_t getAttributesSize() const {return attributes.size();}
+         void setAttributesSize(uint32_t num) {attributes.resize(num);}
+         const std::vector<AttributeHandle>& getAttributes() const {return attributes;}
+         const AttributeHandle& getAttributes(uint32_t rank) const {return attributes[rank];}
+         AttributeHandle& getAttributes(uint32_t rank) {return attributes[rank];}
+         void setAttributes(const AttributeHandle& newAttributes, uint32_t rank) {attributes[rank]=newAttributes;}
+         void removeAttributes(uint32_t rank) {attributes.erase(attributes.begin() + rank);}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         ObjectHandle object;
+         std::vector<AttributeHandle> attributes;
+      private:
+   };
+
+   class CERTI_EXPORT NM_Is_Attribute_Owned_By_Federate : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Is_Attribute_Owned_By_Federate();
+         virtual ~NM_Is_Attribute_Owned_By_Federate();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectHandle& getObject() const {return object;}
+         void setObject(const ObjectHandle& newObject) {object=newObject;}
+         const AttributeHandle& getAttribute() const {return attribute;}
+         void setAttribute(const AttributeHandle& newAttribute) {attribute=newAttribute;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         ObjectHandle object;
+         AttributeHandle attribute;
+      private:
+   };
+
+   class CERTI_EXPORT NM_Query_Attribute_Ownership : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Query_Attribute_Ownership();
+         virtual ~NM_Query_Attribute_Ownership();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectHandle& getObject() const {return object;}
+         void setObject(const ObjectHandle& newObject) {object=newObject;}
+         const AttributeHandle& getAttribute() const {return attribute;}
+         void setAttribute(const AttributeHandle& newAttribute) {attribute=newAttribute;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         ObjectHandle object;
+         AttributeHandle attribute;
+      private:
+   };
+
+   class CERTI_EXPORT NM_Attribute_Is_Not_Owned : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Attribute_Is_Not_Owned();
+         virtual ~NM_Attribute_Is_Not_Owned();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectHandle& getObject() const {return object;}
+         void setObject(const ObjectHandle& newObject) {object=newObject;}
+         const AttributeHandle& getAttribute() const {return attribute;}
+         void setAttribute(const AttributeHandle& newAttribute) {attribute=newAttribute;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         ObjectHandle object;
+         AttributeHandle attribute;
+      private:
+   };
+
+   class CERTI_EXPORT NM_Inform_Attribute_Ownership : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Inform_Attribute_Ownership();
+         virtual ~NM_Inform_Attribute_Ownership();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectHandle& getObject() const {return object;}
+         void setObject(const ObjectHandle& newObject) {object=newObject;}
+         const AttributeHandle& getAttribute() const {return attribute;}
+         void setAttribute(const AttributeHandle& newAttribute) {attribute=newAttribute;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         ObjectHandle object;
+         AttributeHandle attribute;
+      private:
+   };
+
+   class CERTI_EXPORT NM_Attribute_Ownership_Base : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Attribute_Ownership_Base();
+         virtual ~NM_Attribute_Ownership_Base();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectHandle& getObject() const {return object;}
+         void setObject(const ObjectHandle& newObject) {object=newObject;}
+         uint32_t getAttributesSize() const {return attributes.size();}
+         void setAttributesSize(uint32_t num) {attributes.resize(num);}
+         const std::vector<AttributeHandle>& getAttributes() const {return attributes;}
+         const AttributeHandle& getAttributes(uint32_t rank) const {return attributes[rank];}
+         AttributeHandle& getAttributes(uint32_t rank) {return attributes[rank];}
+         void setAttributes(const AttributeHandle& newAttributes, uint32_t rank) {attributes[rank]=newAttributes;}
+         void removeAttributes(uint32_t rank) {attributes.erase(attributes.begin() + rank);}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         ObjectHandle object;
+         std::vector<AttributeHandle> attributes;
+      private:
+   };
+
+   class CERTI_EXPORT NM_Negotiated_Attribute_Ownership_Divestiture : public NM_Attribute_Ownership_Base {
+      public:
+         typedef NM_Attribute_Ownership_Base Super;
+         NM_Negotiated_Attribute_Ownership_Divestiture();
+         virtual ~NM_Negotiated_Attribute_Ownership_Divestiture();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Attribute_Ownership_Acquisition_Notification : public NM_Attribute_Ownership_Base {
+      public:
+         typedef NM_Attribute_Ownership_Base Super;
+         NM_Attribute_Ownership_Acquisition_Notification();
+         virtual ~NM_Attribute_Ownership_Acquisition_Notification();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Attribute_Ownership_Divestiture_Notification : public NM_Attribute_Ownership_Base {
+      public:
+         typedef NM_Attribute_Ownership_Base Super;
+         NM_Attribute_Ownership_Divestiture_Notification();
+         virtual ~NM_Attribute_Ownership_Divestiture_Notification();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Request_Attribute_Ownership_Assumption : public NM_Attribute_Ownership_Base {
+      public:
+         typedef NM_Attribute_Ownership_Base Super;
+         NM_Request_Attribute_Ownership_Assumption();
+         virtual ~NM_Request_Attribute_Ownership_Assumption();
+      protected:
+      private:
+   };
+   // This is a base message which is used to 
+   // define several Attribute_Ownership_XXX
+   // since all these message contains the same fields
+   class CERTI_EXPORT NM_Attribute_Ownership_Unavailable : public NM_Attribute_Ownership_Base {
+      public:
+         typedef NM_Attribute_Ownership_Base Super;
+         NM_Attribute_Ownership_Unavailable();
+         virtual ~NM_Attribute_Ownership_Unavailable();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Attribute_Ownership_Acquisition_If_Available : public NM_Attribute_Ownership_Base {
+      public:
+         typedef NM_Attribute_Ownership_Base Super;
+         NM_Attribute_Ownership_Acquisition_If_Available();
+         virtual ~NM_Attribute_Ownership_Acquisition_If_Available();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Unconditional_Attribute_Ownership_Divestiture : public NM_Attribute_Ownership_Base {
+      public:
+         typedef NM_Attribute_Ownership_Base Super;
+         NM_Unconditional_Attribute_Ownership_Divestiture();
+         virtual ~NM_Unconditional_Attribute_Ownership_Divestiture();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Attribute_Ownership_Acquisition : public NM_Attribute_Ownership_Base {
+      public:
+         typedef NM_Attribute_Ownership_Base Super;
+         NM_Attribute_Ownership_Acquisition();
+         virtual ~NM_Attribute_Ownership_Acquisition();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Request_Attribute_Ownership_Release : public NM_Attribute_Ownership_Base {
+      public:
+         typedef NM_Attribute_Ownership_Base Super;
+         NM_Request_Attribute_Ownership_Release();
+         virtual ~NM_Request_Attribute_Ownership_Release();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Cancel_Negotiated_Attribute_Ownership_Divestiture : public NM_Attribute_Ownership_Base {
+      public:
+         typedef NM_Attribute_Ownership_Base Super;
+         NM_Cancel_Negotiated_Attribute_Ownership_Divestiture();
+         virtual ~NM_Cancel_Negotiated_Attribute_Ownership_Divestiture();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Attribute_Ownership_Release_Response : public NM_Attribute_Ownership_Base {
+      public:
+         typedef NM_Attribute_Ownership_Base Super;
+         NM_Attribute_Ownership_Release_Response();
+         virtual ~NM_Attribute_Ownership_Release_Response();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Cancel_Attribute_Ownership_Acquisition : public NM_Attribute_Ownership_Base {
+      public:
+         typedef NM_Attribute_Ownership_Base Super;
+         NM_Cancel_Attribute_Ownership_Acquisition();
+         virtual ~NM_Cancel_Attribute_Ownership_Acquisition();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Confirm_Attribute_Ownership_Acquisition_Cancellation : public NM_Attribute_Ownership_Base {
+      public:
+         typedef NM_Attribute_Ownership_Base Super;
+         NM_Confirm_Attribute_Ownership_Acquisition_Cancellation();
+         virtual ~NM_Confirm_Attribute_Ownership_Acquisition_Cancellation();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_DDM_Create_Region : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_DDM_Create_Region();
+         virtual ~NM_DDM_Create_Region();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         uint32_t getAttributesSize() const {return attributes.size();}
+         void setAttributesSize(uint32_t num) {attributes.resize(num);}
+         const std::vector<AttributeHandle>& getAttributes() const {return attributes;}
+         const AttributeHandle& getAttributes(uint32_t rank) const {return attributes[rank];}
+         AttributeHandle& getAttributes(uint32_t rank) {return attributes[rank];}
+         void setAttributes(const AttributeHandle& newAttributes, uint32_t rank) {attributes[rank]=newAttributes;}
+         void removeAttributes(uint32_t rank) {attributes.erase(attributes.begin() + rank);}
+         const bool& getDDM_bool() const {return DDM_bool;}
+         void setDDM_bool(const bool& newDDM_bool) {DDM_bool=newDDM_bool;}
+         const SpaceHandle& getSpace() const {return space;}
+         void setSpace(const SpaceHandle& newSpace) {space=newSpace;}
+         const RegionHandle& getRegion() const {return region;}
+         void setRegion(const RegionHandle& newRegion) {region=newRegion;}
+         const uint32_t& getNbExtents() const {return nbExtents;}
+         void setNbExtents(const uint32_t& newNbExtents) {nbExtents=newNbExtents;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         std::vector<AttributeHandle> attributes;
+         bool DDM_bool;
+         SpaceHandle space;
+         RegionHandle region;
+         uint32_t nbExtents;// FIXME not sure it must be here
+      private:
+   };
+
+   class CERTI_EXPORT NM_DDM_Modify_Region : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_DDM_Modify_Region();
+         virtual ~NM_DDM_Modify_Region();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         uint32_t getAttributesSize() const {return attributes.size();}
+         void setAttributesSize(uint32_t num) {attributes.resize(num);}
+         const std::vector<AttributeHandle>& getAttributes() const {return attributes;}
+         const AttributeHandle& getAttributes(uint32_t rank) const {return attributes[rank];}
+         AttributeHandle& getAttributes(uint32_t rank) {return attributes[rank];}
+         void setAttributes(const AttributeHandle& newAttributes, uint32_t rank) {attributes[rank]=newAttributes;}
+         void removeAttributes(uint32_t rank) {attributes.erase(attributes.begin() + rank);}
+         const bool& getDDM_bool() const {return DDM_bool;}
+         void setDDM_bool(const bool& newDDM_bool) {DDM_bool=newDDM_bool;}
+         const RegionHandle& getRegion() const {return region;}
+         void setRegion(const RegionHandle& newRegion) {region=newRegion;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         std::vector<AttributeHandle> attributes;
+         bool DDM_bool;
+         RegionHandle region;
+      private:
+   };
+
+   class CERTI_EXPORT NM_DDM_Delete_Region : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_DDM_Delete_Region();
+         virtual ~NM_DDM_Delete_Region();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const RegionHandle& getRegion() const {return region;}
+         void setRegion(const RegionHandle& newRegion) {region=newRegion;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         RegionHandle region;
+      private:
+   };
+
+   class CERTI_EXPORT NM_DDM_Associate_Region : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_DDM_Associate_Region();
+         virtual ~NM_DDM_Associate_Region();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         uint32_t getAttributesSize() const {return attributes.size();}
+         void setAttributesSize(uint32_t num) {attributes.resize(num);}
+         const std::vector<AttributeHandle>& getAttributes() const {return attributes;}
+         const AttributeHandle& getAttributes(uint32_t rank) const {return attributes[rank];}
+         AttributeHandle& getAttributes(uint32_t rank) {return attributes[rank];}
+         void setAttributes(const AttributeHandle& newAttributes, uint32_t rank) {attributes[rank]=newAttributes;}
+         void removeAttributes(uint32_t rank) {attributes.erase(attributes.begin() + rank);}
+         const bool& getDDM_bool() const {return DDM_bool;}
+         void setDDM_bool(const bool& newDDM_bool) {DDM_bool=newDDM_bool;}
+         const RegionHandle& getRegion() const {return region;}
+         void setRegion(const RegionHandle& newRegion) {region=newRegion;}
+         const ObjectHandle& getObject() const {return object;}
+         void setObject(const ObjectHandle& newObject) {object=newObject;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         std::vector<AttributeHandle> attributes;
+         bool DDM_bool;
+         RegionHandle region;
+         ObjectHandle object;
+      private:
+   };
+
+   class CERTI_EXPORT NM_DDM_Unassociate_Region : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_DDM_Unassociate_Region();
+         virtual ~NM_DDM_Unassociate_Region();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         uint32_t getAttributesSize() const {return attributes.size();}
+         void setAttributesSize(uint32_t num) {attributes.resize(num);}
+         const std::vector<AttributeHandle>& getAttributes() const {return attributes;}
+         const AttributeHandle& getAttributes(uint32_t rank) const {return attributes[rank];}
+         AttributeHandle& getAttributes(uint32_t rank) {return attributes[rank];}
+         void setAttributes(const AttributeHandle& newAttributes, uint32_t rank) {attributes[rank]=newAttributes;}
+         void removeAttributes(uint32_t rank) {attributes.erase(attributes.begin() + rank);}
+         const RegionHandle& getRegion() const {return region;}
+         void setRegion(const RegionHandle& newRegion) {region=newRegion;}
+         const ObjectHandle& getObject() const {return object;}
+         void setObject(const ObjectHandle& newObject) {object=newObject;}
+         const bool& getDDM_bool() const {return DDM_bool;}
+         void setDDM_bool(const bool& newDDM_bool) {DDM_bool=newDDM_bool;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         std::vector<AttributeHandle> attributes;
+         RegionHandle region;
+         ObjectHandle object;
+         bool DDM_bool;
+      private:
+   };
+
+   class CERTI_EXPORT NM_DDM_Register_Object : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_DDM_Register_Object();
+         virtual ~NM_DDM_Register_Object();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectClassHandle& getObjectClass() const {return objectClass;}
+         void setObjectClass(const ObjectClassHandle& newObjectClass) {objectClass=newObjectClass;}
+         uint32_t getAttributesSize() const {return attributes.size();}
+         void setAttributesSize(uint32_t num) {attributes.resize(num);}
+         const std::vector<AttributeHandle>& getAttributes() const {return attributes;}
+         const AttributeHandle& getAttributes(uint32_t rank) const {return attributes[rank];}
+         AttributeHandle& getAttributes(uint32_t rank) {return attributes[rank];}
+         void setAttributes(const AttributeHandle& newAttributes, uint32_t rank) {attributes[rank]=newAttributes;}
+         void removeAttributes(uint32_t rank) {attributes.erase(attributes.begin() + rank);}
+         const RegionHandle& getRegion() const {return region;}
+         void setRegion(const RegionHandle& newRegion) {region=newRegion;}
+         const std::string& getObjectInstanceName() const {return objectInstanceName;}
+         void setObjectInstanceName(const std::string& newObjectInstanceName) {
+            hasObjectInstanceName=true;
+            objectInstanceName=newObjectInstanceName;
+         }
+         const ObjectHandle& getObject() const {return object;}
+         void setObject(const ObjectHandle& newObject) {object=newObject;}
+         const bool& getDDM_bool() const {return DDM_bool;}
+         void setDDM_bool(const bool& newDDM_bool) {DDM_bool=newDDM_bool;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         ObjectClassHandle objectClass;
+         std::vector<AttributeHandle> attributes;
+         RegionHandle region;
+         std::string objectInstanceName;
+         bool hasObjectInstanceName;
+         ObjectHandle object;
+         bool DDM_bool;
+      private:
+   };
+
+   class CERTI_EXPORT NM_DDM_Subscribe_Attributes : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_DDM_Subscribe_Attributes();
+         virtual ~NM_DDM_Subscribe_Attributes();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectClassHandle& getObjectClass() const {return objectClass;}
+         void setObjectClass(const ObjectClassHandle& newObjectClass) {objectClass=newObjectClass;}
+         const RegionHandle& getRegion() const {return region;}
+         void setRegion(const RegionHandle& newRegion) {region=newRegion;}
+         uint32_t getAttributesSize() const {return attributes.size();}
+         void setAttributesSize(uint32_t num) {attributes.resize(num);}
+         const std::vector<AttributeHandle>& getAttributes() const {return attributes;}
+         const AttributeHandle& getAttributes(uint32_t rank) const {return attributes[rank];}
+         AttributeHandle& getAttributes(uint32_t rank) {return attributes[rank];}
+         void setAttributes(const AttributeHandle& newAttributes, uint32_t rank) {attributes[rank]=newAttributes;}
+         void removeAttributes(uint32_t rank) {attributes.erase(attributes.begin() + rank);}
+         const bool& getDDM_bool() const {return DDM_bool;}
+         void setDDM_bool(const bool& newDDM_bool) {DDM_bool=newDDM_bool;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         ObjectClassHandle objectClass;
+         RegionHandle region;
+         std::vector<AttributeHandle> attributes;
+         bool DDM_bool;
+      private:
+   };
+
+   class CERTI_EXPORT NM_DDM_Unsubscribe_Attributes : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_DDM_Unsubscribe_Attributes();
+         virtual ~NM_DDM_Unsubscribe_Attributes();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectClassHandle& getObjectClass() const {return objectClass;}
+         void setObjectClass(const ObjectClassHandle& newObjectClass) {objectClass=newObjectClass;}
+         const RegionHandle& getRegion() const {return region;}
+         void setRegion(const RegionHandle& newRegion) {region=newRegion;}
+         uint32_t getAttributesSize() const {return attributes.size();}
+         void setAttributesSize(uint32_t num) {attributes.resize(num);}
+         const std::vector<AttributeHandle>& getAttributes() const {return attributes;}
+         const AttributeHandle& getAttributes(uint32_t rank) const {return attributes[rank];}
+         AttributeHandle& getAttributes(uint32_t rank) {return attributes[rank];}
+         void setAttributes(const AttributeHandle& newAttributes, uint32_t rank) {attributes[rank]=newAttributes;}
+         void removeAttributes(uint32_t rank) {attributes.erase(attributes.begin() + rank);}
+         const bool& getDDM_bool() const {return DDM_bool;}
+         void setDDM_bool(const bool& newDDM_bool) {DDM_bool=newDDM_bool;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         ObjectClassHandle objectClass;
+         RegionHandle region;
+         std::vector<AttributeHandle> attributes;
+         bool DDM_bool;
+      private:
+   };
+
+   class CERTI_EXPORT NM_DDM_Subscribe_Interaction : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_DDM_Subscribe_Interaction();
+         virtual ~NM_DDM_Subscribe_Interaction();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const InteractionClassHandle& getInteractionClass() const {return interactionClass;}
+         void setInteractionClass(const InteractionClassHandle& newInteractionClass) {interactionClass=newInteractionClass;}
+         const RegionHandle& getRegion() const {return region;}
+         void setRegion(const RegionHandle& newRegion) {region=newRegion;}
+         const bool& getDDM_bool() const {return DDM_bool;}
+         void setDDM_bool(const bool& newDDM_bool) {DDM_bool=newDDM_bool;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         InteractionClassHandle interactionClass;
+         RegionHandle region;
+         bool DDM_bool;
+      private:
+   };
+
+   class CERTI_EXPORT NM_DDM_Unsubscribe_Interaction : public NM_DDM_Subscribe_Interaction {
+      public:
+         typedef NM_DDM_Subscribe_Interaction Super;
+         NM_DDM_Unsubscribe_Interaction();
+         virtual ~NM_DDM_Unsubscribe_Interaction();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Provide_Attribute_Value_Update : public NM_Request_Object_Attribute_Value_Update {
+      public:
+         typedef NM_Request_Object_Attribute_Value_Update Super;
+         NM_Provide_Attribute_Value_Update();
+         virtual ~NM_Provide_Attribute_Value_Update();
+      protected:
+      private:
+   };
+
+   class CERTI_EXPORT NM_Start_Registration_For_Object_Class : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Start_Registration_For_Object_Class();
+         virtual ~NM_Start_Registration_For_Object_Class();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectClassHandle& getObjectClass() const {return objectClass;}
+         void setObjectClass(const ObjectClassHandle& newObjectClass) {objectClass=newObjectClass;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         ObjectClassHandle objectClass;
+      private:
+   };
+
+   class CERTI_EXPORT NM_Stop_Registration_For_Object_Class : public NetworkMessage {
+      public:
+         typedef NetworkMessage Super;
+         NM_Stop_Registration_For_Object_Class();
+         virtual ~NM_Stop_Registration_For_Object_Class();
+         virtual void serialize(MessageBuffer& msgBuffer);
+         virtual void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const ObjectClassHandle& getObjectClass() const {return objectClass;}
+         void setObjectClass(const ObjectClassHandle& newObjectClass) {objectClass=newObjectClass;}
+         // the show method
+         virtual void show(std::ostream& out);
+      protected:
+         ObjectClassHandle objectClass;
+      private:
+   };
+
+   class CERTI_EXPORT New_NetworkMessage {
+      public:
+         New_NetworkMessage();
+         ~New_NetworkMessage();
+         void serialize(MessageBuffer& msgBuffer);
+         void deserialize(MessageBuffer& msgBuffer);
+         // specific Getter(s)/Setter(s)
+         const uint32_t& getType() const {return type;}
+         void setType(const uint32_t& newType) {type=newType;}
+         const FederationTime& getDate() const {return date;}
+         void setDate(const FederationTime& newDate) {
+            hasDate=true;
+            date=newDate;
+         }
+         const std::string& getLabel() const {return label;}
+         void setLabel(const std::string& newLabel) {
+            hasLabel=true;
+            label=newLabel;
+         }
+         const std::string& getTag() const {return tag;}
+         void setTag(const std::string& newTag) {
+            hasTag=true;
+            tag=newTag;
+         }
+         // the show method
+         void show(std::ostream& out);
+      protected:
+         uint32_t type;//required string          name  {default="MessageBaseClass"}
+         FederationTime date;
+         bool hasDate;
+         std::string label;
+         bool hasLabel;
+         std::string tag;
+         bool hasTag;
+      private:
+   };
+
+   class CERTI_EXPORT NM_Factory {
+      public:
+         static NetworkMessage* create(NM_Type type) throw (RTIinternalError);
+         static NetworkMessage* receive(NMStreamType stream) throw (RTIinternalError);
+      protected:
+      private:
+   };
 
+} // end of namespace certi 
+// NM_CLASSES_HH
 #endif
Index: libCERTI/Interaction.hh
===================================================================
RCS file: /sources/certi/certi/libCERTI/Interaction.hh,v
retrieving revision 3.41
diff -u -r3.41 Interaction.hh
--- libCERTI/Interaction.hh	7 Mar 2010 21:30:30 -0000	3.41
+++ libCERTI/Interaction.hh	18 Mar 2010 18:31:09 -0000
@@ -172,8 +172,8 @@
 
     InteractionBroadcastList *
     sendInteraction(FederateHandle federate_handle,
-                    std::vector <ParameterHandle> &parameter_list,
-                    std::vector <ParameterValue_t> &value_list,
+                    const std::vector <ParameterHandle> &parameter_list,
+                    const std::vector <ParameterValue_t> &value_list,
                     uint16_t list_size,
                     FederationTime the_time,
 		    const RTIRegion *,
@@ -185,8 +185,8 @@
 
     InteractionBroadcastList *
     sendInteraction(FederateHandle federate_handle,
-                    std::vector <ParameterHandle> &parameter_list,
-                    std::vector <ParameterValue_t> &value_list,
+                    const std::vector <ParameterHandle> &parameter_list,
+                    const std::vector <ParameterValue_t> &value_list,
                     uint16_t list_size,
 		    const RTIRegion *,
                     const std::string& the_tag)
Index: libCERTI/InteractionBroadcastList.cc
===================================================================
RCS file: /sources/certi/certi/libCERTI/InteractionBroadcastList.cc,v
retrieving revision 3.14
diff -u -r3.14 InteractionBroadcastList.cc
--- libCERTI/InteractionBroadcastList.cc	21 Oct 2009 18:56:28 -0000	3.14
+++ libCERTI/InteractionBroadcastList.cc	18 Mar 2010 18:31:09 -0000
@@ -61,7 +61,7 @@
 /*! theMsg must have been allocated, and will be destroyed by the destructor.
   theMsg->NumeroFedere is added to the list, and its state is set as "Sent".
 */
-InteractionBroadcastList::InteractionBroadcastList(NetworkMessage *theMsg)
+InteractionBroadcastList::InteractionBroadcastList(NM_Receive_Interaction *theMsg)
 {
 
     G.Out(pdGendoc,"enter InteractionBroadcastList::InteractionBroadcastList");
Index: libCERTI/InteractionBroadcastList.hh
===================================================================
RCS file: /sources/certi/certi/libCERTI/InteractionBroadcastList.hh,v
retrieving revision 3.9
diff -u -r3.9 InteractionBroadcastList.hh
--- libCERTI/InteractionBroadcastList.hh	30 May 2008 14:01:05 -0000	3.9
+++ libCERTI/InteractionBroadcastList.hh	18 Mar 2010 18:31:09 -0000
@@ -26,6 +26,7 @@
 #include "certi.hh"
 #include "NetworkMessage.hh"
 #include "SecurityServer.hh"
+#include "NM_Classes.hh"
 
 #include <list>
 
@@ -48,7 +49,7 @@
 class InteractionBroadcastList
 {
 public:
-    InteractionBroadcastList(NetworkMessage *theMsg);
+    InteractionBroadcastList(NM_Receive_Interaction *theMsg);
     ~InteractionBroadcastList();
 
     void clear();
@@ -59,7 +60,7 @@
      * The Message to be broadcasted. This message must be allocated before
      * calling the constructor of the class, be is deleted by the destructor.
      */
-    NetworkMessage *message ;
+    NM_Receive_Interaction *message ;
 
 private:
     InteractionBroadcastLine *getLineWithFederate(FederateHandle theFederate);
Index: libCERTI/NetworkMessage.hh
===================================================================
RCS file: /sources/certi/certi/libCERTI/NetworkMessage.hh,v
retrieving revision 3.58
diff -u -r3.58 NetworkMessage.hh
--- libCERTI/NetworkMessage.hh	7 Mar 2010 21:30:30 -0000	3.58
+++ libCERTI/NetworkMessage.hh	18 Mar 2010 18:31:10 -0000
@@ -44,7 +44,7 @@
 
 /**
  * NetworkMessage is the base class used
- * for modelling message exchanged between RTIG and RTIA.
+ * for modeling message exchanged between RTIG and RTIA.
  * NetworkMessage is the base class of a class hierarchy.
  * Each specific message is a (direct of indirect)
  * daughter class of NetworkMessage.    
@@ -114,6 +114,7 @@
 				QUERY_ATTRIBUTE_OWNERSHIP,
 				ATTRIBUTE_IS_NOT_OWNED,
 				INFORM_ATTRIBUTE_OWNERSHIP,
+				ATTRIBUTE_OWNERSHIP_BASE, /* NOT USED */
 				NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE,
 				ATTRIBUTE_OWNERSHIP_ACQUISITION_NOTIFICATION,
 				ATTRIBUTE_OWNERSHIP_DIVESTITURE_NOTIFICATION,
@@ -138,7 +139,7 @@
 				DDM_SUBSCRIBE_INTERACTION,
 				DDM_UNSUBSCRIBE_INTERACTION,
 				PROVIDE_ATTRIBUTE_VALUE_UPDATE,
-				GET_FED_FILE_SUPPRESSED,
+				/* GET_FED_FILE_SUPPRESSED, */
 				SET_CLASS_RELEVANCE_ADVISORY_SWITCH,
 				SET_INTERACTION_RELEVANCE_ADVISORY_SWITCH,
 				SET_ATTRIBUTE_RELEVANCE_ADVISORY_SWITCH,
@@ -172,60 +173,16 @@
 	 * Send a message buffer to the socket
 	 */
 	void send(Socket* socket, MessageBuffer& msgBuffer) throw (NetworkError, NetworkSignal);
-	void receive(Socket* socket, MessageBuffer& msgBuffer) throw (NetworkError, NetworkSignal);
-
-	// Parameter and Attribute Management
-	// Remove the Parameter of rank 'Rank' in the ParamArray and its value in
-	// ValueArray. If there are other parameter in the list, they are shifted
-	// one rank back.
-	// Ex: ParamArraySize = 3,
-	// ParamArray =[1, 2, 3], ValueArray =["Val1", "Val2", "Val3"]
-	//->removeParameter(1)
-	// ParamArraySize = 2,
-	// ParamArray =[1, 3], ValueArray =["Val1", "Val3"]
-	void removeParameter(uint16_t Rank);
-
-	// See RemoveParameter for explanations.
-	void removeAttribute(uint16_t Rank);
-
-	// Value Array Management
-
-	void setAHS(const std::vector <AttributeHandle> &, int);
-
-	void displayValueArray(char *);
-
-	int bestEffortPeer ;
-	unsigned long bestEffortAddress ;
-
-	int numberOfRegulators ;
 
-	/* NM_DDM_Base class fields */
-	SpaceHandle            space;
-	int32_t                nbExtents;
-	int32_t                region;
-	ObjectHandle           object;
-	ObjectClassHandle      objectClass;
-	InteractionClassHandle interactionClass;
-
-	unsigned long multicastAddress ;
-
-	void sizeValueArray(int size) ;
-
-	ObjectHandle firstId ;
-	ObjectHandle lastId ;
-
-	EventRetractionHandle eventRetraction ;
-
-	/* NM_WithHandleArray class specific fields */
-	uint16_t handleArraySize ;
-	std::vector <AttributeHandle> handleArray ;
-	std::vector <AttributeValue_t> valueArray ;
+	/**
+	 * Receive a message buffer from the socket
+	 */
+	void receive(Socket* socket, MessageBuffer& msgBuffer) throw (NetworkError, NetworkSignal);
 
-	TransportType transport ;
-	OrderType order ;
+	EventRetractionHandle eventRetraction ; /* FIXME to be suppressed */
 
 	/** The name corresponding to message type */
-	const char* getName() const {return name;}
+	const char* getMessageName() const {return messageName;}
 
 	/**
 	 * The federation handle 
@@ -253,7 +210,7 @@
 	 * this as a plain char* because it won't be changed
 	 * it's thus cheaper to build than an std::string.
 	 */
-	const char* name;	
+	const char* messageName;
 
 	/** 
 	 * The network message type
Index: libCERTI/SocketMC.hh
===================================================================
RCS file: /sources/certi/certi/libCERTI/SocketMC.hh,v
retrieving revision 3.15
diff -u -r3.15 SocketMC.hh
--- libCERTI/SocketMC.hh	25 Nov 2009 21:48:04 -0000	3.15
+++ libCERTI/SocketMC.hh	18 Mar 2010 18:31:12 -0000
@@ -22,6 +22,7 @@
 
 #include "Socket.hh"
 #include "NetworkMessage.hh"
+#include "MessageBuffer.hh"
 
 namespace certi {
 
@@ -64,6 +65,7 @@
 	int timeoutMC(int, int);
 
 	int _num_msg ;
+	MessageBuffer   MCMessageBuffer;
 };
 
 } // namespace certi
Index: libCERTI/Object.cc
===================================================================
RCS file: /sources/certi/certi/libCERTI/Object.cc,v
retrieving revision 3.27
diff -u -r3.27 Object.cc
--- libCERTI/Object.cc	14 Mar 2010 14:38:27 -0000	3.27
+++ libCERTI/Object.cc	18 Mar 2010 18:31:10 -0000
@@ -86,7 +86,7 @@
     AttributeMap::const_iterator i = _attributeMap.find(attributeHandle);
     if (i == _attributeMap.end()) {
         throw AttributeNotDefined(stringize() <<
-            "Unknown attribute handle " << attributeHandle);
+            "Object::getAttribute(AttributeHandle) Unknown attribute handle <" << attributeHandle<<">");
     }
     return i->second;
 }
Index: libCERTI/ObjectSet.cc
===================================================================
RCS file: /sources/certi/certi/libCERTI/ObjectSet.cc,v
retrieving revision 3.29
diff -u -r3.29 ObjectSet.cc
--- libCERTI/ObjectSet.cc	14 Mar 2010 14:38:27 -0000	3.29
+++ libCERTI/ObjectSet.cc	18 Mar 2010 18:31:12 -0000
@@ -239,16 +239,19 @@
 
         NetworkMessage *answer;
         if (oa->getOwner()) {
-        	answer = NM_Factory::create(NetworkMessage::INFORM_ATTRIBUTE_OWNERSHIP);
+        	NM_Inform_Attribute_Ownership* IAO = new NM_Inform_Attribute_Ownership();
+        	IAO->setObject(the_object);
+        	IAO->setAttribute(the_attribute);
+        	answer = IAO;
         } else {
-        	answer = NM_Factory::create(NetworkMessage::ATTRIBUTE_IS_NOT_OWNED);
+        	NM_Attribute_Is_Not_Owned* AINO = new NM_Attribute_Is_Not_Owned();
+        	AINO->setObject(the_object);
+        	AINO->setAttribute(the_attribute);
+        	answer = AINO;
         }
 
         answer->federation = server->federation();
         answer->setException(e_NO_EXCEPTION);
-        answer->object = the_object ;
-        answer->handleArray.resize(1) ;
-        answer->handleArray[0] = the_attribute ;
         answer->federate = oa->getOwner();
 
         sendToFederate(answer, the_federate);
@@ -327,7 +330,7 @@
 void ObjectSet::
 cancelNegotiatedAttributeOwnershipDivestiture(FederateHandle the_federate,
                                               ObjectHandle the_object,
-                                              std::vector <AttributeHandle> &the_attributes,
+                                              const std::vector <AttributeHandle> &the_attributes,
                                               uint16_t the_size)
     throw (ObjectNotKnown,
            AttributeNotDefined,
Index: libCERTI/Interaction.cc
===================================================================
RCS file: /sources/certi/certi/libCERTI/Interaction.cc,v
retrieving revision 3.60
diff -u -r3.60 Interaction.cc
--- libCERTI/Interaction.cc	7 Mar 2010 21:30:30 -0000	3.60
+++ libCERTI/Interaction.cc	18 Mar 2010 18:31:09 -0000
@@ -142,15 +142,15 @@
 	G.Out(pdGendoc,"enter Interaction::broadcastInteractionMessage");
 
 	// 1. Set InteractionHandle to local class Handle.
-	ibList->message->interactionClass = handle ;
+	ibList->message->setInteractionClass(handle);
 
 	// 2. Update message Parameters list by removing child's Parameters.
-	for (int i = 0 ; i < ibList->message->handleArraySize ;) {
+	for (uint32_t i = 0 ; i < ibList->message->getParametersSize() ;) {
 		// If the Parameter is not in that class, remove it from the message.
-                if (hasParameter(ibList->message->handleArray[i])) {
+                if (hasParameter(ibList->message->getParameters(i))) {
 			++i;
                 } else {
-			ibList->message->removeParameter(i);
+			ibList->message->removeParameters(i);
                 }
 	}
 
@@ -398,8 +398,8 @@
  */
 InteractionBroadcastList *
 Interaction::sendInteraction(FederateHandle federate_handle,
-		std::vector <ParameterHandle> &parameter_list,
-		std::vector <ParameterValue_t> &value_list,
+		const std::vector <ParameterHandle> &parameter_list,
+		const std::vector <ParameterValue_t> &value_list,
 		uint16_t list_size,
 		FederationTime time,
 		const RTIRegion *region,
@@ -419,21 +419,20 @@
 	// Prepare and Broadcast message for this class
 	InteractionBroadcastList *ibList = NULL ;
 	if (server != NULL) {
-		NetworkMessage *answer = NM_Factory::create(NetworkMessage::RECEIVE_INTERACTION) ;
+		NM_Receive_Interaction *answer = new NM_Receive_Interaction() ;
 		answer->setException (e_NO_EXCEPTION);
 		answer->federation = server->federation();
 		answer->federate = federate_handle ;
-		answer->interactionClass = handle ; // Interaction Class Handle
+		answer->setInteractionClass(handle) ; // Interaction Class Handle
 		answer->setDate(time);
 
 		answer->setLabel(the_tag);
 
-		answer->handleArraySize = list_size ;
-		answer->handleArray.resize(list_size) ;
-		answer->sizeValueArray(list_size);
+		answer->setParametersSize(list_size);
+		answer->setValuesSize(list_size) ;
 		for (int i = 0 ; i < list_size ; i++) {
-			answer->handleArray[i] = parameter_list[i] ;
-			answer->valueArray[i] = value_list[i];
+			answer->setParameters(parameter_list[i],i);
+			answer->setValues(value_list[i],i);
 		}
 
 		D.Out(pdProtocol, "Preparing broadcast list.");
@@ -459,8 +458,8 @@
  */
 InteractionBroadcastList *
 Interaction::sendInteraction(FederateHandle federate_handle,
-		std::vector <ParameterHandle> &parameter_list,
-		std::vector <ParameterValue_t> &value_list,
+		const std::vector <ParameterHandle> &parameter_list,
+		const std::vector <ParameterValue_t> &value_list,
 		uint16_t list_size,
 		const RTIRegion *region,
 		const std::string& the_tag)
@@ -479,20 +478,19 @@
 	// Prepare and Broadcast message for this class
 	InteractionBroadcastList *ibList = NULL ;
 	if (server != NULL) {
-		NetworkMessage *answer = NM_Factory::create(NetworkMessage::RECEIVE_INTERACTION) ;
+		NM_Receive_Interaction *answer = new NM_Receive_Interaction();
 		answer->setException(e_NO_EXCEPTION);
 		answer->federation = server->federation();
 		answer->federate = federate_handle ;
-		answer->interactionClass = handle ; // Interaction Class Handle
+		answer->setInteractionClass(handle); // Interaction Class Handle
 		answer->setLabel(the_tag);
 
-		answer->handleArraySize = list_size ;
-		answer->handleArray.resize(list_size) ;
-		answer->sizeValueArray(list_size);
+		answer->setParametersSize(list_size);
+		answer->setValuesSize(list_size);
 
 		for (int i = 0 ; i < list_size ; i++) {
-			answer->handleArray[i] = parameter_list[i] ;
-			answer->valueArray[i] = value_list[i];
+			answer->setParameters(parameter_list[i],i);
+			answer->setValues(value_list[i],i);
 		}
 
 		D.Out(pdProtocol, "Preparing broadcast list.");
Index: libCERTI/NetworkMessage.cc
===================================================================
RCS file: /sources/certi/certi/libCERTI/NetworkMessage.cc,v
retrieving revision 3.45
diff -u -r3.45 NetworkMessage.cc
--- libCERTI/NetworkMessage.cc	7 Mar 2010 21:30:30 -0000	3.45
+++ libCERTI/NetworkMessage.cc	18 Mar 2010 18:31:10 -0000
@@ -38,91 +38,19 @@
 NetworkMessage::NetworkMessage()
     : type(NOT_USED), exception(e_NO_EXCEPTION)
 {
-    name               = "NetworkMessage (generic)";
+    messageName        = "NetworkMessage (generic)";
 
     federation         = 0 ;
     federate           = 0 ;
         
-    bestEffortPeer = -1 ;
-    bestEffortAddress = 0 ;
-    numberOfRegulators = 0;
-    multicastAddress = 0;
-    
     date             = 0.0;
 
-    object           = 0 ;
-    objectClass      = 0 ;
-    interactionClass = 0 ;
-
-    handleArraySize  = 0 ;
-    valueArray.empty();
-
 } /* end of NetworkMessage() */
 
 NetworkMessage::~NetworkMessage() {
 	
 }
 
-// ----------------------------------------------------------------------------
-void
-NetworkMessage::removeAttribute(uint16_t Rank)
-{
-    if (Rank >= valueArray.size())
-        throw RTIinternalError("Bad Rank while removing Nmessage attribute.");
-
-    handleArray.erase(handleArray.begin() + Rank);
-    valueArray.erase(valueArray.begin() + Rank);
-
-    handleArraySize -- ;
-}
-
-// ----------------------------------------------------------------------------
-void
-NetworkMessage::removeParameter(uint16_t Rank)
-{
-    if (Rank >= valueArray.size())
-        throw RTIinternalError("Bad Rank while removing Nmessage parameter.");
-
-    handleArray.erase(handleArray.begin() + Rank);
-    valueArray.erase(valueArray.begin() + Rank);
-
-    handleArraySize -- ;
-}
-
-// ----------------------------------------------------------------------------
-void
-NetworkMessage::setAHS(const std::vector <AttributeHandle> &attr, int size)
-{
-    handleArraySize = size ;
-    handleArray.resize(size) ;
-    for (int i = 0 ; i < size ; ++i) {
-        handleArray[i] = attr[i] ;
-    }
-}
-// ----------------------------------------------------------------------------
-void
-NetworkMessage::sizeValueArray(int size)
-{
-valueArray.resize(size) ;
-}
-// ----------------------------------------------------------------------------
-void
-NetworkMessage::displayValueArray(char *titre)
-{
-    printf("(%s) valueArray size=%d\n",titre,(int)valueArray.size());
-    for (int i=0; i<(int)valueArray.size();i++)
-    {
-        printf("%d : length=%d : value=",i,(int)(valueArray[i].length()));
-
-        for(int k=0; k<(int)valueArray[i].length(); k++)
-            if (isprint(valueArray[i][k]) == 0 )
-                printf(" %x",valueArray[i][k]);
-            else
-                printf("%c",valueArray[i][k]);
-
-        printf("\n");
-    }
-}
 
 } // namespace certi
 
Index: libCERTI/ObjectClassBroadcastList.hh
===================================================================
RCS file: /sources/certi/certi/libCERTI/ObjectClassBroadcastList.hh,v
retrieving revision 3.10
diff -u -r3.10 ObjectClassBroadcastList.hh
--- libCERTI/ObjectClassBroadcastList.hh	11 Jun 2008 15:19:22 -0000	3.10
+++ libCERTI/ObjectClassBroadcastList.hh	18 Mar 2010 18:31:10 -0000
@@ -27,6 +27,7 @@
 
 #include "certi.hh"
 #include "NetworkMessage.hh"
+#include "NM_Classes.hh"
 #include "SecurityServer.hh"
 
 #include <list>
@@ -35,52 +36,138 @@
 
 namespace certi {
 
+/**
+ * An object broadcast line represents a federate
+ * interested in part (or all) of the attributes of
+ * the message referenced in the ObjectClassBroadcastList.
+ */
 class ObjectBroadcastLine {
 public:
-    enum State { sent, waiting, notSub };
-
-    ObjectBroadcastLine(FederateHandle fed, State init = notSub);
-
-    FederateHandle Federate ;
-
-    State state[MAX_STATE_SIZE+1] ;
+	/**
+	 * The state of the attribute
+	 * for the federate in this broadcast line
+	 */
+	enum State {
+		sent,    /**< the attribute has been sent                       */
+		waiting, /**< the attribute is waiting to be sent               */
+		notSub   /**< the federate did not subscribed to this attribute */
+	};
+
+	ObjectBroadcastLine(FederateHandle fed, State init = notSub);
+
+	/* The Federate Handle */
+	FederateHandle Federate ;
+
+	/**
+	 * The state of the attributes.
+	 * The index of the state array is the attribute handle
+	 * FIXME we should rather use a map, because the
+	 * FIXME attribute handle may be very sparse.
+	 */
+	State state[MAX_STATE_SIZE+1] ;
 
 };
 
-/*! This class is used to carry necessary information for broadcasting a
-  RegisterObject() or an UpdateAttributeValues().
-*/
+/**
+ * An ObjectClassBroadcastList consist in a message associated
+ * with a list of federate which could be interested by part
+ * of this message because it has subscribed to part or
+ * all of the object instance/class attribute.
+ * Thus an instance of this class carries the necessary information for
+ * broadcasting the following type of messages:
+ * <ul>
+ *   <li> NM_Remove_Object </li>
+ * 	 <li> NM_Discover_Object </li>
+ *   <li> NM_Reflect_Attribute_Values </li>
+ *   <li> NM_Request_Attribute_Ownership_Assumption </li>
+ *   <li> NM_Attribute_Ownership_Divestiture_Notification </li>
+ * </ul>
+ * A federate is represented by an ObjectBroadcastLine.
+ */
 class ObjectClassBroadcastList {
 
 public:
-    ObjectClassBroadcastList(NetworkMessage *, AttributeHandle = 0);
-    ~ObjectClassBroadcastList();
+	/**
+	 * The provided msg must have been allocated, and will be destroyed
+	 * by the destructor.
+	 * msg->federate is added to the list, and its state is set as "Sent"
+	 * for all attributes. For RAVs messages, MaxAttHandle is the greatest
+	 * attribute handle of the class. For Discover_Object message, it can be 0 to
+	 * mean "any attribute".
+	 */
+	ObjectClassBroadcastList(NetworkMessage *msg, AttributeHandle maxAttributeHandles = 0)
+	throw (RTIinternalError);
+
+	~ObjectClassBroadcastList();
+
+	NetworkMessage* getMsg() {return msg;}
+	NM_Remove_Object*                                getMsgRO()   {return msgRO;}
+	NM_Discover_Object*                              getMsgDO()	  {return msgDO;}
+	NM_Reflect_Attribute_Values*     		  	     getMsgRAV()  {return msgRAV;}
+	NM_Request_Attribute_Ownership_Assumption*       getMsgRAOA() {return msgRAOA;}
+	NM_Attribute_Ownership_Divestiture_Notification* getMsgAODN() {return msgAODN;}
+
+	/**
+	 * Clear the broadcast lines.
+	 */
+	void clear();
+
+	/**
+	 * Add a federate interested in the broadcast.
+	 * @param[in] federate, the handle of the interested Federate
+	 * @param[in] attribute,
+	 */
+	void addFederate(FederateHandle federate, AttributeHandle attribute = 0);
+
+	/**
+	 * Send all the pending message to all concerned
+	 * Federate stored in the broadcast lines.
+	 */
+	void sendPendingMessage(SecurityServer *server);
+
+	/**
+	 * Upcast class to appropriate message.
+	 * The inheritance feature of HLA imply that a federate subscribing
+	 * to a superclass attribute which effectively belong to an instance
+	 * of object of a derived (HLA meaning) class  should receive
+	 * Federate callback (e.g. discover object) of the appropriate level
+	 * i.e. the one he subscribed to.
+	 */
+	void upcastTo(ObjectClassHandle objectClass);
+
+protected:
+	NetworkMessage                                      *msg;
+	NM_Remove_Object                                  *msgRO;
+	NM_Discover_Object                                *msgDO;
+	NM_Reflect_Attribute_Values                      *msgRAV;
+	NM_Request_Attribute_Ownership_Assumption       *msgRAOA;
+	NM_Attribute_Ownership_Divestiture_Notification *msgAODN;
 
-    void clear();
-    void addFederate(FederateHandle, AttributeHandle = 0);
-    void sendPendingMessage(SecurityServer *server);
+private:
 
-    NetworkMessage *message ;
+	template <typename T>
+	T* createReducedMessage(T* msg, ObjectBroadcastLine *line);
+
+	template <typename T>
+	T* createReducedMessageWithValue(T* msg, ObjectBroadcastLine *line);
 
-private:
-    NetworkMessage *adaptMessage(ObjectBroadcastLine *line);
 
-    //! Return the line of the list describing federate 'theFederate', or NULL.
-    ObjectBroadcastLine *getLineWithFederate(FederateHandle theFederate);
+	//! Return the line of the list describing federate 'theFederate', or NULL.
+	ObjectBroadcastLine *getLineWithFederate(FederateHandle theFederate);
 
-    bool isWaiting(ObjectBroadcastLine *line);
+	bool isWaiting(ObjectBroadcastLine *line);
 
-    /*! The two next methods are called by the public SendPendingMessage
+	/*! The two next methods are called by the public SendPendingMessage
       methods. They respectively handle DiscoverObject and
       ReflectAttributeValues messages.
-    */
-    void sendPendingDOMessage(SecurityServer *server);
-    void sendPendingRAVMessage(SecurityServer *server);
-
-    AttributeHandle maxHandle ;
-    std::list<ObjectBroadcastLine *> lines ;
-    /* The message buffer used to send Network messages */
-    MessageBuffer NM_msgBufSend;
+	 */
+	void sendPendingDOMessage(SecurityServer *server);
+	void sendPendingRAVMessage(SecurityServer *server);
+
+	AttributeHandle maxHandle ;
+	std::list<ObjectBroadcastLine *> lines ;
+	/* The message buffer used to send Network messages */
+	MessageBuffer NM_msgBufSend;
 };
 
 } // namespace certi
Index: libCERTI/ObjectClassSet.hh
===================================================================
RCS file: /sources/certi/certi/libCERTI/ObjectClassSet.hh,v
retrieving revision 3.39
diff -u -r3.39 ObjectClassSet.hh
--- libCERTI/ObjectClassSet.hh	27 Feb 2010 16:53:36 -0000	3.39
+++ libCERTI/ObjectClassSet.hh	18 Mar 2010 18:31:10 -0000
@@ -85,7 +85,7 @@
 	throw (ObjectClassNotDefined, AttributeNotDefined, RTIinternalError,
 			SecurityError);
 
-	void subscribe(FederateHandle, ObjectClassHandle, std::vector <AttributeHandle> &,
+	void subscribe(FederateHandle, ObjectClassHandle, const std::vector <AttributeHandle> &,
 			int theListSize, const RTIRegion * = 0)
 	throw (ObjectClassNotDefined, AttributeNotDefined, RTIinternalError,
 			SecurityError);
@@ -109,8 +109,8 @@
 
 	void updateAttributeValues(FederateHandle theFederateHandle,
                         Object* object,
-			std::vector <AttributeHandle> &theAttribArray,
-			std::vector <AttributeValue_t> &theValueArray,
+			const std::vector <AttributeHandle> &theAttribArray,
+			const std::vector <AttributeValue_t> &theValueArray,
 			const FederationTime& theTime,
 			const std::string& theUserTag)
 	throw (AttributeNotDefined, AttributeNotOwned,
@@ -118,8 +118,8 @@
 
 	void updateAttributeValues(FederateHandle theFederateHandle,
                         Object* object,
-			std::vector <AttributeHandle> &theAttribArray,
-			std::vector <AttributeValue_t> &theValueArray,
+			const std::vector <AttributeHandle> &theAttribArray,
+			const std::vector <AttributeValue_t> &theValueArray,
 			const std::string& theUserTag)
 	throw (AttributeNotDefined, AttributeNotOwned,
 			RTIinternalError, InvalidObjectHandle);
@@ -128,7 +128,7 @@
 	// Ownership Management
 	void negotiatedAttributeOwnershipDivestiture(FederateHandle,
 			Object* object,
-			std::vector <AttributeHandle> &,
+			const std::vector <AttributeHandle> &,
 			const std::string& theTag)
 	throw (AttributeNotDefined, AttributeNotOwned,
 			AttributeAlreadyBeingDivested, RTIinternalError);
@@ -136,33 +136,33 @@
 
 	void attributeOwnershipAcquisitionIfAvailable(FederateHandle,
 			Object* object,
-			std::vector <AttributeHandle>&)
+			const std::vector <AttributeHandle>&)
 	throw (ObjectClassNotPublished, AttributeNotDefined,
 			AttributeNotPublished, FederateOwnsAttributes,
 			AttributeAlreadyBeingAcquired, RTIinternalError);
 
 	void unconditionalAttributeOwnershipDivestiture(FederateHandle,
 			Object* object,
-			std::vector <AttributeHandle>&)
+			const std::vector <AttributeHandle>&)
 	throw (AttributeNotDefined, AttributeNotOwned,
 			RTIinternalError);
 
 	void attributeOwnershipAcquisition(FederateHandle theFederateHandle,
 			Object* object,
-			std::vector <AttributeHandle> &theAttributeList,
+			const std::vector <AttributeHandle> &theAttributeList,
 			const std::string& theTag)
 	throw (ObjectClassNotPublished, AttributeNotDefined,
 			AttributeNotPublished, FederateOwnsAttributes, RTIinternalError);
 
 	AttributeHandleSet *attributeOwnershipReleaseResponse(FederateHandle,
 			Object* object,
-			std::vector <AttributeHandle> &)
+			const std::vector <AttributeHandle> &)
 	throw (AttributeNotDefined, AttributeNotOwned,
 			FederateWasNotAskedToReleaseAttribute, RTIinternalError);
 
 	void cancelAttributeOwnershipAcquisition(FederateHandle theFederateHandle,
 			Object* object,
-			std::vector <AttributeHandle> &theAttributeList)
+			const std::vector <AttributeHandle> &theAttributeList)
 	throw (AttributeNotDefined, AttributeAlreadyOwned,
 			AttributeAcquisitionWasNotRequested, RTIinternalError);
 
Index: libCERTI/InteractionSet.cc
===================================================================
RCS file: /sources/certi/certi/libCERTI/InteractionSet.cc,v
retrieving revision 3.32
diff -u -r3.32 InteractionSet.cc
--- libCERTI/InteractionSet.cc	7 Mar 2010 21:30:30 -0000	3.32
+++ libCERTI/InteractionSet.cc	18 Mar 2010 18:31:09 -0000
@@ -63,8 +63,8 @@
 void
 InteractionSet::broadcastInteraction(FederateHandle federate_handle,
 		InteractionClassHandle interaction_handle,
-		std::vector <ParameterHandle> &parameter_list,
-		std::vector <ParameterValue_t> &value_list,
+		const std::vector <ParameterHandle> &parameter_list,
+		const std::vector <ParameterValue_t> &value_list,
 		uint16_t list_size,
 		FederationTime the_time,
 		const RTIRegion *region,
@@ -112,8 +112,8 @@
 void
 InteractionSet::broadcastInteraction(FederateHandle federate_handle,
 		InteractionClassHandle interaction_handle,
-		std::vector <ParameterHandle> &parameter_list,
-		std::vector <ParameterValue_t> &value_list,
+		const std::vector <ParameterHandle> &parameter_list,
+		const std::vector <ParameterValue_t> &value_list,
 		uint16_t list_size,
 		const RTIRegion *region,
 		const std::string& the_tag)
Index: libCERTI/RootObject.cc
===================================================================
RCS file: /sources/certi/certi/libCERTI/RootObject.cc,v
retrieving revision 3.49
diff -u -r3.49 RootObject.cc
--- libCERTI/RootObject.cc	25 Nov 2009 22:05:19 -0000	3.49
+++ libCERTI/RootObject.cc	18 Mar 2010 18:31:12 -0000
@@ -364,19 +364,19 @@
 {
         // The rounting spaces
         uint32_t routingSpaceCount = spaces.size();
-        message.setNumRoutingSpaces(routingSpaceCount);
+        message.setRoutingSpacesSize(routingSpaceCount);
         for (uint32_t i = 0; i < routingSpaceCount; ++i) {
                 const RoutingSpace& rs = spaces[i];
-                NM_FOM_Routing_Space& mrs = message.getRoutingSpace(i);
+                NM_FOM_Routing_Space& mrs = message.getRoutingSpaces(i);
 
-                mrs.setHandle(rs.getHandle());
+                mrs.setSpace(rs.getHandle());
                 mrs.setName(rs.getName());
 
                 uint32_t dimensionCount = rs.getDimensions().size();
-                mrs.setNumDimensions(dimensionCount);
+                mrs.setDimensionsSize(dimensionCount);
                 for (uint32_t j = 0; j < dimensionCount; ++j) {
                         const Dimension& d = rs.getDimensions()[j];
-                        NM_FOM_Dimension& md = mrs.getDimension(j);
+                        NM_FOM_Dimension& md = mrs.getDimensions(j);
 
                         md.setHandle(d.getHandle());
                         md.setName(d.getName());
@@ -384,17 +384,17 @@
         }
 
         // The object classes
-        message.setNumObjectClasses(ObjectClasses->size());
+        message.setObjectClassesSize(ObjectClasses->size());
         uint32_t idx = 0;
         for (ObjectClassSet::handled_const_iterator i = ObjectClasses->handled_begin();
              i != ObjectClasses->handled_end(); ++i, ++idx) {
                 const ObjectClass* objectClass = i->second;
-                NM_FOM_Object_Class& moc = message.getObjectClass(idx);
+                NM_FOM_Object_Class& moc = message.getObjectClasses(idx);
 
                 moc.setHandle(objectClass->getHandle());
                 std::string name = objectClass->getName();
                 ObjectClassHandle superclassHandle = objectClass->getSuperclass();
-                moc.setSuperclassHandle(superclassHandle);
+                moc.setSuperClass(superclassHandle);
 
                 ObjectClass* parent = 0;
                 if (0 < superclassHandle) {
@@ -419,8 +419,8 @@
 
                         const ObjectClassAttribute* attribute = j->second;
 
-                        moc.setNumAttributes(++jdx);
-                        NM_FOM_Attribute& ma = moc.getAttribute(jdx - 1);
+                        moc.setAttributesSize(++jdx);
+                        NM_FOM_Attribute& ma = moc.getAttributes(jdx - 1);
 
                         ma.setHandle(attribute->getHandle());
                         ma.setName(attribute->getName());
@@ -432,18 +432,18 @@
 
 
         // The interaction classes
-        message.setNumInteractionClasses(Interactions->size());
+        message.setInteractionClassesSize(Interactions->size());
         idx = 0;
         for (InteractionSet::handled_const_iterator i = Interactions->handled_begin();
              i != Interactions->handled_end(); ++i, ++idx) {
                 Interaction* interactionClass = i->second;
-                NM_FOM_Interaction_Class& mic = message.getInteractionClass(idx);
+                NM_FOM_Interaction_Class& mic = message.getInteractionClasses(idx);
 
-                mic.setHandle(interactionClass->getHandle());
+                mic.setInteractionClass(interactionClass->getHandle());
                 std::string name = interactionClass->getName();
                 InteractionClassHandle superclassHandle = interactionClass->getSuperclass();
-                mic.setSuperclassHandle(superclassHandle);
-                mic.setSpaceHandle(interactionClass->getSpace());
+                mic.setSuperClass(superclassHandle);
+                mic.setSpace(interactionClass->getSpace());
                 mic.setOrder(interactionClass->order);
                 mic.setTransport(interactionClass->transport);
 
@@ -470,8 +470,8 @@
                         if (parent && parent->hasParameter(parameter->getHandle()))
                                 continue;
 
-                        mic.setNumParameters(++jdx);
-                        NM_FOM_Parameter& mp = mic.getParameter(jdx - 1);
+                        mic.setParametersSize(++jdx);
+                        NM_FOM_Parameter& mp = mic.getParameters(jdx - 1);
 
                         mp.setHandle(parameter->getHandle());
                         mp.setName(parameter->getName());
@@ -483,17 +483,17 @@
 RootObject::rebuildFromSerializedFOM(const NM_Join_Federation_Execution& message)
 {
         // The number of routing space records to read
-        uint32_t routingSpaceCount = message.getNumRoutingSpaces();
+        uint32_t routingSpaceCount = message.getRoutingSpacesSize();
         for (uint32_t i = 0; i < routingSpaceCount; ++i) {
-                const NM_FOM_Routing_Space& mrs = message.getRoutingSpace(i);
+                const NM_FOM_Routing_Space& mrs = message.getRoutingSpaces(i);
 
                 RoutingSpace current;
-                current.setHandle(mrs.getHandle());
+                current.setHandle(mrs.getSpace());
                 current.setName(mrs.getName());
 
-                uint32_t dimensionCount = mrs.getNumDimensions();
+                uint32_t dimensionCount = mrs.getDimensionsSize();
                 for (uint32_t j = 0; j < dimensionCount; ++j) {
-                        const NM_FOM_Dimension& md = mrs.getDimension(j);
+                        const NM_FOM_Dimension& md = mrs.getDimensions(j);
 
                         Dimension dimension(md.getHandle());
                         dimension.setName(md.getName());
@@ -504,22 +504,22 @@
         }
 
         // The number of object class records to read
-        uint32_t objectClassCount = message.getNumObjectClasses();
+        uint32_t objectClassCount = message.getObjectClassesSize();
         for (uint32_t i = 0; i < objectClassCount; ++i) {
-                const NM_FOM_Object_Class& moc = message.getObjectClass(i);
+                const NM_FOM_Object_Class& moc = message.getObjectClasses(i);
 
                 // add the object class to the root object
                 ObjectClass* current = new ObjectClass(moc.getName(), moc.getHandle());
                 ObjectClass* parent = 0;
-                ObjectClassHandle superclassHandle = moc.getSuperclassHandle();
+                ObjectClassHandle superclassHandle = moc.getSuperClass();
                 if (0 < superclassHandle) {
                         parent = getObjectClass(superclassHandle);
                 }
                 addObjectClass(current, parent);
 
-                uint32_t attributeCount = moc.getNumAttributes();
+                uint32_t attributeCount = moc.getAttributesSize();
                 for (uint32_t j = 0; j < attributeCount; ++j) {
-                        const NM_FOM_Attribute& ma = moc.getAttribute(j);
+                        const NM_FOM_Attribute& ma = moc.getAttributes(j);
 
                         // OrderType order = ma.getOrder();
                         // TransportType transport = ma.getTransport();
@@ -534,23 +534,23 @@
         }
 
         // The number of interactions records to read
-        uint32_t interactionsCount = message.getNumInteractionClasses();
+        uint32_t interactionsCount = message.getInteractionClassesSize();
         for (uint32_t i = 0; i < interactionsCount; ++i) {
-                const NM_FOM_Interaction_Class& mic = message.getInteractionClass(i);
+                const NM_FOM_Interaction_Class& mic = message.getInteractionClasses(i);
 
-                Interaction* current = new Interaction(mic.getName(), mic.getHandle(), mic.getTransport(), mic.getOrder());
-                current->setSpace(mic.getSpaceHandle());
+                Interaction* current = new Interaction(mic.getName(), mic.getInteractionClass(), mic.getTransport(), mic.getOrder());
+                current->setSpace(mic.getSpace());
                 Interaction* parent = 0;
-                InteractionClassHandle superclassHandle = mic.getSuperclassHandle();
+                InteractionClassHandle superclassHandle = mic.getSuperClass();
                 if (0 < superclassHandle) {
                         parent = getInteractionClass(superclassHandle);
                 }
 
                 addInteractionClass(current, parent);
 
-                uint32_t parameterCount = mic.getNumParameters();
+                uint32_t parameterCount = mic.getParametersSize();
                 for (uint32_t j = 0; j < parameterCount; ++j) {
-                        const NM_FOM_Parameter& mp = mic.getParameter(j);
+                        const NM_FOM_Parameter& mp = mic.getParameters(j);
 
                         Parameter *parameter = new Parameter(mp.getName(), mp.getHandle());
                         current->addParameter(parameter);
Index: libCERTI/ObjectClassBroadcastList.cc
===================================================================
RCS file: /sources/certi/certi/libCERTI/ObjectClassBroadcastList.cc,v
retrieving revision 3.28
diff -u -r3.28 ObjectClassBroadcastList.cc
--- libCERTI/ObjectClassBroadcastList.cc	7 Mar 2010 21:30:30 -0000	3.28
+++ libCERTI/ObjectClassBroadcastList.cc	18 Mar 2010 18:31:10 -0000
@@ -36,153 +36,209 @@
 static PrettyDebug D("BROADCAST", __FILE__);
 static PrettyDebug G("GENDOC",__FILE__);
 
+template <typename T>
+T* ObjectClassBroadcastList::createReducedMessage(T* msg, ObjectBroadcastLine *line) {
+
+	// Create the reduced message
+	// FIXME whould be better to msg->clone() if a clone method was generated
+	// FIXME or maybe copy constructor
+	// FIXME T *reducedMessage = new T(msg)
+	T *reducedMessage = new T();
+
+	// Copy static informations.
+	reducedMessage->setException(msg->getException());
+	reducedMessage->federation = msg->federation ;
+	reducedMessage->federate = msg->federate ;
+	reducedMessage->setObject(msg->getObject());
+	if (msg->isDated()) {
+		reducedMessage->setDate(msg->getDate());
+	}
+	if (msg->isTagged()) {
+		reducedMessage->setTag(msg->getTag());
+	}
+
+	if (msg->isLabelled()) {
+		reducedMessage->setLabel(msg->getLabel());
+	}
+
+	// Copy attributes that are in the bsWaiting state in Line.
+	uint32_t currentSize ;
+	AttributeHandle currentAttrib ;
+
+	currentSize = 0;
+	reducedMessage->setAttributesSize(currentSize);
+
+	for (uint32_t i = 0 ; i < msg->getAttributesSize() ; ++i) {
+		currentAttrib = msg->getAttributes(i);
+		if (line->state[currentAttrib] == ObjectBroadcastLine::waiting) {
+			// Update number of attributes in ReducedMessage.
+			++currentSize; ;
+			reducedMessage->setAttributesSize(currentSize);
+			// Copy Attribute Handle.
+			reducedMessage->setAttributes(currentAttrib,currentSize);
+		}
+	}
+	return reducedMessage;
+}
+
+template <typename T>
+T* ObjectClassBroadcastList::createReducedMessageWithValue(T* msg, ObjectBroadcastLine *line) {
+
+	// Create the reduced message
+	// FIXME whould be better to msg->clone() if a clone method was generated
+	// FIXME or maybe copy constructor
+	// FIXME T *reducedMessage = new T(msg)
+	T *reducedMessage = new T();
+
+	// Copy static informations.
+	reducedMessage->setException(msg->getException());
+	reducedMessage->federation = msg->federation ;
+	reducedMessage->federate = msg->federate ;
+	reducedMessage->setObject(msg->getObject());
+	if (msg->isDated()) {
+		reducedMessage->setDate(msg->getDate());
+	}
+	if (msg->isTagged()) {
+		reducedMessage->setTag(msg->getTag());
+	}
+
+	if (msg->isLabelled()) {
+		reducedMessage->setLabel(msg->getLabel());
+	}
+
+	// Copy attributes that are in the bsWaiting state in Line.
+	uint32_t currentSize ;
+	AttributeHandle currentAttrib ;
+
+	currentSize = 0;
+	reducedMessage->setAttributesSize(currentSize);
+
+	for (uint32_t i = 0 ; i < msg->getAttributesSize() ; ++i) {
+		currentAttrib = msg->getAttributes(i);
+		if (line->state[currentAttrib] == ObjectBroadcastLine::waiting) {
+			// Update number of attributes in ReducedMessage.
+			++currentSize; ;
+			reducedMessage->setAttributesSize(currentSize);
+			// Copy Attribute Handle.
+			reducedMessage->setAttributes(currentAttrib,currentSize);
+
+			reducedMessage->setValuesSize(currentSize);
+			// Copy Attribute Value.
+			reducedMessage->setValues(msg->getValues(i),currentSize);
+		}
+	}
+	return reducedMessage;
+}
+
 // ----------------------------------------------------------------------------
 /** ObjectBroadcastLine  
  */
 ObjectBroadcastLine::ObjectBroadcastLine(FederateHandle theFederate,
-                                         ObjectBroadcastLine::State init_state)
+		ObjectBroadcastLine::State init_state)
 {
-    Federate = theFederate ;
-    for (AttributeHandle i = 0 ; i <= MAX_STATE_SIZE ; i++)
-        state[i] = init_state ;
+	Federate = theFederate ;
+	for (AttributeHandle i = 0 ; i <= MAX_STATE_SIZE ; i++)
+		state[i] = init_state ;
 }
 
 // ============================================================================
 
 // ----------------------------------------------------------------------------
-/*! Return a copy of the REFLECT_ATTRIBUTE_VALUES message 'Message' containing
-  references omly to the attributes marked as bsWaiting in the line 'line'.
-  The returned message should be deleted later.
-*/
-NetworkMessage *
-ObjectClassBroadcastList::adaptMessage(ObjectBroadcastLine *line)
-{
-    G.Out(pdGendoc,"enter ObjectClassBroadcastList::adaptMessage");
-    G.Out(pdGendoc,"      message->objectClass=%d",message->objectClass);
-
-    if ((message->getType() != NetworkMessage::REFLECT_ATTRIBUTE_VALUES) &&
-        (message->getType() != NetworkMessage::REQUEST_ATTRIBUTE_OWNERSHIP_ASSUMPTION))
-        throw RTIinternalError("Bad Message type in Broadcast's AdaptMsg.");
-
-    // Copy static informations.
-    NetworkMessage *reducedMessage = NM_Factory::create(message->getType());    
-    reducedMessage->setException(message->getException());
-    reducedMessage->federation = message->federation ;
-    reducedMessage->federate = message->federate ;
-    reducedMessage->object = message->object ;
-    if (message->isDated()) {
-    	reducedMessage->setDate(message->getDate());
-    }
-    if (message->isTagged()) {
-    	reducedMessage->setTag(message->getTag());
-    }
-    reducedMessage->objectClass = message->objectClass ;
-
-    if (message->isLabelled()) {
-    	reducedMessage->setLabel(message->getLabel());
-    }
-    // Copy attributes that are in the bsWaiting state in Line.
-    uint16_t currentSize ;
-    AttributeHandle currentAttrib ;
-
-    reducedMessage->handleArraySize = 0 ;
-
-    for (uint16_t i = 0 ; i < message->handleArraySize ; i++) {
-
-        currentAttrib = message->handleArray[i] ;
-
-        if (line->state[currentAttrib] == ObjectBroadcastLine::waiting) {
-
-            // Update number of attributes in ReducedMessage.
-            currentSize = reducedMessage->handleArraySize ;
-            reducedMessage->handleArraySize ++ ;
-            reducedMessage->handleArray.resize(reducedMessage->handleArraySize);
-            reducedMessage->sizeValueArray(reducedMessage->handleArraySize);
-
-            // Copy Attribute Handle.
-            reducedMessage->handleArray[currentSize] = currentAttrib ;
-
-            if (message->getType() == NetworkMessage::REFLECT_ATTRIBUTE_VALUES) {
-                // Copy Attribute Value.
-                reducedMessage->valueArray[currentSize] = message->valueArray[i];
-            }
-        }
-    }
-    G.Out(pdGendoc,"      reducedMessage->objectClass=%d",reducedMessage->objectClass);
-    G.Out(pdGendoc,"exit  ObjectClassBroadcastList::adaptMessage");
-    return reducedMessage ;
-}
-
-// ----------------------------------------------------------------------------
 /*! Add a federate to the list. If it was not present in the list, a
   new line is added and all attributes are marked as bsNotSubscriber.
   Then if the Federate has not been sent a message for this attribute,
   the attribute (for the federate) is marked has
   ObjectBroadcastLine::waiting. theAttribute can be not specified in
   the case of a DiscoverObject message.
-*/
+ */
 void
 ObjectClassBroadcastList::addFederate(FederateHandle theFederate,
-                                      AttributeHandle theAttribute)
+		AttributeHandle theAttribute)
 {
-    if (theAttribute > maxHandle) {
-        D.Out(pdExcept, "Bad attribute handle: %u > %u.", theAttribute,
-              maxHandle);
-        throw RTIinternalError("");
-    }
-
-    ObjectBroadcastLine *line = getLineWithFederate(theFederate);
-
-    if (line == 0) {
-        line =
-            new ObjectBroadcastLine(theFederate, ObjectBroadcastLine::notSub);
-        lines.push_front(line);
-        D.Out(pdRegister, "Adding new line in list for Federate %d.",
-              theFederate);
-    }
-
-    if (line->state[theAttribute] != ObjectBroadcastLine::sent) {
-        line->state[theAttribute] = ObjectBroadcastLine::waiting ;
-        D.Out(pdRegister, "List attribute %d for Federate %d is now "
-              "ObjectBroadcastLine::waiting.", theAttribute, theFederate);
-    }
-    else
-        D.Out(pdTrace,
-              "Message already sent to federate %d about attribute %d.",
-              theFederate, theAttribute);
+	if (theAttribute > maxHandle) {
+		D.Out(pdExcept, "Bad attribute handle: %u > %u.", theAttribute,
+				maxHandle);
+		throw RTIinternalError("Invalid Attribute Handle");
+	}
+
+	ObjectBroadcastLine *line = getLineWithFederate(theFederate);
+
+	if (line == 0) {
+		line =
+				new ObjectBroadcastLine(theFederate, ObjectBroadcastLine::notSub);
+		lines.push_front(line);
+		D.Out(pdRegister, "Adding new line in list for Federate %d.",
+				theFederate);
+	}
+
+	if (line->state[theAttribute] != ObjectBroadcastLine::sent) {
+		line->state[theAttribute] = ObjectBroadcastLine::waiting ;
+		D.Out(pdRegister, "List attribute %d for Federate %d is now "
+				"ObjectBroadcastLine::waiting.", theAttribute, theFederate);
+	}
+	else
+		D.Out(pdTrace,
+				"Message already sent to federate %d about attribute %d.",
+				theFederate, theAttribute);
 }
 
 // ----------------------------------------------------------------------------
-/*! theMsg must have been allocated, and will be destroyed by the destructor.
-  theMsg->federate is added to the list, and its state is set as "Sent"
-  for all attributes. For RAVs messages, MaxAttHandle is the greatest
-  attribute handle of the class. For Discover_Object message, it can be 0 to
-  mean "any attribute".
-*/
-ObjectClassBroadcastList::ObjectClassBroadcastList(NetworkMessage *theMsg,
-                                                   AttributeHandle maxAttHandle)
-    : maxHandle(maxAttHandle)
-{
-    ObjectBroadcastLine *firstLine = 0 ;
-
-    if (theMsg == 0)
-        throw RTIinternalError("Null Broadcast Message.");
 
-    message = theMsg ;
-
-    // Add reference of the sender.
-    if (message->federate != 0) {
-        firstLine = new ObjectBroadcastLine(message->federate,
-                                            ObjectBroadcastLine::sent);
-        lines.push_front(firstLine);
-    }
+ObjectClassBroadcastList::ObjectClassBroadcastList(NetworkMessage *msg,
+		AttributeHandle maxAttHandle)
+throw (RTIinternalError)
+: maxHandle(maxAttHandle)
+{
+	ObjectBroadcastLine *firstLine = NULL;
+
+	if (NULL==msg) {
+		throw RTIinternalError("Null Broadcast Message.");
+	}
+
+	this->msg=msg;
+	/* RAZ specific pointers */
+	msgRO=NULL;
+	msgDO=NULL;
+	msgRAV=NULL;
+	msgRAOA=NULL;
+	msgAODN=NULL;
+
+	/* Initialize specific pointer
+	 * FIXME : this is ugly and will be reworked
+	 * */
+	switch(msg->getType()) {
+	case NetworkMessage::REMOVE_OBJECT:
+		msgRO = static_cast<NM_Remove_Object*>(msg);
+		break;
+	case NetworkMessage::DISCOVER_OBJECT:
+		msgDO = static_cast<NM_Discover_Object*>(msg);
+		break;
+	case NetworkMessage::REFLECT_ATTRIBUTE_VALUES:
+		msgRAV = static_cast<NM_Reflect_Attribute_Values*>(msg);
+		break;
+	case NetworkMessage::REQUEST_ATTRIBUTE_OWNERSHIP_ASSUMPTION:
+		msgRAOA = static_cast<NM_Request_Attribute_Ownership_Assumption*>(msg);
+		break;
+	case NetworkMessage::ATTRIBUTE_OWNERSHIP_DIVESTITURE_NOTIFICATION:
+		msgAODN = static_cast<NM_Attribute_Ownership_Divestiture_Notification*>(msg);
+		break;
+	default:
+		throw RTIinternalError("Unexpected type of message");
+		break;
+	}
+
+	// Add reference of the sender.
+	if (msg->federate != 0) {
+		firstLine = new ObjectBroadcastLine(msg->federate,ObjectBroadcastLine::sent);
+		lines.push_front(firstLine);
+	}
 }
 
 // ----------------------------------------------------------------------------
 //! Free all structures, including Message.
 ObjectClassBroadcastList::~ObjectClassBroadcastList()
 {
-    this->clear();
+	this->clear();
 }
 
 // ----------------------------------------------------------------------------
@@ -190,17 +246,17 @@
 void
 ObjectClassBroadcastList::clear()
 {
-    delete message ;
-    message = 0 ;
+	delete msg;
+	msg = NULL ;
 
-    maxHandle = 0 ;
+	maxHandle = 0 ;
 
-    while (!lines.empty()) {
-        delete lines.front();
-        lines.pop_front();
-    }
+	while (!lines.empty()) {
+		delete lines.front();
+		lines.pop_front();
+	}
 
-    D.Out(pdTerm, "List is now empty.");
+	D.Out(pdTerm, "List is now empty.");
 }
 
 
@@ -208,13 +264,13 @@
 ObjectBroadcastLine*
 ObjectClassBroadcastList::getLineWithFederate(FederateHandle theFederate)
 {
-    list<ObjectBroadcastLine *>::iterator i ;
-    for (i = lines.begin(); i != lines.end(); i++) {
-        if ((*i)->Federate == theFederate)
-            return (*i);
-    }
+	list<ObjectBroadcastLine *>::iterator i ;
+	for (i = lines.begin(); i != lines.end(); i++) {
+		if ((*i)->Federate == theFederate)
+			return (*i);
+	}
 
-    return 0 ;
+	return 0 ;
 }
 
 // ----------------------------------------------------------------------------
@@ -224,13 +280,13 @@
 bool
 ObjectClassBroadcastList::isWaiting(ObjectBroadcastLine *line)
 {
-    for (unsigned int attrIndex = 1 ; attrIndex <= maxHandle ; attrIndex++) {
-        if (line->state[attrIndex] == ObjectBroadcastLine::waiting) {
-            return true ;
-        }
-    }
+	for (unsigned int attrIndex = 1 ; attrIndex <= maxHandle ; attrIndex++) {
+		if (line->state[attrIndex] == ObjectBroadcastLine::waiting) {
+			return true ;
+		}
+	}
 
-    return false ;
+	return false ;
 }
 
 
@@ -241,38 +297,38 @@
 void
 ObjectClassBroadcastList::sendPendingDOMessage(SecurityServer *server)
 {
-    Socket *socket = NULL ;
+	Socket *socket = NULL ;
 
-    // Pour chaque ligne de la liste
-    list<ObjectBroadcastLine *>::iterator i ;
-    for (i = lines.begin(); i != lines.end(); ++i) {
-        // Si le federe attend un message(attribute 0 en attente)
-        if ((*i)->state[0] == ObjectBroadcastLine::waiting) {
-
-            // 1. Envoyer le message au federe
-            D.Out(pdProtocol,
-                  "Broadcasting message to Federate %d.", (*i)->Federate);
-            try {
-                socket = server->getSocketLink((*i)->Federate);
-                // socket NULL means federate dead (killed ?)
-                if ( socket != NULL )
-                    message->send(socket,NM_msgBufSend);
-            }
-            catch (RTIinternalError &e) {
-                D.Out(pdExcept,
-                      "Reference to a killed Federate while broadcasting.");
-            }
-            catch (NetworkError &e) {
-                D.Out(pdExcept, "Network error while broadcasting, ignoring.");
-            }
-
-            // 2. Marquer le federe comme ayant recu le message.
-            (*i)->state[0] = ObjectBroadcastLine::sent ;
-        }
-        else
-            D.Out(pdProtocol, "No message sent to Federate %d.",
-                  (*i)->Federate);
-    }
+	// Pour chaque ligne de la liste
+	list<ObjectBroadcastLine *>::iterator i ;
+	for (i = lines.begin(); i != lines.end(); ++i) {
+		// Si le federe attend un message(attribute 0 en attente)
+		if ((*i)->state[0] == ObjectBroadcastLine::waiting) {
+
+			// 1. Envoyer le message au federe
+			D.Out(pdProtocol,
+					"Broadcasting message to Federate %d.", (*i)->Federate);
+			try {
+				socket = server->getSocketLink((*i)->Federate);
+				// socket NULL means federate dead (killed ?)
+				if ( socket != NULL )
+					msg->send(socket,NM_msgBufSend);
+			}
+			catch (RTIinternalError &e) {
+				D.Out(pdExcept,
+						"Reference to a killed Federate while broadcasting.");
+			}
+			catch (NetworkError &e) {
+				D.Out(pdExcept, "Network error while broadcasting, ignoring.");
+			}
+
+			// 2. Marquer le federe comme ayant recu le message.
+			(*i)->state[0] = ObjectBroadcastLine::sent ;
+		}
+		else
+			D.Out(pdProtocol, "No message sent to Federate %d.",
+					(*i)->Federate);
+	}
 }
 
 // ----------------------------------------------------------------------------
@@ -287,26 +343,26 @@
   and then all pending attributes(in the bsWainting state) are added
   to the copy. The copy is sent, and attributes are marked as
   ObjectBroadcastLine::sent.
-*/
+ */
 void ObjectClassBroadcastList::sendPendingMessage(SecurityServer *server)
 {
-    G.Out(pdGendoc,"enter ObjectClassBroadcastList::sendPendingMessage");
-    switch (message->getType()) {
+	G.Out(pdGendoc,"enter ObjectClassBroadcastList::sendPendingMessage");
+	switch (msg->getType()) {
 
-      case NetworkMessage::REFLECT_ATTRIBUTE_VALUES:
-      case NetworkMessage::REQUEST_ATTRIBUTE_OWNERSHIP_ASSUMPTION:
-        sendPendingRAVMessage(server);
-        break ;
-
-      case NetworkMessage::DISCOVER_OBJECT:
-      case NetworkMessage::REMOVE_OBJECT:
-        sendPendingDOMessage(server);
-        break ;
-
-      default:
-        throw RTIinternalError("Unknown message type to broadcast.");
-    G.Out(pdGendoc,"exit  ObjectClassBroadcastList::sendPendingMessage");
-    }
+	case NetworkMessage::REFLECT_ATTRIBUTE_VALUES:
+	case NetworkMessage::REQUEST_ATTRIBUTE_OWNERSHIP_ASSUMPTION:
+		sendPendingRAVMessage(server);
+		break ;
+
+	case NetworkMessage::DISCOVER_OBJECT:
+	case NetworkMessage::REMOVE_OBJECT:
+		sendPendingDOMessage(server);
+		break ;
+
+	default:
+		throw RTIinternalError("Unknown message type to broadcast.");
+		G.Out(pdGendoc,"exit  ObjectClassBroadcastList::sendPendingMessage");
+	}
 }
 
 // ---------------------------
@@ -316,87 +372,131 @@
 void
 ObjectClassBroadcastList::sendPendingRAVMessage(SecurityServer *server)
 {
-    Socket *socket = 0 ;
-    NetworkMessage *currentMessage = 0 ;
+	Socket         *socket         = NULL;
+	NetworkMessage *currentMessage = NULL;
+	uint32_t attributeSize   = 0;
+	std::vector<AttributeHandle>  vATH;
+
+	if (NULL!=msgRAV) {
+		attributeSize = msgRAV->getAttributesSize();
+		vATH = msgRAV->getAttributes();
+	}
+
+	if (NULL!=msgRAOA) {
+		attributeSize = msgRAOA->getAttributesSize();
+		vATH = msgRAOA->getAttributes();
+	}
+
+	G.Out(pdGendoc,"enter ObjectClassBroadcastList::sendPendingRAVMessage");
+	// For each line :
+	list<ObjectBroadcastLine *>::iterator i ;
+	for (i = lines.begin(); i != lines.end(); ++i) {
+
+		// Si AU MOINS UN des attributs est en ObjectBroadcastLine::waiting
+		if (isWaiting(*i)) {
+
+			// 1. Est-ce que tous les attributs du message sont en
+			// ObjectBroadcastLine::waiting ?
+			bool all_waiting = true ;
+			for (uint32_t attrIndex = 0 ; attrIndex < attributeSize ;	++attrIndex ) {
+				if ((*i)->state[vATH[attrIndex]] != ObjectBroadcastLine::waiting)
+					all_waiting = false ;
+			}
+
+			if (!all_waiting) {
+				// NO: Create a new message containing only ObjectBroadcastLine::waiting
+				// attributes.
+				if (NULL!=msgRAV) {
+					currentMessage = createReducedMessageWithValue(msgRAV,*i);
+				}
+				if (NULL!=msgRAOA) {
+					currentMessage = createReducedMessage(msgRAOA,*i);
+				}
+				D.Out(pdProtocol,
+						"Broadcasting reduced message to Federate %d.",
+						(*i)->Federate);
+			}
+			else {
+				// YES: Nothing to do.
+				currentMessage = msg ;
+				D.Out(pdProtocol,
+						"Broadcasting complete message to Federate %d.",
+						(*i)->Federate);
+			}
 
-    G.Out(pdGendoc,"enter ObjectClassBroadcastList::sendPendingRAVMessage");
-    // For each line :
-    list<ObjectBroadcastLine *>::iterator i ;
-    for (i = lines.begin(); i != lines.end(); i++) {
-
-        // Si AU MOINS UN des attributs est en ObjectBroadcastLine::waiting
-        if (isWaiting(*i)) {
-
-            // 1. Est-ce que tous les attributs du message sont en
-            // ObjectBroadcastLine::waiting ?
-            bool all_waiting = true ;
-            for (unsigned int attrIndex = 0 ;
-                 attrIndex < message->handleArraySize ;
-                 attrIndex ++) {
-                AttributeHandle attrib = message->handleArray[attrIndex] ;
-                if ((*i)->state[attrib] != ObjectBroadcastLine::waiting)
-                    all_waiting = false ;
-            }
-
-            if (!all_waiting) {
-                // NO: Create a new message containing only ObjectBroadcastLine::waiting
-                // attributes.
-                currentMessage = adaptMessage(*i);
-                D.Out(pdProtocol,
-                      "Broadcasting reduced message to Federate %d.",
-                      (*i)->Federate);
-            }
-            else {
-                // YES: Nothing to do.
-                currentMessage = message ;
-                D.Out(pdProtocol,
-                      "Broadcasting complete message to Federate %d.",
-                      (*i)->Federate);
-            }
-
-            // 2. Send message (or reduced one).
-            try {
+			// 2. Send message (or reduced one).
+			try {
 #ifdef HLA_USES_UDP
-                socket = server->getSocketLink((*i)->Federate, BEST_EFFORT);
+				socket = server->getSocketLink((*i)->Federate, BEST_EFFORT);
 #else
-                socket = server->getSocketLink((*i)->Federate);
+				socket = server->getSocketLink((*i)->Federate);
 #endif
-                // socket NULL means federate is dead (killed ?)
-                if ( socket != NULL )
-                   {
-                   G.Out(pdGendoc,"                                 sendPendingRAVMessage=====> write");
-                   currentMessage->send(socket,NM_msgBufSend);
-                   }
-            }
-            catch (RTIinternalError &e) {
-                D.Out(pdExcept,
-                      "Reference to a killed Federate while broadcasting.");
-            }
-            catch (NetworkError &e) {
-                D.Out(pdExcept, "Network error while broadcasting, ignoring.");
-            }
-
-            // 3. marquer les attributs en ObjectBroadcastLine::sent.
-            for (unsigned int attrIndex = 1 ;
-                 attrIndex <= maxHandle ;
-                 attrIndex ++) {
-                if ((*i)->state[attrIndex] == ObjectBroadcastLine::waiting) {
-                    (*i)->state[attrIndex] = ObjectBroadcastLine::sent ;
-                }
-            }
-
-            // 4. Eventuellement effacer la copie du message.
-            if (currentMessage != message) {
-                delete currentMessage ;
-                currentMessage = NULL ;
-            }
-
-        } // Si AU MOINS UN des attributs est en ObjectBroadcastLine::waiting
-        else
-            D.Out(pdProtocol, "No message sent to Federate %d.",
-                  (*i)->Federate);
-    G.Out(pdGendoc,"exit  ObjectClassBroadcastList::sendPendingRAVMessage");
-    }
+				// socket NULL means federate is dead (killed ?)
+				if ( socket != NULL )
+				{
+					G.Out(pdGendoc,"                                 sendPendingRAVMessage=====> write");
+					currentMessage->send(socket,NM_msgBufSend);
+				}
+			}
+			catch (RTIinternalError &e) {
+				D.Out(pdExcept,
+						"Reference to a killed Federate while broadcasting.");
+			}
+			catch (NetworkError &e) {
+				D.Out(pdExcept, "Network error while broadcasting, ignoring.");
+			}
+
+			// 3. marquer les attributs en ObjectBroadcastLine::sent.
+			for (unsigned int attrIndex = 1 ;
+					attrIndex <= maxHandle ;
+					attrIndex ++) {
+				if ((*i)->state[attrIndex] == ObjectBroadcastLine::waiting) {
+					(*i)->state[attrIndex] = ObjectBroadcastLine::sent ;
+				}
+			}
+
+			// 4. Eventuellement effacer la copie du message.
+			if (currentMessage != msg) {
+				delete currentMessage ;
+				currentMessage = NULL ;
+			}
+
+		} // Si AU MOINS UN des attributs est en ObjectBroadcastLine::waiting
+		else
+			D.Out(pdProtocol, "No message sent to Federate %d.",
+					(*i)->Federate);
+		G.Out(pdGendoc,"exit  ObjectClassBroadcastList::sendPendingRAVMessage");
+	}
+}
+
+void
+ObjectClassBroadcastList::upcastTo(ObjectClassHandle objectClass) {
+	/* Initialize specific pointer
+	 * FIXME : this is ugly and will be reworked
+	 * */
+	switch(msg->getType()) {
+	case NetworkMessage::REMOVE_OBJECT:
+		msgRO->setObjectClass(objectClass);
+		break;
+	case NetworkMessage::DISCOVER_OBJECT:
+		msgDO->setObjectClass(objectClass);
+		break;
+	case NetworkMessage::REFLECT_ATTRIBUTE_VALUES:
+		// FIXME nothing TODO RAV does not embed object class?
+		//msgRAV->setObjectClass(objectClass);
+		break;
+	case NetworkMessage::REQUEST_ATTRIBUTE_OWNERSHIP_ASSUMPTION:
+		// FIXME nothing TODO RAV does not embed object class?
+		//msgRAOA->setObjectClass(objectClass);
+		break;
+	case NetworkMessage::ATTRIBUTE_OWNERSHIP_DIVESTITURE_NOTIFICATION:
+		// FIXME nothing TODO RAV does not embed object class?
+		//msgAODN->setObjectClass(objectClass);
+		break;
+	default:
+		throw RTIinternalError("Unexpected type of message");
+		break;
+	}
 }
 
 } // namespace certi
Index: libCERTI/ObjectSet.hh
===================================================================
RCS file: /sources/certi/certi/libCERTI/ObjectSet.hh,v
retrieving revision 3.16
diff -u -r3.16 ObjectSet.hh
--- libCERTI/ObjectSet.hh	7 Mar 2010 21:30:30 -0000	3.16
+++ libCERTI/ObjectSet.hh	18 Mar 2010 18:31:12 -0000
@@ -138,7 +138,7 @@
     void
     cancelNegotiatedAttributeOwnershipDivestiture(FederateHandle the_federate,
                                                   ObjectHandle the_object,
-                                                  std::vector <AttributeHandle> &,
+                                                  const std::vector <AttributeHandle> &,
                                                   uint16_t the_size)
         throw (ObjectNotKnown, AttributeNotDefined, AttributeNotOwned,
                AttributeDivestitureWasNotRequested, RTIinternalError);
Index: libCERTI/InteractionSet.hh
===================================================================
RCS file: /sources/certi/certi/libCERTI/InteractionSet.hh,v
retrieving revision 3.27
diff -u -r3.27 InteractionSet.hh
--- libCERTI/InteractionSet.hh	7 Mar 2010 21:30:30 -0000	3.27
+++ libCERTI/InteractionSet.hh	18 Mar 2010 18:31:09 -0000
@@ -125,8 +125,8 @@
 
 	void broadcastInteraction(FederateHandle theFederateHandle,
 			InteractionClassHandle theInteractionHandle,
-			std::vector <ParameterHandle> &theParameterList,
-			std::vector <ParameterValue_t> &theValueList,
+			const std::vector <ParameterHandle> &theParameterList,
+			const std::vector <ParameterValue_t> &theValueList,
 			uint16_t theListSize,
 			FederationTime theTime,
 			const RTIRegion *,
@@ -138,8 +138,8 @@
 
 	void broadcastInteraction(FederateHandle theFederateHandle,
 			InteractionClassHandle theInteractionHandle,
-			std::vector <ParameterHandle> &theParameterList,
-			std::vector <ParameterValue_t> &theValueList,
+			const std::vector <ParameterHandle> &theParameterList,
+			const std::vector <ParameterValue_t> &theValueList,
 			uint16_t theListSize,
 			const RTIRegion *,
 			const std::string& theTag)
Index: libCERTI/GAV.cc
===================================================================
RCS file: /sources/certi/certi/libCERTI/GAV.cc,v
retrieving revision 3.22
diff -u -r3.22 GAV.cc
--- libCERTI/GAV.cc	7 Mar 2010 21:30:30 -0000	3.22
+++ libCERTI/GAV.cc	18 Mar 2010 18:31:09 -0000
@@ -281,7 +281,7 @@
     if (isMember(h) == true)
         _set.remove(h);
     else
-        throw AttributeNotDefined("");
+        throw AttributeNotDefined(stringize() << "AttributeHandleSet::remove(AttributeHandle) Attribute <"<<h <<"> not member of the set");
 }
 
 // ----------------------------------------------------------------------------
@@ -351,7 +351,7 @@
     if (isMember(h) == true)
         _set.remove(h);
     else
-        throw AttributeNotDefined("");
+        throw AttributeNotDefined(stringize() << "FederateHandleSet::remove(FederateHandle) Federate <"<<h <<"> not member of the set");
 }
 
 // ----------------------------------------------------------------------------
Index: libCERTI/NM_Classes.cc
===================================================================
RCS file: /sources/certi/certi/libCERTI/NM_Classes.cc,v
retrieving revision 3.21
diff -u -r3.21 NM_Classes.cc
--- libCERTI/NM_Classes.cc	24 Nov 2009 19:11:37 -0000	3.21
+++ libCERTI/NM_Classes.cc	18 Mar 2010 18:31:09 -0000
@@ -1,11 +1,15 @@
+// Generated on 2010 March Thu, 18 at 17:48:39 by the CERTI message generator
+#include <vector>
+#include <string>
+#include "NM_Classes.hh"
 // ----------------------------------------------------------------------------
 // CERTI - HLA RunTime Infrastructure
-// Copyright (C) 2002-2005  ONERA
+// Copyright (C) 2002-2008  ONERA
 //
 // This program is free software ; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public License
 // as published by the Free Software Foundation ; either version 2 of
-// the License, or (at your option) any later version.
+// the License, or (at your option) Any later version.
 //
 // This program is distributed in the hope that it will be useful, but
 // WITHOUT ANY WARRANTY ; without even the implied warranty of
@@ -14,1905 +18,2904 @@
 //
 // You should have received a copy of the GNU Lesser General Public
 // License along with this program ; if not, write to the Free Software
-// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
+// USA
 //
 // ----------------------------------------------------------------------------
-
-#include "NM_Classes.hh"
-#include <assert.h>
+// CERTI Network Messages description
+// ----------------------------------------------------------------------------
+// The messages related classes will be placed in the certi package
 namespace certi {
 
-NetworkMessage* NM_Factory::create(NetworkMessage::Message_T type) throw (RTIinternalError) {
-	NetworkMessage* msg;
-
-	switch (type) {
-	case NetworkMessage::NOT_USED:
-		throw RTIinternalError("NOT_USED message type should not be used!!");
-		msg = new NM_Not_Used(); 
-		break;
-	case NetworkMessage::CLOSE_CONNEXION:
-		msg = new NM_Close_Connexion(); 
-		break;
-	case NetworkMessage::MESSAGE_NULL:
-		msg = new NM_Message_Null(); 
-		break;
-	case NetworkMessage::CREATE_FEDERATION_EXECUTION:
-		msg = new NM_Create_Federation_Execution(); 
-		break;
-	case NetworkMessage::DESTROY_FEDERATION_EXECUTION:
-		msg = new NM_Destroy_Federation_Execution(); 
-		break;
-	case NetworkMessage::JOIN_FEDERATION_EXECUTION:
-		msg = new NM_Join_Federation_Execution(); 
-		break;
-	case NetworkMessage::RESIGN_FEDERATION_EXECUTION:
-		msg = new NM_Resign_Federation_Execution(); 
-		break;
-	case NetworkMessage::SET_TIME_REGULATING:
-		msg = new NM_Set_Time_Regulating(); 
-		break;
-	case NetworkMessage::SET_TIME_CONSTRAINED:
-		msg = new NM_Set_Time_Constrained(); 
-		break;
-	case NetworkMessage::TIME_REGULATION_ENABLED:
-		msg = new NM_Time_Regulation_Enabled(); 
-		break;
-	case NetworkMessage::TIME_CONSTRAINED_ENABLED:
-		msg = new NM_Time_Constrained_Enabled(); 
-		break;
-	case NetworkMessage::REGISTER_FEDERATION_SYNCHRONIZATION_POINT:
-		msg = new NM_Register_Federation_Synchronization_Point(); 
-		break;
-	case NetworkMessage::SYNCHRONIZATION_POINT_REGISTRATION_SUCCEEDED:
-		msg = new NM_Synchronization_Point_Registration_Succeeded(); 
-		break;
-	case NetworkMessage::ANNOUNCE_SYNCHRONIZATION_POINT:
-		msg = new NM_Announce_Synchronization_Point(); 
-		break;
-	case NetworkMessage::SYNCHRONIZATION_POINT_ACHIEVED:
-		msg = new NM_Synchronization_Point_Achieved(); 
-		break;
-	case NetworkMessage::FEDERATION_SYNCHRONIZED:
-		msg = new NM_Federation_Synchronized(); 
-		break;
-	case NetworkMessage::REQUEST_FEDERATION_SAVE:
-		msg = new NM_Request_Federation_Save(); 
-		break;
-	case NetworkMessage::FEDERATE_SAVE_BEGUN:
-		msg = new NM_Federate_Save_Begun(); 
-		break;
-	case NetworkMessage::FEDERATE_SAVE_COMPLETE:
-		msg = new NM_Federate_Save_Complete(); 
-		break;
-	case NetworkMessage::FEDERATE_SAVE_NOT_COMPLETE:
-		msg = new NM_Federate_Save_Not_Complete(); 
-		break;
-	case NetworkMessage::INITIATE_FEDERATE_SAVE:
-		msg = new NM_Initiate_Federate_Save(); 
-		break;
-	case NetworkMessage::FEDERATION_SAVED:
-		msg = new NM_Federation_Saved(); 
-		break;
-	case NetworkMessage::FEDERATION_NOT_SAVED:
-		msg = new NM_Federation_Not_Saved(); 
-		break;
-	case NetworkMessage::REQUEST_FEDERATION_RESTORE:
-		msg = new NM_Request_Federation_Restore(); 
-		break;
-	case NetworkMessage::FEDERATE_RESTORE_COMPLETE:
-		msg = new NM_Federate_Restore_Complete(); 
-		break;
-	case NetworkMessage::FEDERATE_RESTORE_NOT_COMPLETE:
-		msg = new NM_Federate_Restore_Not_Complete(); 
-		break;
-	case NetworkMessage::REQUEST_FEDERATION_RESTORE_SUCCEEDED:
-		msg = new NM_Request_Federation_Restore_Succeeded(); 
-		break;
-	case NetworkMessage::REQUEST_FEDERATION_RESTORE_FAILED:
-		msg = new NM_Request_Federation_Restore_Failed(); 
-		break;
-	case NetworkMessage::FEDERATION_RESTORE_BEGUN:
-		msg = new NM_Federation_Restore_Begun(); 
-		break;
-	case NetworkMessage::INITIATE_FEDERATE_RESTORE:
-		msg = new NM_Initiate_Federate_Restore(); 
-		break;
-	case NetworkMessage::FEDERATION_RESTORED:
-		msg = new NM_Federation_Restored(); 
-		break;
-	case NetworkMessage::FEDERATION_NOT_RESTORED:
-		msg = new NM_Federation_Not_Restored(); 
-		break;
-	case NetworkMessage::PUBLISH_OBJECT_CLASS:
-		msg = new NM_Publish_Object_Class(); 
-		break;
-	case NetworkMessage::UNPUBLISH_OBJECT_CLASS:
-		msg = new NM_Unpublish_Object_Class(); 
-		break;
-	case NetworkMessage::PUBLISH_INTERACTION_CLASS:
-		msg = new NM_Publish_Interaction_Class(); 
-		break;
-	case NetworkMessage::UNPUBLISH_INTERACTION_CLASS:
-		msg = new NM_Unpublish_Interaction_Class(); 
-		break;
-	case NetworkMessage::SUBSCRIBE_OBJECT_CLASS:
-		msg = new NM_Subscribe_Object_Class(); 
-		break;
-	case NetworkMessage::UNSUBSCRIBE_OBJECT_CLASS:
-		msg = new NM_Unsubscribe_Object_Class(); 
-		break;
-	case NetworkMessage::SUBSCRIBE_INTERACTION_CLASS:
-		msg = new NM_Subscribe_Interaction_Class(); 
-		break;
-	case NetworkMessage::UNSUBSCRIBE_INTERACTION_CLASS:
-		msg = new NM_Unsubscribe_Interaction_Class(); 
-		break;
-	case NetworkMessage::SET_CLASS_RELEVANCE_ADVISORY_SWITCH:
-	        msg = new NM_Set_Class_Relevance_Advisory_Switch();
-		break;
-	case NetworkMessage::SET_INTERACTION_RELEVANCE_ADVISORY_SWITCH:
-	        msg = new NM_Set_Interaction_Relevance_Advisory_Switch();
-		break;
-	case NetworkMessage::SET_ATTRIBUTE_RELEVANCE_ADVISORY_SWITCH:
-	        msg = new NM_Set_Attribute_Relevance_Advisory_Switch();
-		break;
-	case NetworkMessage::SET_ATTRIBUTE_SCOPE_ADVISORY_SWITCH:
-	        msg = new NM_Set_Attribute_Scope_Advisory_Switch();
-		break;
-	case NetworkMessage::START_REGISTRATION_FOR_OBJECT_CLASS:
-	        msg = new NM_Start_Registration_For_Object_Class();
-		break;
-	case NetworkMessage::STOP_REGISTRATION_FOR_OBJECT_CLASS:
-	        msg = new NM_Stop_Registration_For_Object_Class();
-		break;
-	case NetworkMessage::TURN_INTERACTIONS_ON:
-		msg = new NM_Turn_Interactions_On(); 
-		break;
-	case NetworkMessage::TURN_INTERACTIONS_OFF:
-		msg = new NM_Turn_Interactions_Off(); 
-		break;
-	case NetworkMessage::REGISTER_OBJECT:
-		msg = new NM_Register_Object(); 
-		break;
-	case NetworkMessage::DISCOVER_OBJECT:
-		msg = new NM_Discover_Object(); 
-		break;
-	case NetworkMessage::UPDATE_ATTRIBUTE_VALUES:
-		msg = new NM_Update_Attribute_Values(); 
-		break;
-	case NetworkMessage::REFLECT_ATTRIBUTE_VALUES:
-		msg = new NM_Reflect_Attribute_Values(); 
-		break;
-	case NetworkMessage::SEND_INTERACTION:
-		msg = new NM_Send_Interaction(); 
-		break;
-	case NetworkMessage::RECEIVE_INTERACTION:
-		msg = new NM_Receive_Interaction(); 
-		break;
-	case NetworkMessage::DELETE_OBJECT:
-		msg = new NM_Delete_Object(); 
-		break;
-	case NetworkMessage::REMOVE_OBJECT:
-		msg = new NM_Remove_Object(); 
-		break;
-	case NetworkMessage::CHANGE_ATTRIBUTE_TRANSPORT_TYPE:
-		throw RTIinternalError("CHANGE_ATTRIBUTE_TRANSPORT_TYPE: Unimplemented");
-		msg = new NM_Change_Attribute_Transport_Type(); 
-		break;
-	case NetworkMessage::CHANGE_ATTRIBUTE_ORDER_TYPE:
-		throw RTIinternalError("CHANGE_ATTRIBUTE_ORDER_TYPE: Unimplemented");
-		msg = new NM_Change_Attribute_Order_Type(); 
-		break;	   
-	case NetworkMessage::CHANGE_INTERACTION_TRANSPORT_TYPE:
-		throw RTIinternalError("CHANGE_INTERACTION_TRANSPORT_TYPE: Unimplemented");
-		msg = new NM_Change_Interaction_Transport_Type(); 
-		break;	   
-	case NetworkMessage::CHANGE_INTERACTION_ORDER_TYPE:
-		throw RTIinternalError("CHANGE_INTERACTION_ORDER_TYPE: Unimplemented");
-		msg = new NM_Change_Interaction_Order_Type(); 
-		break;
-	case NetworkMessage::REQUEST_CLASS_ATTRIBUTE_VALUE_UPDATE:
-		msg = new NM_Request_Class_Attribute_Value_Update(); 
-		break;
-	case NetworkMessage::REQUEST_OBJECT_ATTRIBUTE_VALUE_UPDATE:
-		msg = new NM_Request_Object_Attribute_Value_Update(); 
-		break;
-	case NetworkMessage::IS_ATTRIBUTE_OWNED_BY_FEDERATE:
-		msg = new NM_Is_Attribute_Owned_By_Federate(); 
-		break;
-	case NetworkMessage::QUERY_ATTRIBUTE_OWNERSHIP:
-		msg = new NM_Query_Attribute_Ownership(); 
-		break;
-	case NetworkMessage::ATTRIBUTE_IS_NOT_OWNED:
-		msg = new NM_Attribute_Is_Not_Owned(); 
-		break;
-	case NetworkMessage::INFORM_ATTRIBUTE_OWNERSHIP:
-		msg = new NM_Inform_Attribute_Ownership(); 
-		break;
-	case NetworkMessage::NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE:
-		msg = new NM_Negotiated_Attribute_Ownership_Divestiture(); 
-		break;
-	case NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION_NOTIFICATION:
-		msg = new NM_Attribute_Ownership_Acquisition_Notification(); 
-		break;
-	case NetworkMessage::ATTRIBUTE_OWNERSHIP_DIVESTITURE_NOTIFICATION:
-		msg = new NM_Attribute_Ownership_Divestiture_Notification(); 
-		break;
-	case NetworkMessage::REQUEST_ATTRIBUTE_OWNERSHIP_ASSUMPTION:
-		msg = new NM_Request_Attribute_Ownership_Assumption(); 
-		break;
-	case NetworkMessage::ATTRIBUTE_OWNERSHIP_UNAVAILABLE:
-		msg = new NM_Attribute_Ownership_Unavailable(); 
-		break;
-	case NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION_IF_AVAILABLE:
-		msg = new NM_Attribute_Ownership_Acquisition_If_Available(); 
-		break;
-	case NetworkMessage::UNCONDITIONAL_ATTRIBUTE_OWNERSHIP_DIVESTITURE:
-		msg = new NM_Unconditional_Attribute_Ownership_Divestiture(); 
-		break;
-	case NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION:
-		msg = new NM_Attribute_Ownership_Acquisition(); 
-		break;
-	case NetworkMessage::REQUEST_ATTRIBUTE_OWNERSHIP_RELEASE:
-		msg = new NM_Request_Attribute_Ownership_Release(); 
-		break;
-	case NetworkMessage::CANCEL_NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE:
-		msg = new NM_Cancel_Negotiated_Attribute_Ownership_Divestiture(); 
-		break;
-	case NetworkMessage::ATTRIBUTE_OWNERSHIP_RELEASE_RESPONSE:
-		msg = new NM_Attribute_Ownership_Release_Response(); 
-		break;
-	case NetworkMessage::CANCEL_ATTRIBUTE_OWNERSHIP_ACQUISITION:
-		msg = new NM_Cancel_Attribute_Ownership_Acquisition(); 
-		break;
-	case NetworkMessage::CONFIRM_ATTRIBUTE_OWNERSHIP_ACQUISITION_CANCELLATION:
-		msg = new NM_Confirm_Attribute_Ownership_Acquisition_Cancellation(); 
-		break;
-	case NetworkMessage::DDM_CREATE_REGION:
-		msg = new NM_DDM_Create_Region(); 
-		break;
-	case NetworkMessage::DDM_MODIFY_REGION:
-		msg = new NM_DDM_Modify_Region(); 
-		break;
-	case NetworkMessage::DDM_DELETE_REGION:
-		msg = new NM_DDM_Delete_Region(); 
-		break;
-	case NetworkMessage::DDM_ASSOCIATE_REGION:
-		msg = new NM_DDM_Associate_Region(); 
-		break;
-	case NetworkMessage::DDM_REGISTER_OBJECT:
-		msg = new NM_DDM_Register_Object(); 
-		break;
-	case NetworkMessage::DDM_UNASSOCIATE_REGION:
-		msg = new NM_DDM_Unassociate_Region(); 
-		break;
-	case NetworkMessage::DDM_SUBSCRIBE_ATTRIBUTES:
-		msg = new NM_DDM_Subscribe_Attributes(); 
-		break;
-	case NetworkMessage::DDM_UNSUBSCRIBE_ATTRIBUTES:
-		msg = new NM_DDM_Unsubscribe_Attributes(); 
-		break;
-	case NetworkMessage::DDM_SUBSCRIBE_INTERACTION:
-		msg = new NM_DDM_Subscribe_Interaction(); 
-		break;
-	case NetworkMessage::DDM_UNSUBSCRIBE_INTERACTION:
-		msg = new NM_DDM_Unsubscribe_Interaction(); 
-		break;
-	case NetworkMessage::PROVIDE_ATTRIBUTE_VALUE_UPDATE:
-		msg = new NM_Provide_Attribute_Value_Update(); 
-		break;
-	case NetworkMessage::LAST:
-		throw RTIinternalError("LAST message type should not be used!!");
-		msg = new NM_Last(); 
-		break;
-	default:
-		throw RTIinternalError("Unknown/Unimplemented message Type");
-	}
-	
-	return msg;
-} /* end of NM_Factory::create */
-
-NetworkMessage* 
-NM_Factory::receive(Socket* socket) throw (NetworkError, RTIinternalError) {
-	// FIXME this is not thread-safe.
-	static MessageBuffer msgBuffer;
-	NetworkMessage  msgGen;
-	NetworkMessage* msg;
-	
-	/* receive generic message */
-	msgGen.receive(socket,msgBuffer);
-	/* create specific message from type */
-	msg = NM_Factory::create(msgGen.getType());
-	msgBuffer.assumeSizeFromReservedBytes();	
-	msg->deserialize(msgBuffer);
-	return msg;	
-} /* end of NM_Factory::receive */
-
-NM_WithHandleArray::NM_WithHandleArray() {
-	this->name = "NM_WithHandleArray";
-	this->type = NOT_USED;
-	/* specific field init */
-	this->handleArraySize = 0;
-}
-
-NM_WithHandleArray::~NM_WithHandleArray() {
-}
-
-void NM_WithHandleArray::serialize(MessageBuffer& msgBuffer) {
-	int i;
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */	
-	msgBuffer.write_uint16(handleArraySize);
-	/* 
-	 * Note that if handleArraySize is 0 
-	 * the loop is void which is done on purpose.
-	 * (this is a feature not a bug :-) 
-	 */		
-	for (i = 0 ; i < handleArraySize ; ++i) {
-		msgBuffer.write_uint16(handleArray[i]);
-	}
-
-} /* end of serialize */ 
-void NM_WithHandleArray::deserialize(MessageBuffer& msgBuffer) {
-	int i;
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */	
-	handleArraySize = msgBuffer.read_int16();
-	/* 
-	 * Note that if handleArraySize is 0 
-	 * the loop is void which is done on purpose.
-	 * (this is a feature not a bug :-) 
-	 */
-        handleArray.resize(handleArraySize);	
-	for (i = 0 ; i < handleArraySize ; i ++) {
-		handleArray[i] = msgBuffer.read_int16();
-	}
-} /* end of deserialize */
-
-NM_DDM_Base::NM_DDM_Base() {
-	this->name = "NM_DDM_Base";
-	this->type = NetworkMessage::NOT_USED;
-	/* specific field init */
-	this->space       = 0;
-	this->nbExtents   = 0;
-	this->region      = 0;
-	this->object      = 0;
-	this->objectClass = 0;
-	this->DDM_bool    = false; /* FIXME don't know the purpose of this */
-}
-
-NM_DDM_Base::~NM_DDM_Base() {
-}
-
-/*<BEGIN>---------- Not_Used ------------<BEGIN>*/
-NM_Not_Used::NM_Not_Used() {
-	this->name = "NOT_USED";
-	this->type = NetworkMessage::NOT_USED;
-	/* specific field init */
-}
-NM_Not_Used::~NM_Not_Used() {
-}
-/*<END>---------- Not_Used ------------<END>*/
-
-/*<BEGIN>---------- Close_Connexion ------------<BEGIN>*/
-NM_Close_Connexion::NM_Close_Connexion() {
-	this->name = "CLOSE_CONNEXION";
-	this->type = NetworkMessage::CLOSE_CONNEXION;
-	/* specific field init */
-}
-NM_Close_Connexion::~NM_Close_Connexion() {
-}
-/*<END>---------- Close_Connexion ------------<END>*/
-
-/*<BEGIN>---------- Message_Null ------------<BEGIN>*/
-NM_Message_Null::NM_Message_Null() {
-	this->name = "MESSAGE_NULL";
-	this->type = MESSAGE_NULL;
-	/* specific field init */	
-}
-NM_Message_Null::~NM_Message_Null() {	
-}
-/*<END>---------- Message_Null ------------<END>*/
-
-/*<BEGIN>---------- FOM_Dimension ------------<BEGIN>*/
-void NM_FOM_Dimension::serialize(MessageBuffer& msgBuffer) {
-	msgBuffer.write_uint32(_handle);
-	msgBuffer.write_string(_name);
-}
-void NM_FOM_Dimension::deserialize(MessageBuffer& msgBuffer) {
-	_handle = msgBuffer.read_uint32();
-	msgBuffer.read_string(_name);
-}
-/*<END>---------- FOM_Dimension ------------<END>*/
-
-/*<BEGIN>---------- FOM_Routing_Space ------------<BEGIN>*/
-void NM_FOM_Routing_Space::serialize(MessageBuffer& msgBuffer) {
-	msgBuffer.write_uint32(_handle);
-	msgBuffer.write_string(_name);
-        uint32_t size = _dimensions.size();
-	msgBuffer.write_uint32(size);
-        for (uint32_t i = 0; i < size; ++i)
-          _dimensions[i].serialize(msgBuffer);
-} /* end of serialize */ 
-void NM_FOM_Routing_Space::deserialize(MessageBuffer& msgBuffer) {
-	_handle = msgBuffer.read_uint32();
-	msgBuffer.read_string(_name);
-	uint32_t size = msgBuffer.read_uint32();
-        _dimensions.resize(size);
-        for (uint32_t i = 0; i < size; ++i)
-          _dimensions[i].deserialize(msgBuffer);
-} /* end of deserialize */
-/*<END>---------- FOM_Routing_Space ------------<END>*/
-
-/*<BEGIN>---------- FOM_Attribute ------------<BEGIN>*/
-void NM_FOM_Attribute::serialize(MessageBuffer& msgBuffer) {
-	msgBuffer.write_uint32(_handle);
-	msgBuffer.write_string(_name);
-	msgBuffer.write_uint32(_spaceHandle);
-	msgBuffer.write_uint8(_order);
-	msgBuffer.write_uint8(_transport);
-}
-void NM_FOM_Attribute::deserialize(MessageBuffer& msgBuffer) {
-	_handle = msgBuffer.read_uint32();
-	msgBuffer.read_string(_name);
-        _spaceHandle = msgBuffer.read_uint32();
-	_order = msgBuffer.read_uint8();
-	_transport = msgBuffer.read_uint8();
-}
-/*<END>---------- FOM_Attribute ------------<END>*/
-
-/*<BEGIN>---------- FOM_Object_Class ------------<BEGIN>*/
-void NM_FOM_Object_Class::serialize(MessageBuffer& msgBuffer) {
-	msgBuffer.write_uint32(_handle);
-	msgBuffer.write_string(_name);
-	msgBuffer.write_uint32(_superclassHandle);
-        uint32_t size = _attributes.size();
-	msgBuffer.write_uint32(size);
-        for (uint32_t i = 0; i < size; ++i)
-          _attributes[i].serialize(msgBuffer);
-} /* end of serialize */ 
-void NM_FOM_Object_Class::deserialize(MessageBuffer& msgBuffer) {
-	_handle = msgBuffer.read_uint32();
-	msgBuffer.read_string(_name);
-        _superclassHandle = msgBuffer.read_uint32();
-	uint32_t size = msgBuffer.read_uint32();
-        _attributes.resize(size);
-        for (uint32_t i = 0; i < size; ++i)
-          _attributes[i].deserialize(msgBuffer);
-} /* end of deserialize */
-/*<END>---------- FOM_Object_Class ------------<END>*/
-
-/*<BEGIN>---------- FOM_FOM_Parameter ------------<BEGIN>*/
-void NM_FOM_Parameter::serialize(MessageBuffer& msgBuffer) {
-	msgBuffer.write_uint32(_handle);
-	msgBuffer.write_string(_name);
-}
-void NM_FOM_Parameter::deserialize(MessageBuffer& msgBuffer) {
-	_handle = msgBuffer.read_uint32();
-	msgBuffer.read_string(_name);
-}
-/*<END>---------- FOM_FOM_Parameter ------------<END>*/
-
-/*<BEGIN>---------- FOM_Interaction_Class ------------<BEGIN>*/
-void NM_FOM_Interaction_Class::serialize(MessageBuffer& msgBuffer) {
-	msgBuffer.write_uint32(_handle);
-	msgBuffer.write_string(_name);
-	msgBuffer.write_uint32(_superclassHandle);
-	msgBuffer.write_uint32(_spaceHandle);
-	msgBuffer.write_uint8(_order);
-	msgBuffer.write_uint8(_transport);
-        uint32_t size = _parameters.size();
-	msgBuffer.write_uint32(size);
-        for (uint32_t i = 0; i < size; ++i)
-          _parameters[i].serialize(msgBuffer);
-} /* end of serialize */ 
-void NM_FOM_Interaction_Class::deserialize(MessageBuffer& msgBuffer) {
-	_handle = msgBuffer.read_uint32();
-	msgBuffer.read_string(_name);
-        _superclassHandle = msgBuffer.read_uint32();
-        _spaceHandle = msgBuffer.read_uint32();
-	_order = msgBuffer.read_uint8();
-	_transport = msgBuffer.read_uint8();
-	uint32_t size = msgBuffer.read_uint32();
-        _parameters.resize(size);
-        for (uint32_t i = 0; i < size; ++i)
-          _parameters[i].deserialize(msgBuffer);
-} /* end of deserialize */
-/*<END>---------- FOM_Interaction_Class ------------<END>*/
-
-/*<BEGIN>---------- Create_Federation_Execution ------------<BEGIN>*/
-NM_Create_Federation_Execution::NM_Create_Federation_Execution() {
-	this->name = "CREATE_FEDERATION_EXECUTION";
-	this->type = NetworkMessage::CREATE_FEDERATION_EXECUTION;
-	/* specific field init */
-}
-NM_Create_Federation_Execution::~NM_Create_Federation_Execution() {	
-}
-void NM_Create_Federation_Execution::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	msgBuffer.write_string(federationName);
-	msgBuffer.write_string(FEDid);
-} /* end of serialize */ 
-void NM_Create_Federation_Execution::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	msgBuffer.read_string(federationName);
-	msgBuffer.read_string(FEDid);
-} /* end of deserialize */
-/*<END>---------- Create_Federation_Execution ------------<END>*/
-
-/*<BEGIN>---------- Destroy_Federation_Execution ------------<BEGIN>*/
-NM_Destroy_Federation_Execution::NM_Destroy_Federation_Execution() {
-	this->name = "DESTROY_FEDERATION_EXECUTION";
-	this->type = NetworkMessage::DESTROY_FEDERATION_EXECUTION;    
-	/* specific field init */    
-}
-NM_Destroy_Federation_Execution::~NM_Destroy_Federation_Execution() {
-}
-void NM_Destroy_Federation_Execution::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	msgBuffer.write_string(federationName);
-} /* end of serialize */ 
-void NM_Destroy_Federation_Execution::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	msgBuffer.read_string(federationName);
-} /* end of deserialize */
-/*<END>---------- Destroy_Federation_Execution ------------<END>*/
-
-/*<BEGIN>---------- Join_Federation_Execution ------------<BEGIN>*/
-NM_Join_Federation_Execution::NM_Join_Federation_Execution() {
-	this->name = "JOIN_FEDERATION_EXECUTION";
-	this->type = NetworkMessage::JOIN_FEDERATION_EXECUTION;
-	/* specific field init */
-}
-NM_Join_Federation_Execution::~NM_Join_Federation_Execution() {
-}
-void NM_Join_Federation_Execution::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	msgBuffer.write_int32(numberOfRegulators);
-	msgBuffer.write_uint32(multicastAddress);
-	msgBuffer.write_uint32(bestEffortAddress);
-	msgBuffer.write_uint32(bestEffortPeer);
-	msgBuffer.write_string(federationName);
-	msgBuffer.write_string(federateName);
-        uint32_t size = _routingSpaces.size();
-	msgBuffer.write_uint32(size);
-        for (uint32_t i = 0; i < size; ++i)
-          _routingSpaces[i].serialize(msgBuffer);
-        size = _objectClasses.size();
-	msgBuffer.write_uint32(size);
-        for (uint32_t i = 0; i < size; ++i)
-          _objectClasses[i].serialize(msgBuffer);
-        size = _interactionClasses.size();
-	msgBuffer.write_uint32(size);
-        for (uint32_t i = 0; i < size; ++i)
-          _interactionClasses[i].serialize(msgBuffer);
-} /* end of serialize */ 
-void NM_Join_Federation_Execution::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	numberOfRegulators = msgBuffer.read_int32();
-	multicastAddress   = msgBuffer.read_uint32();
-	bestEffortAddress  = msgBuffer.read_uint32();
-	bestEffortPeer     = msgBuffer.read_uint32();
-	msgBuffer.read_string(federationName);
-	msgBuffer.read_string(federateName);
-	uint32_t size = msgBuffer.read_uint32();
-        _routingSpaces.resize(size);
-        for (uint32_t i = 0; i < size; ++i)
-          _routingSpaces[i].deserialize(msgBuffer);
-	size = msgBuffer.read_uint32();
-        _objectClasses.resize(size);
-        for (uint32_t i = 0; i < size; ++i)
-          _objectClasses[i].deserialize(msgBuffer);
-	size = msgBuffer.read_uint32();
-        _interactionClasses.resize(size);
-        for (uint32_t i = 0; i < size; ++i)
-          _interactionClasses[i].deserialize(msgBuffer);
-} /* end of deserialize */
-/*<END>---------- Join_Federation_Execution ------------<END>*/
-
-/*<BEGIN>---------- Resign_Federation_Execution ------------<BEGIN>*/
-NM_Resign_Federation_Execution::NM_Resign_Federation_Execution() {
-	this->name = "RESIGN_FEDERATION_EXECUTION";
-	this->type = NetworkMessage::RESIGN_FEDERATION_EXECUTION;
-	/* specific field init */
-}
-NM_Resign_Federation_Execution::~NM_Resign_Federation_Execution() {
-}
-/*<END>---------- Resign_Federation_Execution ------------<END>*/
-
-/*<BEGIN>---------- Set_Time_Regulating ------------<BEGIN>*/
-NM_Set_Time_Regulating::NM_Set_Time_Regulating() {
-	this->name = "SET_TIME_REGULATING";
-	this->type = NetworkMessage::SET_TIME_REGULATING;
-	/* specific field init */	
-	regulator = false;
-}
-NM_Set_Time_Regulating::~NM_Set_Time_Regulating() {
-}
-void NM_Set_Time_Regulating::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	msgBuffer.write_bool(regulator);  	  
-} /* end of serialize */ 
-void NM_Set_Time_Regulating::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	regulator = msgBuffer.read_bool();
-} /* end of deserialize */
-/*<END>---------- Set_Time_Regulating ------------<END>*/
-
-/*<BEGIN>---------- Set_Time_Constrained ------------<BEGIN>*/
-NM_Set_Time_Constrained::NM_Set_Time_Constrained() {
-	this->name = "SET_TIME_CONSTRAINED";
-	this->type = NetworkMessage::SET_TIME_CONSTRAINED;
-	/* specific field init */
-	constrained=false;
-}
-NM_Set_Time_Constrained::~NM_Set_Time_Constrained() {
-}
-void NM_Set_Time_Constrained::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	msgBuffer.write_bool(constrained);  
-} /* end of serialize */ 
-void NM_Set_Time_Constrained::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	constrained = msgBuffer.read_bool();
-} /* end of deserialize */
-/*<END>---------- Set_Time_Constrained ------------<END>*/
-
-/*<BEGIN>---------- Time_Regulation_Enabled  ------------<BEGIN>*/
-NM_Time_Regulation_Enabled::NM_Time_Regulation_Enabled() {
-       this->name = "TIME_REGULATION_ENABLED";
-       this->type = NetworkMessage::TIME_REGULATION_ENABLED;
-}
-
-NM_Time_Regulation_Enabled::~NM_Time_Regulation_Enabled() {
-}
-/*<END>---------- Time_Regulation_Enabled ------------<END>*/
-
-/*<BEGIN>---------- Time_Constrained_Enabled  ------------<BEGIN>*/
-NM_Time_Constrained_Enabled::NM_Time_Constrained_Enabled() {
-       this->name = "TIME_CONSTRAINED_ENABLED";
-       this->type = NetworkMessage::TIME_CONSTRAINED_ENABLED;
-}
-NM_Time_Constrained_Enabled::~NM_Time_Constrained_Enabled() {
-}
-/*<END>---------- Time_Constrained_Enabled ------------<END>*/
-
-/*<BEGIN>---------- Start_Registration_For_Object_Class ------------<BEGIN>*/
-NM_Start_Registration_For_Object_Class::NM_Start_Registration_For_Object_Class() {
-	this->name = "START_REGISTRATION_FOR_OBJECT_CLASS";
-	this->type = NetworkMessage::START_REGISTRATION_FOR_OBJECT_CLASS;
-	/* specific field init */
-}
-NM_Start_Registration_For_Object_Class::~NM_Start_Registration_For_Object_Class() {
-}
-void NM_Start_Registration_For_Object_Class::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	msgBuffer.write_int32(objectClass);
-} /* end of serialize */ 
-void NM_Start_Registration_For_Object_Class::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	objectClass = msgBuffer.read_int32();
-} /* end of deserialize */
-
-/*<END>---------- Start_Registration_For_Object_Class ------------<END>*/
-
-/*<BEGIN>---------- Stop_Registration_For_Object_Class ------------<BEGIN>*/
-NM_Stop_Registration_For_Object_Class::NM_Stop_Registration_For_Object_Class() {
-	this->name = "STOP_REGISTRATION_FOR_OBJECT_CLASS";
-	this->type = NetworkMessage::STOP_REGISTRATION_FOR_OBJECT_CLASS;
-	/* specific field init */
-}
-NM_Stop_Registration_For_Object_Class::~NM_Stop_Registration_For_Object_Class() {
-}
-void NM_Stop_Registration_For_Object_Class::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	msgBuffer.write_int32(objectClass);
-} /* end of serialize */ 
-void NM_Stop_Registration_For_Object_Class::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	objectClass = msgBuffer.read_int32();
-} /* end of deserialize */
-
-/*<END>---------- Stop_Registration_For_Object_Class ------------<END>*/
-
-/*<BEGIN>---------- Set_Class_Relevance_Advisory_Switch ------------<BEGIN>*/
-NM_Set_Class_Relevance_Advisory_Switch::NM_Set_Class_Relevance_Advisory_Switch() {
-	this->name = "SET_CLASS_RELEVANCE_ADVISORY_SWITCH";
-	this->type = NetworkMessage::SET_CLASS_RELEVANCE_ADVISORY_SWITCH;
-	/* specific field init */
-	classRelevanceAdvisorySwitch=true;
-}
-NM_Set_Class_Relevance_Advisory_Switch::~NM_Set_Class_Relevance_Advisory_Switch() {
-}
-void NM_Set_Class_Relevance_Advisory_Switch::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	msgBuffer.write_bool(classRelevanceAdvisorySwitch);  
-} /* end of serialize */ 
-void NM_Set_Class_Relevance_Advisory_Switch::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	classRelevanceAdvisorySwitch = msgBuffer.read_bool();
-} /* end of deserialize */
-/*<END>---------- Set_Class_Relevance_Advisory_Switch ------------<END>*/
-
-/*<BEGIN>---------- Set_Interaction_Relevance_Advisory_Switch ------------<BEGIN>*/
-NM_Set_Interaction_Relevance_Advisory_Switch::NM_Set_Interaction_Relevance_Advisory_Switch() {
-	this->name = "SET_INTERACTION_RELEVANCE_ADVISORY_SWITCH";
-	this->type = NetworkMessage::SET_INTERACTION_RELEVANCE_ADVISORY_SWITCH;
-	/* specific field init */
-	interactionRelevanceAdvisorySwitch=true;
-}
-NM_Set_Interaction_Relevance_Advisory_Switch::~NM_Set_Interaction_Relevance_Advisory_Switch() {
-}
-void NM_Set_Interaction_Relevance_Advisory_Switch::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	msgBuffer.write_bool(interactionRelevanceAdvisorySwitch);  
-} /* end of serialize */ 
-void NM_Set_Interaction_Relevance_Advisory_Switch::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	interactionRelevanceAdvisorySwitch = msgBuffer.read_bool();
-} /* end of deserialize */
-/*<END>---------- Set_Interaction_Relevance_Advisory_Switch ------------<END>*/
-
-/*<BEGIN>---------- Set_Attribute_Relevance_Advisory_Switch ------------<BEGIN>*/
-NM_Set_Attribute_Relevance_Advisory_Switch::NM_Set_Attribute_Relevance_Advisory_Switch() {
-	this->name = "SET_ATTRIBUTE_RELEVANCE_ADVISORY_SWITCH";
-	this->type = NetworkMessage::SET_ATTRIBUTE_RELEVANCE_ADVISORY_SWITCH;
-	/* specific field init */
-	attributeRelevanceAdvisorySwitch=false;
-}
-NM_Set_Attribute_Relevance_Advisory_Switch::~NM_Set_Attribute_Relevance_Advisory_Switch() {
-}
-void NM_Set_Attribute_Relevance_Advisory_Switch::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	msgBuffer.write_bool(attributeRelevanceAdvisorySwitch);  
-} /* end of serialize */ 
-void NM_Set_Attribute_Relevance_Advisory_Switch::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	attributeRelevanceAdvisorySwitch = msgBuffer.read_bool();
-} /* end of deserialize */
-/*<END>---------- Set_Attribute_Relevance_Advisory_Switch ------------<END>*/
-
-/*<BEGIN>---------- Set_Attribute_Scope_Advisory_Switch ------------<BEGIN>*/
-NM_Set_Attribute_Scope_Advisory_Switch::NM_Set_Attribute_Scope_Advisory_Switch() {
-	this->name = "SET_ATTRIBUTE_SCOPE_ADVISORY_SWITCH";
-	this->type = NetworkMessage::SET_ATTRIBUTE_SCOPE_ADVISORY_SWITCH;
-	/* specific field init */
-	attributeScopeAdvisorySwitch=false;
-}
-NM_Set_Attribute_Scope_Advisory_Switch::~NM_Set_Attribute_Scope_Advisory_Switch() {
-}
-void NM_Set_Attribute_Scope_Advisory_Switch::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	msgBuffer.write_bool(attributeScopeAdvisorySwitch);  
-} /* end of serialize */ 
-void NM_Set_Attribute_Scope_Advisory_Switch::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	attributeScopeAdvisorySwitch = msgBuffer.read_bool();
-} /* end of deserialize */
-/*<END>---------- Set_Attribute_Scope_Advisory_Switch ------------<END>*/
-
-/*<BEGIN>---------- Register_Federation_Synchronization_Point ------------<BEGIN>*/
-NM_Register_Federation_Synchronization_Point::NM_Register_Federation_Synchronization_Point() {
-	this->name = "REGISTER_FEDERATION_SYNCHRONIZATION_POINT";
-	this->type = NetworkMessage::REGISTER_FEDERATION_SYNCHRONIZATION_POINT;
-	/* specific field init */
-	this->_setExist = false;
-}
-NM_Register_Federation_Synchronization_Point::~NM_Register_Federation_Synchronization_Point() {
-}
-void 
-NM_Register_Federation_Synchronization_Point::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	msgBuffer.write_bool(_setExist);  
-} /* end of serialize */ 
-void 
-NM_Register_Federation_Synchronization_Point::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	_setExist = msgBuffer.read_bool();
-} /* end of deserialize */
-/*<END>---------- Register_Federation_Synchronization_Point ------------<END>*/
-
-/*<BEGIN>---------- Synchronization_Point_Registration_Succeeded ------------<BEGIN>*/
-NM_Synchronization_Point_Registration_Succeeded::NM_Synchronization_Point_Registration_Succeeded() {
-	this->name = "SYNCHRONIZATION_POINT_REGISTRATION_SUCCEEDED";
-	this->type = NetworkMessage::SYNCHRONIZATION_POINT_REGISTRATION_SUCCEEDED;
-	/* specific field init */
-}
-NM_Synchronization_Point_Registration_Succeeded::~NM_Synchronization_Point_Registration_Succeeded() {
-}
-/*<END>---------- Synchronization_Point_Registration_Succeeded ------------<END>*/
-
-/*<BEGIN>---------- Announce_Synchronization_Point ------------<BEGIN>*/
-NM_Announce_Synchronization_Point::NM_Announce_Synchronization_Point() {
-	this->name = "ANNOUNCE_SYNCHRONIZATION_POINT";
-	this->type = NetworkMessage::ANNOUNCE_SYNCHRONIZATION_POINT;
-	/* specific field init */
-}
-NM_Announce_Synchronization_Point::~NM_Announce_Synchronization_Point() {
-}
-/*<END>---------- Announce_Synchronization_Point ------------<END>*/
-
-/*<BEGIN>---------- Synchronization_Point_Achieved ------------<BEGIN>*/
-NM_Synchronization_Point_Achieved::NM_Synchronization_Point_Achieved() {
-	this->name = "SYNCHRONIZATION_POINT_ACHIEVED";
-	this->type = NetworkMessage::SYNCHRONIZATION_POINT_ACHIEVED;
-	/* specific field init */
-}
-NM_Synchronization_Point_Achieved::~NM_Synchronization_Point_Achieved() {
-}
-/*<END>---------- Synchronization_Point_Achieved ------------<END>*/
-
-/*<BEGIN>---------- Federation_Synchronized ------------<BEGIN>*/
-NM_Federation_Synchronized::NM_Federation_Synchronized() {
-	this->name = "FEDERATION_SYNCHRONIZED";
-	this->type = NetworkMessage::FEDERATION_SYNCHRONIZED;
-	/* specific field init */
-}
-NM_Federation_Synchronized::~NM_Federation_Synchronized() {
-}
-/*<END>---------- Federation_Synchronized ------------<END>*/
-
-/*<BEGIN>---------- Request_Federation_Save ------------<BEGIN>*/
-NM_Request_Federation_Save::NM_Request_Federation_Save() {
-	this->name = "REQUEST_FEDERATION_SAVE";
-	this->type = NetworkMessage::REQUEST_FEDERATION_SAVE;
-	/* specific field init */
-}
-NM_Request_Federation_Save::~NM_Request_Federation_Save() {
-}
-/*<END>---------- Request_Federation_Save ------------<END>*/
-
-/*<BEGIN>---------- Federate_Save_Begun ------------<BEGIN>*/
-NM_Federate_Save_Begun::NM_Federate_Save_Begun() {
-	this->name = "FEDERATE_SAVE_BEGUN";
-	this->type = NetworkMessage::FEDERATE_SAVE_BEGUN;
-	/* specific field init */
-}
-NM_Federate_Save_Begun::~NM_Federate_Save_Begun() {
-}
-/*<END>---------- Federate_Save_Begun ------------<END>*/
-
-/*<BEGIN>---------- Federate_Save_Complete ------------<BEGIN>*/
-NM_Federate_Save_Complete::NM_Federate_Save_Complete() {
-	this->name = "FEDERATE_SAVE_COMPLETE";
-	this->type = NetworkMessage::FEDERATE_SAVE_COMPLETE;
-	/* specific field init */
-}
-NM_Federate_Save_Complete::~NM_Federate_Save_Complete() {
-}
-/*<END>---------- Federate_Save_Complete ------------<END>*/
-
-/*<BEGIN>---------- Federate_Save_Not_Complete ------------<BEGIN>*/
-NM_Federate_Save_Not_Complete::NM_Federate_Save_Not_Complete() {
-	this->name = "FEDERATE_SAVE_NOT_COMPLETE";
-	this->type = NetworkMessage::FEDERATE_SAVE_NOT_COMPLETE;
-	/* specific field init */
-}
-NM_Federate_Save_Not_Complete::~NM_Federate_Save_Not_Complete() {
-}
-/*<END>---------- Federate_Save_Not_Complete ------------<END>*/
-
-/*<BEGIN>---------- Initiate_Federate_Save ------------<BEGIN>*/
-NM_Initiate_Federate_Save::NM_Initiate_Federate_Save() {
-	this->name = "INITIATE_FEDERATE_SAVE";
-	this->type = NetworkMessage::INITIATE_FEDERATE_SAVE;
-	/* specific field init */
-}
-NM_Initiate_Federate_Save::~NM_Initiate_Federate_Save() {
-}
-/*<END>---------- Initiate_Federate_Save ------------<END>*/
-
-/*<BEGIN>---------- Federation_Saved ------------<BEGIN>*/
-NM_Federation_Saved::NM_Federation_Saved() {
-	this->name = "FEDERATION_SAVED";
-	this->type = NetworkMessage::FEDERATION_SAVED;
-	/* specific field init */
-}
-NM_Federation_Saved::~NM_Federation_Saved() {
-}
-/*<END>---------- Federation_Saved ------------<END>*/
-
-/*<BEGIN>---------- Federation_Not_Saved ------------<BEGIN>*/
-NM_Federation_Not_Saved::NM_Federation_Not_Saved() {
-	this->name = "FEDERATION_NOT_SAVED";
-	this->type = NetworkMessage::FEDERATION_NOT_SAVED;
-	/* specific field init */
-}
-NM_Federation_Not_Saved::~NM_Federation_Not_Saved() {
-}
-/*<END>---------- Federation_Not_Saved ------------<END>*/
-
-/*<BEGIN>---------- Request_Federation_Restore ------------<BEGIN>*/
-NM_Request_Federation_Restore::NM_Request_Federation_Restore() {
-	this->name = "REQUEST_FEDERATION_RESTORE";
-	this->type = NetworkMessage::REQUEST_FEDERATION_RESTORE;
-	/* specific field init */
-}
-NM_Request_Federation_Restore::~NM_Request_Federation_Restore() {
-}
-/*<END>---------- Request_Federation_Restore ------------<END>*/
-
-/*<BEGIN>---------- Federate_Restore_Complete ------------<BEGIN>*/
-NM_Federate_Restore_Complete::NM_Federate_Restore_Complete() {
-	this->name = "FEDERATE_RESTORE_COMPLETE";
-	this->type = NetworkMessage::FEDERATE_RESTORE_COMPLETE;
-	/* specific field init */
-}
-NM_Federate_Restore_Complete::~NM_Federate_Restore_Complete() {
-}
-/*<END>---------- Federate_Restore_Complete ------------<END>*/
-
-/*<BEGIN>---------- Federate_Restore_Not_Complete ------------<BEGIN>*/
-NM_Federate_Restore_Not_Complete::NM_Federate_Restore_Not_Complete() {
-	this->name = "FEDERATE_RESTORE_NOT_COMPLETE";
-	this->type = NetworkMessage::FEDERATE_RESTORE_NOT_COMPLETE;
-	/* specific field init */
-}
-NM_Federate_Restore_Not_Complete::~NM_Federate_Restore_Not_Complete() {
-}
-/*<END>---------- Federate_Restore_Not_Complete ------------<END>*/
-
-/*<BEGIN>---------- Request_Federation_Restore_Succeeded ------------<BEGIN>*/
-NM_Request_Federation_Restore_Succeeded::NM_Request_Federation_Restore_Succeeded() {
-	this->name = "REQUEST_FEDERATION_RESTORE_SUCCEEDED";
-	this->type = NetworkMessage::REQUEST_FEDERATION_RESTORE_SUCCEEDED;
-	/* specific field init */
-}
-NM_Request_Federation_Restore_Succeeded::~NM_Request_Federation_Restore_Succeeded() {
-}
-/*<END>---------- Request_Federation_Restore_Succeeded ------------<END>*/
-
-/*<BEGIN>---------- Request_Federation_Restore_Failed ------------<BEGIN>*/
-NM_Request_Federation_Restore_Failed::NM_Request_Federation_Restore_Failed() {
-	this->name = "REQUEST_FEDERATION_RESTORE_FAILED";
-	this->type = NetworkMessage::REQUEST_FEDERATION_RESTORE_FAILED;
-	/* specific field init */
-}
-NM_Request_Federation_Restore_Failed::~NM_Request_Federation_Restore_Failed() {
-}
-/*<END>---------- Request_Federation_Restore_Failed ------------<END>*/
-
-/*<BEGIN>---------- Federation_Restore_Begun ------------<BEGIN>*/
-NM_Federation_Restore_Begun::NM_Federation_Restore_Begun() {
-	this->name = "FEDERATION_RESTORE_BEGUN";
-	this->type = NetworkMessage::FEDERATION_RESTORE_BEGUN;
-	/* specific field init */
-}
-NM_Federation_Restore_Begun::~NM_Federation_Restore_Begun() {
-}
-/*<END>---------- Federation_Restore_Begun ------------<END>*/
-
-/*<BEGIN>---------- Initiate_Federate_Restore ------------<BEGIN>*/
-NM_Initiate_Federate_Restore::NM_Initiate_Federate_Restore() {
-	this->name = "INITIATE_FEDERATE_RESTORE";
-	this->type = NetworkMessage::INITIATE_FEDERATE_RESTORE;
-	/* specific field init */
-}
-NM_Initiate_Federate_Restore::~NM_Initiate_Federate_Restore() {
-}
-/*<END>---------- Initiate_Federate_Restore ------------<END>*/
-
-/*<BEGIN>---------- Federation_Restored ------------<BEGIN>*/
-NM_Federation_Restored::NM_Federation_Restored() {
-	this->name = "FEDERATION_RESTORED";
-	this->type = NetworkMessage::FEDERATION_RESTORED;
-	/* specific field init */
-}
-NM_Federation_Restored::~NM_Federation_Restored() {
-}
-/*<END>---------- Federation_Restored ------------<END>*/
-
-/*<BEGIN>---------- Federation_Not_Restored ------------<BEGIN>*/
-NM_Federation_Not_Restored::NM_Federation_Not_Restored() {
-	this->name = "FEDERATION_NOT_RESTORED";
-	this->type = NetworkMessage::FEDERATION_NOT_RESTORED;
-	/* specific field init */
-}
-NM_Federation_Not_Restored::~NM_Federation_Not_Restored() {
-}
-/*<END>---------- Federation_Not_Restored ------------<END>*/
-
-/*<BEGIN>---------- Publish_Object_Class ------------<BEGIN>*/
-NM_Publish_Object_Class::NM_Publish_Object_Class() {
-	this->name = "PUBLISH_OBJECT_CLASS";
-	this->type = NetworkMessage::PUBLISH_OBJECT_CLASS;
-	/* specific field init */
-}
-NM_Publish_Object_Class::~NM_Publish_Object_Class() {
-}
-void
-NM_Publish_Object_Class::serialize(MessageBuffer& msgBuffer) {
-	Super::serialize(msgBuffer);
-	msgBuffer.write_int32(objectClass);
-}
-void
-NM_Publish_Object_Class::deserialize(MessageBuffer& msgBuffer) {
-	Super::deserialize(msgBuffer);
-	objectClass = msgBuffer.read_int32();
-}
-/*<END>---------- Publish_Object_Class ------------<END>*/
-
-/*<BEGIN>---------- Unpublish_Object_Class ------------<BEGIN>*/
-NM_Unpublish_Object_Class::NM_Unpublish_Object_Class() {
-	this->name = "UNPUBLISH_OBJECT_CLASS";
-	this->type = NetworkMessage::UNPUBLISH_OBJECT_CLASS;
-	/* specific field init */
-}
-NM_Unpublish_Object_Class::~NM_Unpublish_Object_Class() {
-}
-void NM_Unpublish_Object_Class::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	msgBuffer.write_int32(objectClass);
-} /* end of serialize */ 
-void NM_Unpublish_Object_Class::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	objectClass = msgBuffer.read_int32();
-} /* end of deserialize */
-/*<END>---------- Unpublish_Object_Class ------------<END>*/
-
-/*<BEGIN>---------- Publish_Interaction_Class ------------<BEGIN>*/
-NM_Publish_Interaction_Class::NM_Publish_Interaction_Class() {
-	this->name = "PUBLISH_INTERACTION_CLASS";
-	this->type = NetworkMessage::PUBLISH_INTERACTION_CLASS;
-	/* specific field init */
-}
-NM_Publish_Interaction_Class::~NM_Publish_Interaction_Class() {
-}
-void NM_Publish_Interaction_Class::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	msgBuffer.write_int32(interactionClass);
-} /* end of serialize */ 
-void NM_Publish_Interaction_Class::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	interactionClass = msgBuffer.read_int32();
-} /* end of deserialize */
-/*<END>---------- Publish_Interaction_Class ------------<END>*/
-
-/*<BEGIN>---------- Unpublish_Interaction_Class ------------<BEGIN>*/
-NM_Unpublish_Interaction_Class::NM_Unpublish_Interaction_Class() {
-	this->name = "UNPUBLISH_INTERACTION_CLASS";
-	this->type = NetworkMessage::UNPUBLISH_INTERACTION_CLASS;
-	/* specific field init */
-}
-NM_Unpublish_Interaction_Class::~NM_Unpublish_Interaction_Class() {
-}
-/*<END>---------- Unpublish_Interaction_Class ------------<END>*/
-
-/*<BEGIN>---------- Subscribe_Object_Class ------------<BEGIN>*/
-NM_Subscribe_Object_Class::NM_Subscribe_Object_Class() {
-	this->name = "SUBSCRIBE_OBJECT_CLASS";
-	this->type = NetworkMessage::SUBSCRIBE_OBJECT_CLASS;
-	/* specific field init */
-}
-NM_Subscribe_Object_Class::~NM_Subscribe_Object_Class() {
-}
-void NM_Subscribe_Object_Class::serialize(MessageBuffer& msgBuffer) {
-	Super::serialize(msgBuffer);
-	msgBuffer.write_int32(objectClass);
-}
-void NM_Subscribe_Object_Class::deserialize(MessageBuffer& msgBuffer) {
-	Super::deserialize(msgBuffer);
-	objectClass=msgBuffer.read_int32();
-}
-/*<END>---------- Subscribe_Object_Class ------------<END>*/
-
-/*<BEGIN>---------- Unsubscribe_Object_Class ------------<BEGIN>*/
-NM_Unsubscribe_Object_Class::NM_Unsubscribe_Object_Class() {
-	this->name = "UNSUBSCRIBE_OBJECT_CLASS";
-	this->type = NetworkMessage::UNSUBSCRIBE_OBJECT_CLASS;
-	/* specific field init */
-}
-NM_Unsubscribe_Object_Class::~NM_Unsubscribe_Object_Class() {
-}
-/*<END>---------- Unsubscribe_Object_Class ------------<END>*/
-
-/*<BEGIN>---------- Subscribe_Interaction_Class ------------<BEGIN>*/
-NM_Subscribe_Interaction_Class::NM_Subscribe_Interaction_Class() {
-	this->name = "SUBSCRIBE_INTERACTION_CLASS";
-	this->type = NetworkMessage::SUBSCRIBE_INTERACTION_CLASS;
-	/* specific field init */
-}
-NM_Subscribe_Interaction_Class::~NM_Subscribe_Interaction_Class() {
-}
-/*<END>---------- Subscribe_Interaction_Class ------------<END>*/
-
-/*<BEGIN>---------- Unsubscribe_Interaction_Class ------------<BEGIN>*/
-NM_Unsubscribe_Interaction_Class::NM_Unsubscribe_Interaction_Class() {
-	this->name = "UNSUBSCRIBE_INTERACTION_CLASS";
-	this->type = NetworkMessage::UNSUBSCRIBE_INTERACTION_CLASS;
-	/* specific field init */
-}
-NM_Unsubscribe_Interaction_Class::~NM_Unsubscribe_Interaction_Class() {
-}
-/*<END>---------- Unsubscribe_Interaction_Class ------------<END>*/
-
-/*<BEGIN>---------- Turn_Interactions_On ------------<BEGIN>*/
-NM_Turn_Interactions_On::NM_Turn_Interactions_On() {
-	this->name = "TURN_INTERACTIONS_ON";
-	this->type = NetworkMessage::TURN_INTERACTIONS_ON;
-	/* specific field init */
-}
-NM_Turn_Interactions_On::~NM_Turn_Interactions_On() {
-}
-/*<END>---------- Turn_Interactions_On ------------<END>*/
-
-/*<BEGIN>---------- Turn_Interactions_Off ------------<BEGIN>*/
-NM_Turn_Interactions_Off::NM_Turn_Interactions_Off() {
-	this->name = "TURN_INTERACTIONS_OFF";
-	this->type = NetworkMessage::TURN_INTERACTIONS_OFF;
-	/* specific field init */
-}
-NM_Turn_Interactions_Off::~NM_Turn_Interactions_Off() {
-}
-/*<END>---------- Turn_Interactions_Off ------------<END>*/
-
-/*<BEGIN>---------- Register_Object ------------<BEGIN>*/
-NM_Register_Object::NM_Register_Object() {
-	this->name = "REGISTER_OBJECT";
-	this->type = NetworkMessage::REGISTER_OBJECT;
-	/* specific field init */
-}
-NM_Register_Object::~NM_Register_Object() {
-}
-void NM_Register_Object::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	msgBuffer.write_int32(objectClass);
-	msgBuffer.write_int32(object);
-} /* end of serialize */ 
-void NM_Register_Object::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	objectClass = msgBuffer.read_int32();
-	object      = msgBuffer.read_int32();
-} /* end of deserialize */
-/*<END>---------- Register_Object ------------<END>*/
-
-/*<BEGIN>---------- Discover_Object ------------<BEGIN>*/
-NM_Discover_Object::NM_Discover_Object() {
-	this->name = "DISCOVER_OBJECT";
-	this->type = NetworkMessage::DISCOVER_OBJECT;
-	/* specific field init */
-}
-NM_Discover_Object::~NM_Discover_Object() {
-}
-/*<END>---------- Discover_Object ------------<END>*/
-
-/*<BEGIN>---------- Update_Attribute_Values ------------<BEGIN>*/
-NM_Update_Attribute_Values::NM_Update_Attribute_Values() {
-	this->name = "UPDATE_ATTRIBUTE_VALUES";
-	this->type = NetworkMessage::UPDATE_ATTRIBUTE_VALUES;
-	/* specific field init */
-}
-NM_Update_Attribute_Values::~NM_Update_Attribute_Values() {
-}
-void NM_Update_Attribute_Values::serialize(MessageBuffer& msgBuffer) {
-	int i;
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* handleArraySize was done by superclass */
-	/* specific code (if any) goes here */
-	msgBuffer.write_int32(object);	
-	msgBuffer.write_int32(objectClass);
-	/* the value pre-encoded by the user (HLA 1.3) */
-	for (i = 0 ; i < handleArraySize ; i++)
-		msgBuffer.write_string(valueArray[i]) ;
-} /* end of serialize */ 
-void NM_Update_Attribute_Values::deserialize(MessageBuffer& msgBuffer) {
-	int i;
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* handleArraySize was done by superclass */
-	/* specific code (if any) goes here */		
-	object          = msgBuffer.read_int32();	
-	objectClass     = msgBuffer.read_int32();
-    valueArray.resize(handleArraySize) ;	
-    for (i = 0; i < handleArraySize; i++)
-        msgBuffer.read_string(valueArray[i]);
-} /* end of deserialize */
-/*<END>---------- Update_Attribute_Values ------------<END>*/
-
-/*<BEGIN>---------- Reflect_Attribute_Values ------------<BEGIN>*/
-NM_Reflect_Attribute_Values::NM_Reflect_Attribute_Values() {
-	this->name = "REFLECT_ATTRIBUTE_VALUES";
-	this->type = NetworkMessage::REFLECT_ATTRIBUTE_VALUES;
-	/* specific field init */
-}
-NM_Reflect_Attribute_Values::~NM_Reflect_Attribute_Values() {
-}
-/*<END>---------- Reflect_Attribute_Values ------------<END>*/
-
-/*<BEGIN>---------- Send_Interaction ------------<BEGIN>*/
-NM_Send_Interaction::NM_Send_Interaction() {
-	this->name = "SEND_INTERACTION";
-	this->type = NetworkMessage::SEND_INTERACTION;
-	/* specific field init */
-}
-NM_Send_Interaction::~NM_Send_Interaction() {
-}
-void NM_Send_Interaction::serialize(MessageBuffer& msgBuffer) {
-	int i;
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	msgBuffer.write_int32(region);
-	msgBuffer.write_int32(interactionClass);	
-	/* the value pre-encoded by the user (HLA 1.3) */
-	for (i = 0 ; i < handleArraySize ; i++)
-		msgBuffer.write_string(valueArray[i]);
-} /* end of serialize */ 
-void NM_Send_Interaction::deserialize(MessageBuffer& msgBuffer) {
-	int i;
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	region           = msgBuffer.read_int32();
-	interactionClass = msgBuffer.read_int32();
-    valueArray.resize(handleArraySize);
-    for (i = 0; i < handleArraySize; i++)
-        msgBuffer.read_string(valueArray[i]);
-} /* end of deserialize */
-/*<END>---------- Send_Interaction ------------<END>*/
-
-/*<BEGIN>---------- Receive_Interaction ------------<BEGIN>*/
-NM_Receive_Interaction::NM_Receive_Interaction() {
-	this->name = "RECEIVE_INTERACTION";
-	this->type = NetworkMessage::RECEIVE_INTERACTION;
-	/* specific field init */
-}
-NM_Receive_Interaction::~NM_Receive_Interaction() {
-}
-/*<END>---------- Receive_Interaction ------------<END>*/
-
-/*<BEGIN>---------- Delete_Object ------------<BEGIN>*/
-NM_Delete_Object::NM_Delete_Object() {
-	this->name = "DELETE_OBJECT";
-	this->type = NetworkMessage::DELETE_OBJECT;
-	/* specific field init */
-}
-NM_Delete_Object::~NM_Delete_Object() {
-}
-/*<END>---------- Delete_Object ------------<END>*/
-
-/*<BEGIN>---------- Remove_Object ------------<BEGIN>*/
-NM_Remove_Object::NM_Remove_Object() {
-	this->name = "REMOVE_OBJECT";
-	this->type = NetworkMessage::REMOVE_OBJECT;
-	/* specific field init */
-}
-NM_Remove_Object::~NM_Remove_Object() {
-}
-
-/*<END>---------- Remove_Object ------------<END>*/
-
-/*<BEGIN>---------- Change_Attribute_Transport_Type ------------<BEGIN>*/
-NM_Change_Attribute_Transport_Type::NM_Change_Attribute_Transport_Type() {
-	this->name = "CHANGE_ATTRIBUTE_TRANSPORT_TYPE";
-	this->type = NetworkMessage::CHANGE_ATTRIBUTE_TRANSPORT_TYPE;
-	/* specific field init */
-}
-NM_Change_Attribute_Transport_Type::~NM_Change_Attribute_Transport_Type() {
-}
-void NM_Change_Attribute_Transport_Type::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-} /* end of serialize */ 
-void NM_Change_Attribute_Transport_Type::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-} /* end of deserialize */
-/*<END>---------- Change_Attribute_Transport_Type ------------<END>*/
-
-/*<BEGIN>---------- Change_Attribute_Order_Type ------------<BEGIN>*/
-NM_Change_Attribute_Order_Type::NM_Change_Attribute_Order_Type() {
-	this->name = "CHANGE_ATTRIBUTE_ORDER_TYPE";
-	this->type = NetworkMessage::CHANGE_ATTRIBUTE_ORDER_TYPE;
-	/* specific field init */
-}
-NM_Change_Attribute_Order_Type::~NM_Change_Attribute_Order_Type() {
-}
-void NM_Change_Attribute_Order_Type::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-} /* end of serialize */ 
-void NM_Change_Attribute_Order_Type::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-} /* end of deserialize */
-/*<END>---------- Change_Attribute_Order_Type ------------<END>*/
-
-/*<BEGIN>---------- Change_Interaction_Transport_Type ------------<BEGIN>*/
-NM_Change_Interaction_Transport_Type::NM_Change_Interaction_Transport_Type() {
-	this->name = "CHANGE_INTERACTION_TRANSPORT_TYPE";
-	this->type = NetworkMessage::CHANGE_INTERACTION_TRANSPORT_TYPE;
-	/* specific field init */
-}
-NM_Change_Interaction_Transport_Type::~NM_Change_Interaction_Transport_Type() {
-}
-void NM_Change_Interaction_Transport_Type::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-} /* end of serialize */ 
-void NM_Change_Interaction_Transport_Type::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-} /* end of deserialize */
-/*<END>---------- Change_Interaction_Transport_Type ------------<END>*/
-
-/*<BEGIN>---------- Change_Interaction_Order_Type ------------<BEGIN>*/
-NM_Change_Interaction_Order_Type::NM_Change_Interaction_Order_Type() {
-	this->name = "CHANGE_INTERACTION_ORDER_TYPE";
-	this->type = NetworkMessage::CHANGE_INTERACTION_ORDER_TYPE;
-	/* specific field init */
-}
-NM_Change_Interaction_Order_Type::~NM_Change_Interaction_Order_Type() {
-}
-void NM_Change_Interaction_Order_Type::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-} /* end of serialize */ 
-void NM_Change_Interaction_Order_Type::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-} /* end of deserialize */
-/*<END>---------- Change_Interaction_Order_Type ------------<END>*/
-
-/*<BEGIN>---------- Request_Class_Attribute_Value_Update ------------<BEGIN>*/
-NM_Request_Class_Attribute_Value_Update::NM_Request_Class_Attribute_Value_Update() {
-	this->name = "REQUEST_CLASS_ATTRIBUTE_VALUE_UPDATE";
-	this->type = NetworkMessage::REQUEST_CLASS_ATTRIBUTE_VALUE_UPDATE;
-	/* specific field init */
-}
-NM_Request_Class_Attribute_Value_Update::~NM_Request_Class_Attribute_Value_Update() {
-}
-void NM_Request_Class_Attribute_Value_Update::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-} /* end of serialize */ 
-void NM_Request_Class_Attribute_Value_Update::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-} /* end of deserialize */
-/*<END>---------- Request_Class_Attribute_Value_Update ------------<END>*/
-
-/*<BEGIN>---------- Request_Object_Attribute_Value_Update ------------<BEGIN>*/
-NM_Request_Object_Attribute_Value_Update::NM_Request_Object_Attribute_Value_Update() {
-	this->name = "REQUEST_OBJECT_ATTRIBUTE_VALUE_UPDATE";
-	this->type = NetworkMessage::REQUEST_OBJECT_ATTRIBUTE_VALUE_UPDATE;
-	/* specific field init */
-}
-NM_Request_Object_Attribute_Value_Update::~NM_Request_Object_Attribute_Value_Update() {
-}
-void NM_Request_Object_Attribute_Value_Update::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	msgBuffer.write_int32(object);
-} /* end of serialize */ 
-void NM_Request_Object_Attribute_Value_Update::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	object  = msgBuffer.read_int32();
-} /* end of deserialize */
-/*<END>---------- Request_Object_Attribute_Value_Update ------------<END>*/
-
-/*<BEGIN>---------- Is_Attribute_Owned_By_Federate ------------<BEGIN>*/
-NM_Is_Attribute_Owned_By_Federate::NM_Is_Attribute_Owned_By_Federate() {
-	this->name = "IS_ATTRIBUTE_OWNED_BY_FEDERATE";
-	this->type = NetworkMessage::IS_ATTRIBUTE_OWNED_BY_FEDERATE;
-	/* specific field init */
-}
-NM_Is_Attribute_Owned_By_Federate::~NM_Is_Attribute_Owned_By_Federate() {
-}
-void NM_Is_Attribute_Owned_By_Federate::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	msgBuffer.write_int32(object);
-	msgBuffer.write_int32(attribute);
-} /* end of serialize */ 
-void NM_Is_Attribute_Owned_By_Federate::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	Super::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	object    = msgBuffer.read_int32();
-	attribute = msgBuffer.read_int32();
-} /* end of deserialize */
-/*<END>---------- Is_Attribute_Owned_By_Federate ------------<END>*/
-
-/*<BEGIN>---------- Query_Attribute_Ownership ------------<BEGIN>*/
-NM_Query_Attribute_Ownership::NM_Query_Attribute_Ownership() {
-	this->name = "QUERY_ATTRIBUTE_OWNERSHIP";
-	this->type = NetworkMessage::QUERY_ATTRIBUTE_OWNERSHIP;
-	/* specific field init */
-}
-NM_Query_Attribute_Ownership::~NM_Query_Attribute_Ownership() {
-}
-/*<END>---------- Query_Attribute_Ownership ------------<END>*/
-
-/*<BEGIN>---------- Attribute_Is_Not_Owned ------------<BEGIN>*/
-NM_Attribute_Is_Not_Owned::NM_Attribute_Is_Not_Owned() {
-	this->name = "ATTRIBUTE_IS_NOT_OWNED";
-	this->type = NetworkMessage::ATTRIBUTE_IS_NOT_OWNED;
-	/* specific field init */
-}
-NM_Attribute_Is_Not_Owned::~NM_Attribute_Is_Not_Owned() {
-}
-/*<END>---------- Attribute_Is_Not_Owned ------------<END>*/
-
-/*<BEGIN>---------- Inform_Attribute_Ownership ------------<BEGIN>*/
-NM_Inform_Attribute_Ownership::NM_Inform_Attribute_Ownership() {
-	this->name = "INFORM_ATTRIBUTE_OWNERSHIP";
-	this->type = NetworkMessage::INFORM_ATTRIBUTE_OWNERSHIP;
-	/* specific field init */
-}
-NM_Inform_Attribute_Ownership::~NM_Inform_Attribute_Ownership() {
-}
-/*<END>---------- Inform_Attribute_Ownership ------------<END>*/
-
-/*<BEGIN>---------- Negotiated_Attribute_Ownership_Divestiture ------------<BEGIN>*/
-NM_Negotiated_Attribute_Ownership_Divestiture::NM_Negotiated_Attribute_Ownership_Divestiture() {
-	this->name = "NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE";
-	this->type = NetworkMessage::NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE;
-	/* specific field init */
-}
-NM_Negotiated_Attribute_Ownership_Divestiture::~NM_Negotiated_Attribute_Ownership_Divestiture() {
-}
-/*<END>---------- Negotiated_Attribute_Ownership_Divestiture ------------<END>*/
-
-/*<BEGIN>---------- Attribute_Ownership_Acquisition_Notification ------------<BEGIN>*/
-NM_Attribute_Ownership_Acquisition_Notification::NM_Attribute_Ownership_Acquisition_Notification() {
-	this->name = "ATTRIBUTE_OWNERSHIP_ACQUISITION_NOTIFICATION";
-	this->type = NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION_NOTIFICATION;
-	/* specific field init */
-}
-NM_Attribute_Ownership_Acquisition_Notification::~NM_Attribute_Ownership_Acquisition_Notification() {
-}
-/*<END>---------- Attribute_Ownership_Acquisition_Notification ------------<END>*/
-
-/*<BEGIN>---------- Attribute_Ownership_Divestiture_Notification ------------<BEGIN>*/
-NM_Attribute_Ownership_Divestiture_Notification::NM_Attribute_Ownership_Divestiture_Notification() {
-	this->name = "ATTRIBUTE_OWNERSHIP_DIVESTITURE_NOTIFICATION";
-	this->type = NetworkMessage::ATTRIBUTE_OWNERSHIP_DIVESTITURE_NOTIFICATION;
-	/* specific field init */
-}
-NM_Attribute_Ownership_Divestiture_Notification::~NM_Attribute_Ownership_Divestiture_Notification() {
-}
-/*<END>---------- Attribute_Ownership_Divestiture_Notification ------------<END>*/
-
-/*<BEGIN>---------- Request_Attribute_Ownership_Assumption ------------<BEGIN>*/
-NM_Request_Attribute_Ownership_Assumption::NM_Request_Attribute_Ownership_Assumption() {
-	this->name = "REQUEST_ATTRIBUTE_OWNERSHIP_ASSUMPTION";
-	this->type = NetworkMessage::REQUEST_ATTRIBUTE_OWNERSHIP_ASSUMPTION;
-	/* specific field init */
-}
-NM_Request_Attribute_Ownership_Assumption::~NM_Request_Attribute_Ownership_Assumption() {
-}
-/*<END>---------- Request_Attribute_Ownership_Assumption ------------<END>*/
-
-/*<BEGIN>---------- Attribute_Ownership_Unavailable ------------<BEGIN>*/
-NM_Attribute_Ownership_Unavailable::NM_Attribute_Ownership_Unavailable() {
-	this->name = "ATTRIBUTE_OWNERSHIP_UNAVAILABLE";
-	this->type = NetworkMessage::ATTRIBUTE_OWNERSHIP_UNAVAILABLE;
-	/* specific field init */
-}
-NM_Attribute_Ownership_Unavailable::~NM_Attribute_Ownership_Unavailable() {
-}
-/*<END>---------- Attribute_Ownership_Unavailable ------------<END>*/
-
-/*<BEGIN>---------- Attribute_Ownership_Acquisition_If_Available ------------<BEGIN>*/
-NM_Attribute_Ownership_Acquisition_If_Available::NM_Attribute_Ownership_Acquisition_If_Available() {
-	this->name = "ATTRIBUTE_OWNERSHIP_ACQUISITION_IF_AVAILABLE";
-	this->type = NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION_IF_AVAILABLE;
-	/* specific field init */
-}
-NM_Attribute_Ownership_Acquisition_If_Available::~NM_Attribute_Ownership_Acquisition_If_Available() {
-}
-/*<END>---------- Attribute_Ownership_Acquisition_If_Available ------------<END>*/
-
-/*<BEGIN>---------- Unconditional_Attribute_Ownership_Divestiture ------------<BEGIN>*/
-NM_Unconditional_Attribute_Ownership_Divestiture::NM_Unconditional_Attribute_Ownership_Divestiture() {
-	this->name = "UNCONDITIONAL_ATTRIBUTE_OWNERSHIP_DIVESTITURE";
-	this->type = NetworkMessage::UNCONDITIONAL_ATTRIBUTE_OWNERSHIP_DIVESTITURE;
-	/* specific field init */
-}
-NM_Unconditional_Attribute_Ownership_Divestiture::~NM_Unconditional_Attribute_Ownership_Divestiture() {
-}
-/*<END>---------- Unconditional_Attribute_Ownership_Divestiture ------------<END>*/
-
-/*<BEGIN>---------- Attribute_Ownership_Acquisition ------------<BEGIN>*/
-NM_Attribute_Ownership_Acquisition::NM_Attribute_Ownership_Acquisition() {
-	this->name = "ATTRIBUTE_OWNERSHIP_ACQUISITION";
-	this->type = NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION;
-	/* specific field init */
-}
-NM_Attribute_Ownership_Acquisition::~NM_Attribute_Ownership_Acquisition() {
-}
-/*<END>---------- Attribute_Ownership_Acquisition ------------<END>*/
-
-/*<BEGIN>---------- Request_Attribute_Ownership_Release ------------<BEGIN>*/
-NM_Request_Attribute_Ownership_Release::NM_Request_Attribute_Ownership_Release() {
-	this->name = "REQUEST_ATTRIBUTE_OWNERSHIP_RELEASE";
-	this->type = NetworkMessage::REQUEST_ATTRIBUTE_OWNERSHIP_RELEASE;
-	/* specific field init */
-}
-NM_Request_Attribute_Ownership_Release::~NM_Request_Attribute_Ownership_Release() {
-}
-/*<END>---------- Request_Attribute_Ownership_Release ------------<END>*/
-
-/*<BEGIN>---------- Cancel_Negotiated_Attribute_Ownership_Divestiture ------------<BEGIN>*/
-NM_Cancel_Negotiated_Attribute_Ownership_Divestiture::NM_Cancel_Negotiated_Attribute_Ownership_Divestiture() {
-	this->name = "CANCEL_NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE";
-	this->type = NetworkMessage::CANCEL_NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE;
-	/* specific field init */
-}
-NM_Cancel_Negotiated_Attribute_Ownership_Divestiture::~NM_Cancel_Negotiated_Attribute_Ownership_Divestiture() {
-}
-/*<END>---------- Cancel_Negotiated_Attribute_Ownership_Divestiture ------------<END>*/
-
-/*<BEGIN>---------- Attribute_Ownership_Release_Response ------------<BEGIN>*/
-NM_Attribute_Ownership_Release_Response::NM_Attribute_Ownership_Release_Response() {
-	this->name = "ATTRIBUTE_OWNERSHIP_RELEASE_RESPONSE";
-	this->type = NetworkMessage::ATTRIBUTE_OWNERSHIP_RELEASE_RESPONSE;
-	/* specific field init */
-}
-NM_Attribute_Ownership_Release_Response::~NM_Attribute_Ownership_Release_Response() {
-}
-/*<END>---------- Attribute_Ownership_Release_Response ------------<END>*/
-
-/*<BEGIN>---------- Cancel_Attribute_Ownership_Acquisition ------------<BEGIN>*/
-NM_Cancel_Attribute_Ownership_Acquisition::NM_Cancel_Attribute_Ownership_Acquisition() {
-	this->name = "CANCEL_ATTRIBUTE_OWNERSHIP_ACQUISITION";
-	this->type = NetworkMessage::CANCEL_ATTRIBUTE_OWNERSHIP_ACQUISITION;
-	/* specific field init */
-}
-NM_Cancel_Attribute_Ownership_Acquisition::~NM_Cancel_Attribute_Ownership_Acquisition() {
-}
-/*<END>---------- Cancel_Attribute_Ownership_Acquisition ------------<END>*/
-
-/*<BEGIN>---------- Confirm_Attribute_Ownership_Acquisition_Cancellation ------------<BEGIN>*/
-NM_Confirm_Attribute_Ownership_Acquisition_Cancellation::NM_Confirm_Attribute_Ownership_Acquisition_Cancellation() {
-	this->name = "CONFIRM_ATTRIBUTE_OWNERSHIP_ACQUISITION_CANCELLATION";
-	this->type = NetworkMessage::CONFIRM_ATTRIBUTE_OWNERSHIP_ACQUISITION_CANCELLATION;
-	/* specific field init */
-}
-NM_Confirm_Attribute_Ownership_Acquisition_Cancellation::~NM_Confirm_Attribute_Ownership_Acquisition_Cancellation() {
-}
-/*<END>---------- Confirm_Attribute_Ownership_Acquisition_Cancellation ------------<END>*/
-
-/*<BEGIN>---------- DDM_Create_Region ------------<BEGIN>*/
-NM_DDM_Create_Region::NM_DDM_Create_Region() {
-	this->name = "DDM_CREATE_REGION";
-	this->type = NetworkMessage::DDM_CREATE_REGION;
-	/* specific field init */
-}
-NM_DDM_Create_Region::~NM_DDM_Create_Region() {
-}
-void NM_DDM_Create_Region::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	NetworkMessage::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	msgBuffer.write_int32(space);
-	msgBuffer.write_int32(nbExtents);
-	msgBuffer.write_int32(region);
-} /* end of serialize */ 
-void NM_DDM_Create_Region::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	NetworkMessage::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	space     = msgBuffer.read_int32();
-	nbExtents = msgBuffer.read_int32();
-	region    = msgBuffer.read_int32();
-} /* end of deserialize */
-/*<END>---------- DDM_Create_Region ------------<END>*/
-
-/*<BEGIN>---------- DDM_Modify_Region ------------<BEGIN>*/
-NM_DDM_Modify_Region::NM_DDM_Modify_Region() {
-	this->name = "DDM_MODIFY_REGION";
-	this->type = NetworkMessage::DDM_MODIFY_REGION;
-	/* specific field init */
-}
-NM_DDM_Modify_Region::~NM_DDM_Modify_Region() {
-}
-void NM_DDM_Modify_Region::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	NetworkMessage::serialize(msgBuffer);	
-	/* specific code (if any) goes here */
-	msgBuffer.write_int32(federation);
-	msgBuffer.write_int32(federate);
-	msgBuffer.write_int32(region);
-	writeExtents(msgBuffer);
-} /* end of serialize */ 
-void NM_DDM_Modify_Region::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	NetworkMessage::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	federation = msgBuffer.read_int32();
-	federate   = msgBuffer.read_int32();
-	region     = msgBuffer.read_int32();
-	readExtents(msgBuffer);
-} /* end of deserialize */
-/*<END>---------- DDM_Modify_Region ------------<END>*/
-
-/*<BEGIN>---------- DDM_Delete_Region ------------<BEGIN>*/
-NM_DDM_Delete_Region::NM_DDM_Delete_Region() {
-	this->name = "DDM_DELETE_REGION";
-	this->type = NetworkMessage::DDM_DELETE_REGION;
-	/* specific field init */
-}
-NM_DDM_Delete_Region::~NM_DDM_Delete_Region() {
-}
-void NM_DDM_Delete_Region::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	NetworkMessage::serialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	msgBuffer.write_int32(federation);
-	msgBuffer.write_int32(federate);
-	msgBuffer.write_int32(region);
-} /* end of serialize */ 
-void NM_DDM_Delete_Region::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	NetworkMessage::deserialize(msgBuffer); 
-	/* specific code (if any) goes here */
-	federation = msgBuffer.read_int32();
-	federate   = msgBuffer.read_int32();
-	region     = msgBuffer.read_int32();
-} /* end of deserialize */
-/*<END>---------- DDM_Delete_Region ------------<END>*/
-
-/*<BEGIN>---------- DDM_Associate_Region ------------<BEGIN>*/
-NM_DDM_Associate_Region::NM_DDM_Associate_Region() {
-	this->name = "DDM_ASSOCIATE_REGION";
-	this->type = NetworkMessage::DDM_ASSOCIATE_REGION;
-	/* specific field init */
-}
-NM_DDM_Associate_Region::~NM_DDM_Associate_Region() {
-}
-void NM_DDM_Associate_Region::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	NM_WithHandleArray::serialize(msgBuffer);
-	/* specific code (if any) goes here */
-	msgBuffer.write_int32(object);
-	msgBuffer.write_int32(region);
-	msgBuffer.write_bool(DDM_bool);
-} /* end of serialize */ 
-void NM_DDM_Associate_Region::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	NM_WithHandleArray::deserialize(msgBuffer);
-	/* specific code (if any) goes here */
-	object  = msgBuffer.read_int32();
-	region  = msgBuffer.read_int32();
-	DDM_bool = msgBuffer.read_bool();
-} /* end of deserialize */
-/*<END>---------- DDM_Associate_Region ------------<END>*/
-
-/*<BEGIN>---------- DDM_Register_Object ------------<BEGIN>*/
-NM_DDM_Register_Object::NM_DDM_Register_Object() {
-	this->name = "DDM_REGISTER_OBJECT";
-	this->type = NetworkMessage::DDM_REGISTER_OBJECT;
-	/* specific field init */
-}
-NM_DDM_Register_Object::~NM_DDM_Register_Object() {
-}
-void NM_DDM_Register_Object::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	NM_WithHandleArray::serialize(msgBuffer);
-	/* specific code (if any) goes here */
-	msgBuffer.write_int32(object);
-	msgBuffer.write_int32(objectClass);
-	msgBuffer.write_int32(region);
-	msgBuffer.write_bool(DDM_bool);
-} /* end of serialize */ 
-void NM_DDM_Register_Object::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	NM_WithHandleArray::deserialize(msgBuffer);
-	/* specific code (if any) goes here */
-	object      = msgBuffer.read_int32();
-	objectClass = msgBuffer.read_int32();
-	region      = msgBuffer.read_int32();
-	DDM_bool     = msgBuffer.read_bool();
-} /* end of deserialize */
-/*<END>---------- DDM_Register_Object ------------<END>*/
-
-/*<BEGIN>---------- DDM_Unassociate_Region ------------<BEGIN>*/
-NM_DDM_Unassociate_Region::NM_DDM_Unassociate_Region() {
-	this->name = "DDM_UNASSOCIATE_REGION";
-	this->type = NetworkMessage::DDM_UNASSOCIATE_REGION;
-	/* specific field init */
-}
-NM_DDM_Unassociate_Region::~NM_DDM_Unassociate_Region() {
-}
-void NM_DDM_Unassociate_Region::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	NetworkMessage::serialize(msgBuffer);
-	/* specific code (if any) goes here */
-	msgBuffer.write_int32(object);
-	msgBuffer.write_int32(region);
-} /* end of serialize */ 
-void NM_DDM_Unassociate_Region::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      	
-	NetworkMessage::deserialize(msgBuffer);
-	/* specific code (if any) goes here */
-	object = msgBuffer.read_int32();
-	region = msgBuffer.read_int32();
-} /* end of deserialize */
-/*<END>---------- DDM_Unassociate_Region ------------<END>*/
-
-/*<BEGIN>---------- DDM_Subscribe_Attributes ------------<BEGIN>*/
-NM_DDM_Subscribe_Attributes::NM_DDM_Subscribe_Attributes() {
-	this->name = "DDM_SUBSCRIBE_ATTRIBUTES";
-	this->type = NetworkMessage::DDM_SUBSCRIBE_ATTRIBUTES;
-	/* specific field init */
-}
-NM_DDM_Subscribe_Attributes::~NM_DDM_Subscribe_Attributes() {
-}
-void NM_DDM_Subscribe_Attributes::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	NM_WithHandleArray::serialize(msgBuffer);
-	/* specific code (if any) goes here */
-	msgBuffer.write_int32(objectClass);
-	msgBuffer.write_int32(region);
-	msgBuffer.write_bool(DDM_bool);
-} /* end of serialize */ 
-void NM_DDM_Subscribe_Attributes::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	NM_WithHandleArray::deserialize(msgBuffer);
-	/* specific code (if any) goes here */
-	objectClass = msgBuffer.read_int32();
-	region      = msgBuffer.read_int32();
-	DDM_bool     = msgBuffer.read_bool();
-} /* end of deserialize */
-/*<END>---------- DDM_Subscribe_Attributes ------------<END>*/
-
-/*<BEGIN>---------- DDM_Unsubscribe_Attributes ------------<BEGIN>*/
-NM_DDM_Unsubscribe_Attributes::NM_DDM_Unsubscribe_Attributes() {
-	this->name = "DDM_UNSUBSCRIBE_ATTRIBUTES";
-	this->type = NetworkMessage::DDM_UNSUBSCRIBE_ATTRIBUTES;
-	/* specific field init */
-}
-NM_DDM_Unsubscribe_Attributes::~NM_DDM_Unsubscribe_Attributes() {
-}
-void NM_DDM_Unsubscribe_Attributes::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	NetworkMessage::serialize(msgBuffer);
-	/* specific code (if any) goes here */
-	msgBuffer.write_int32(objectClass);
-	msgBuffer.write_int32(region);
-} /* end of serialize */ 
-void NM_DDM_Unsubscribe_Attributes::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	NetworkMessage::deserialize(msgBuffer);
-	/* specific code (if any) goes here */
-	objectClass = msgBuffer.read_int32();
-	region = msgBuffer.read_int32();
-} /* end of deserialize */
-/*<END>---------- DDM_Unsubscribe_Attributes ------------<END>*/
-
-/*<BEGIN>---------- DDM_Subscribe_Interaction ------------<BEGIN>*/
-NM_DDM_Subscribe_Interaction::NM_DDM_Subscribe_Interaction() {
-	this->name = "DDM_SUBSCRIBE_INTERACTION";
-	this->type = NetworkMessage::DDM_SUBSCRIBE_INTERACTION;
-	/* specific field init */
-}
-NM_DDM_Subscribe_Interaction::~NM_DDM_Subscribe_Interaction() {
-}
-void NM_DDM_Subscribe_Interaction::serialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	NetworkMessage::serialize(msgBuffer);
-	/* specific code (if any) goes here */
-	msgBuffer.write_int32(interactionClass);
-	msgBuffer.write_int32(region);
-	msgBuffer.write_bool(DDM_bool);
-} /* end of serialize */ 
-void NM_DDM_Subscribe_Interaction::deserialize(MessageBuffer& msgBuffer) {
-	/* call mother class */      
-	NetworkMessage::deserialize(msgBuffer);
-	/* specific code (if any) goes here */
-	interactionClass = msgBuffer.read_int32();
-	region           = msgBuffer.read_int32();
-	DDM_bool           = msgBuffer.read_bool();
-} /* end of deserialize */
-/*<END>---------- DDM_Subscribe_Interaction ------------<END>*/
-
-/*<BEGIN>---------- DDM_Unsubscribe_Interaction ------------<BEGIN>*/
-NM_DDM_Unsubscribe_Interaction::NM_DDM_Unsubscribe_Interaction() {
-	this->name = "DDM_UNSUBSCRIBE_INTERACTION";
-	this->type = NetworkMessage::DDM_UNSUBSCRIBE_INTERACTION;
-	/* specific field init */
-}
-NM_DDM_Unsubscribe_Interaction::~NM_DDM_Unsubscribe_Interaction() {
-}
-/*<END>---------- DDM_Unsubscribe_Interaction ------------<END>*/
-
-/*<BEGIN>---------- Provide_Attribute_Value_Update ------------<BEGIN>*/
-NM_Provide_Attribute_Value_Update::NM_Provide_Attribute_Value_Update() {
-	this->name = "PROVIDE_ATTRIBUTE_VALUE_UPDATE";
-	this->type = NetworkMessage::PROVIDE_ATTRIBUTE_VALUE_UPDATE;
-	/* specific field init */
-}
-NM_Provide_Attribute_Value_Update::~NM_Provide_Attribute_Value_Update() {
-}
-/*<END>---------- Provide_Attribute_Value_Update ------------<END>*/
-
-/*<BEGIN>---------- Last ------------<BEGIN>*/
-NM_Last::NM_Last() {
-	this->name = "LAST";
-	this->type = NetworkMessage::LAST;
-	/* specific field init */
-}
-NM_Last::~NM_Last() {
-}
-/*<END>---------- Last ------------<END>*/
+   NM_FOM_Dimension::NM_FOM_Dimension() {
+      handle=0;
+      //name= <no default value in message spec using builtin>
+   }
+
+   NM_FOM_Dimension::~NM_FOM_Dimension() {
+   }
+
+   void NM_FOM_Dimension::serialize(MessageBuffer& msgBuffer) {
+      //Specific serialization code
+      msgBuffer.write_uint32(handle);
+      msgBuffer.write_string(name);
+   }
+
+   void NM_FOM_Dimension::deserialize(MessageBuffer& msgBuffer) {
+      //Specific deserialization code
+      handle = static_cast<DimensionHandle>(msgBuffer.read_uint32());
+      msgBuffer.read_string(name);
+   }
+
+   void NM_FOM_Dimension::show(std::ostream& out) {
+      out << "[NM_FOM_Dimension -Begin]" << std::endl;      //Specific show code
+      out << " handle = " << handle << " "       << std::endl;
+      out << " name = " << name << " "       << std::endl;
+      out << "[NM_FOM_Dimension -End]" << std::endl;   }
+
+   NM_FOM_Routing_Space::NM_FOM_Routing_Space() {
+      space=0;
+      //name= <no default value in message spec using builtin>
+      //dimensions= <no default value in message spec using builtin>
+   }
+
+   NM_FOM_Routing_Space::~NM_FOM_Routing_Space() {
+   }
+
+   void NM_FOM_Routing_Space::serialize(MessageBuffer& msgBuffer) {
+      //Specific serialization code
+      msgBuffer.write_uint32(space);
+      msgBuffer.write_string(name);
+      uint32_t dimensionsSize = dimensions.size();
+      msgBuffer.write_uint32(dimensionsSize);
+      for (uint32_t i = 0; i < dimensionsSize; ++i) {
+         dimensions[i].serialize(msgBuffer);
+      }
+   }
+
+   void NM_FOM_Routing_Space::deserialize(MessageBuffer& msgBuffer) {
+      //Specific deserialization code
+      space = static_cast<SpaceHandle>(msgBuffer.read_uint32());
+      msgBuffer.read_string(name);
+      uint32_t dimensionsSize = msgBuffer.read_uint32();
+      dimensions.resize(dimensionsSize);
+      for (uint32_t i = 0; i < dimensionsSize; ++i) {
+         dimensions[i].deserialize(msgBuffer);
+      }
+   }
+
+   void NM_FOM_Routing_Space::show(std::ostream& out) {
+      out << "[NM_FOM_Routing_Space -Begin]" << std::endl;      //Specific show code
+      out << " space = " << space << " "       << std::endl;
+      out << " name = " << name << " "       << std::endl;
+      out << "    dimensions [] =" << std::endl;
+      for (uint32_t i = 0; i < getDimensionsSize(); ++i) {
+         out << "FIXME inherited " ;
+      }
+      out << std::endl;
+      out << "[NM_FOM_Routing_Space -End]" << std::endl;   }
+
+   NM_FOM_Attribute::NM_FOM_Attribute() {
+      handle=0;
+      //name= <no default value in message spec using builtin>
+      spaceHandle=0;
+      //order= <no default value in message spec using builtin>
+      //transport= <no default value in message spec using builtin>
+   }
+
+   NM_FOM_Attribute::~NM_FOM_Attribute() {
+   }
+
+   void NM_FOM_Attribute::serialize(MessageBuffer& msgBuffer) {
+      //Specific serialization code
+      msgBuffer.write_uint32(handle);
+      msgBuffer.write_string(name);
+      msgBuffer.write_uint32(spaceHandle);
+      msgBuffer.write_uint8(order);
+      msgBuffer.write_uint8(transport);
+   }
+
+   void NM_FOM_Attribute::deserialize(MessageBuffer& msgBuffer) {
+      //Specific deserialization code
+      handle = static_cast<AttributeHandle>(msgBuffer.read_uint32());
+      msgBuffer.read_string(name);
+      spaceHandle = static_cast<SpaceHandle>(msgBuffer.read_uint32());
+      order = static_cast<OrderType>(msgBuffer.read_uint8());
+      transport = static_cast<TransportType>(msgBuffer.read_uint8());
+   }
+
+   void NM_FOM_Attribute::show(std::ostream& out) {
+      out << "[NM_FOM_Attribute -Begin]" << std::endl;      //Specific show code
+      out << " handle = " << handle << " "       << std::endl;
+      out << " name = " << name << " "       << std::endl;
+      out << " spaceHandle = " << spaceHandle << " "       << std::endl;
+      out << " order = " << order << " "       << std::endl;
+      out << " transport = " << transport << " "       << std::endl;
+      out << "[NM_FOM_Attribute -End]" << std::endl;   }
+
+   NM_FOM_Object_Class::NM_FOM_Object_Class() {
+      handle=0;
+      superClass=0;
+      //name= <no default value in message spec using builtin>
+      //attributes= <no default value in message spec using builtin>
+   }
+
+   NM_FOM_Object_Class::~NM_FOM_Object_Class() {
+   }
+
+   void NM_FOM_Object_Class::serialize(MessageBuffer& msgBuffer) {
+      //Specific serialization code
+      msgBuffer.write_uint32(handle);
+      msgBuffer.write_uint32(superClass);
+      msgBuffer.write_string(name);
+      uint32_t attributesSize = attributes.size();
+      msgBuffer.write_uint32(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         attributes[i].serialize(msgBuffer);
+      }
+   }
+
+   void NM_FOM_Object_Class::deserialize(MessageBuffer& msgBuffer) {
+      //Specific deserialization code
+      handle = static_cast<ObjectClassHandle>(msgBuffer.read_uint32());
+      superClass = static_cast<ObjectClassHandle>(msgBuffer.read_uint32());
+      msgBuffer.read_string(name);
+      uint32_t attributesSize = msgBuffer.read_uint32();
+      attributes.resize(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         attributes[i].deserialize(msgBuffer);
+      }
+   }
+
+   void NM_FOM_Object_Class::show(std::ostream& out) {
+      out << "[NM_FOM_Object_Class -Begin]" << std::endl;      //Specific show code
+      out << " handle = " << handle << " "       << std::endl;
+      out << " superClass = " << superClass << " "       << std::endl;
+      out << " name = " << name << " "       << std::endl;
+      out << "    attributes [] =" << std::endl;
+      for (uint32_t i = 0; i < getAttributesSize(); ++i) {
+         out << "FIXME inherited " ;
+      }
+      out << std::endl;
+      out << "[NM_FOM_Object_Class -End]" << std::endl;   }
+
+   NM_FOM_Parameter::NM_FOM_Parameter() {
+      handle=0;
+      //name= <no default value in message spec using builtin>
+   }
+
+   NM_FOM_Parameter::~NM_FOM_Parameter() {
+   }
+
+   void NM_FOM_Parameter::serialize(MessageBuffer& msgBuffer) {
+      //Specific serialization code
+      msgBuffer.write_uint32(handle);
+      msgBuffer.write_string(name);
+   }
+
+   void NM_FOM_Parameter::deserialize(MessageBuffer& msgBuffer) {
+      //Specific deserialization code
+      handle = static_cast<ParameterHandle>(msgBuffer.read_uint32());
+      msgBuffer.read_string(name);
+   }
+
+   void NM_FOM_Parameter::show(std::ostream& out) {
+      out << "[NM_FOM_Parameter -Begin]" << std::endl;      //Specific show code
+      out << " handle = " << handle << " "       << std::endl;
+      out << " name = " << name << " "       << std::endl;
+      out << "[NM_FOM_Parameter -End]" << std::endl;   }
+
+   NM_FOM_Interaction_Class::NM_FOM_Interaction_Class() {
+      interactionClass=0;
+      //name= <no default value in message spec using builtin>
+      superClass=0;
+      space=0;
+      //order= <no default value in message spec using builtin>
+      //transport= <no default value in message spec using builtin>
+      //parameters= <no default value in message spec using builtin>
+   }
+
+   NM_FOM_Interaction_Class::~NM_FOM_Interaction_Class() {
+   }
+
+   void NM_FOM_Interaction_Class::serialize(MessageBuffer& msgBuffer) {
+      //Specific serialization code
+      msgBuffer.write_uint32(interactionClass);
+      msgBuffer.write_string(name);
+      msgBuffer.write_uint32(superClass);
+      msgBuffer.write_uint32(space);
+      msgBuffer.write_uint8(order);
+      msgBuffer.write_uint8(transport);
+      uint32_t parametersSize = parameters.size();
+      msgBuffer.write_uint32(parametersSize);
+      for (uint32_t i = 0; i < parametersSize; ++i) {
+         parameters[i].serialize(msgBuffer);
+      }
+   }
+
+   void NM_FOM_Interaction_Class::deserialize(MessageBuffer& msgBuffer) {
+      //Specific deserialization code
+      interactionClass = static_cast<InteractionClassHandle>(msgBuffer.read_uint32());
+      msgBuffer.read_string(name);
+      superClass = static_cast<InteractionClassHandle>(msgBuffer.read_uint32());
+      space = static_cast<SpaceHandle>(msgBuffer.read_uint32());
+      order = static_cast<OrderType>(msgBuffer.read_uint8());
+      transport = static_cast<TransportType>(msgBuffer.read_uint8());
+      uint32_t parametersSize = msgBuffer.read_uint32();
+      parameters.resize(parametersSize);
+      for (uint32_t i = 0; i < parametersSize; ++i) {
+         parameters[i].deserialize(msgBuffer);
+      }
+   }
+
+   void NM_FOM_Interaction_Class::show(std::ostream& out) {
+      out << "[NM_FOM_Interaction_Class -Begin]" << std::endl;      //Specific show code
+      out << " interactionClass = " << interactionClass << " "       << std::endl;
+      out << " name = " << name << " "       << std::endl;
+      out << " superClass = " << superClass << " "       << std::endl;
+      out << " space = " << space << " "       << std::endl;
+      out << " order = " << order << " "       << std::endl;
+      out << " transport = " << transport << " "       << std::endl;
+      out << "    parameters [] =" << std::endl;
+      for (uint32_t i = 0; i < getParametersSize(); ++i) {
+         out << "FIXME inherited " ;
+      }
+      out << std::endl;
+      out << "[NM_FOM_Interaction_Class -End]" << std::endl;   }
+
+   NM_Close_Connexion::NM_Close_Connexion() {
+      this->messageName = "NM_Close_Connexion";
+      this->type = NetworkMessage::CLOSE_CONNEXION;
+   }
+
+   NM_Close_Connexion::~NM_Close_Connexion() {
+   }
+
+   NM_Message_Null::NM_Message_Null() {
+      this->messageName = "NM_Message_Null";
+      this->type = NetworkMessage::MESSAGE_NULL;
+   }
+
+   NM_Message_Null::~NM_Message_Null() {
+   }
+
+   NM_Create_Federation_Execution::NM_Create_Federation_Execution() {
+      this->messageName = "NM_Create_Federation_Execution";
+      this->type = NetworkMessage::CREATE_FEDERATION_EXECUTION;
+      //federationName= <no default value in message spec using builtin>
+      //FEDid= <no default value in message spec using builtin>
+   }
+
+   NM_Create_Federation_Execution::~NM_Create_Federation_Execution() {
+   }
+
+   void NM_Create_Federation_Execution::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_string(federationName);
+      msgBuffer.write_string(FEDid);
+   }
+
+   void NM_Create_Federation_Execution::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      msgBuffer.read_string(federationName);
+      msgBuffer.read_string(FEDid);
+   }
+
+   void NM_Create_Federation_Execution::show(std::ostream& out) {
+      out << "[NM_Create_Federation_Execution -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " federationName = " << federationName << " "       << std::endl;
+      out << " FEDid = " << FEDid << " "       << std::endl;
+      out << "[NM_Create_Federation_Execution -End]" << std::endl;   }
+
+   NM_Destroy_Federation_Execution::NM_Destroy_Federation_Execution() {
+      this->messageName = "NM_Destroy_Federation_Execution";
+      this->type = NetworkMessage::DESTROY_FEDERATION_EXECUTION;
+      //federationName= <no default value in message spec using builtin>
+   }
+
+   NM_Destroy_Federation_Execution::~NM_Destroy_Federation_Execution() {
+   }
+
+   void NM_Destroy_Federation_Execution::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_string(federationName);
+   }
+
+   void NM_Destroy_Federation_Execution::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      msgBuffer.read_string(federationName);
+   }
+
+   void NM_Destroy_Federation_Execution::show(std::ostream& out) {
+      out << "[NM_Destroy_Federation_Execution -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " federationName = " << federationName << " "       << std::endl;
+      out << "[NM_Destroy_Federation_Execution -End]" << std::endl;   }
+
+   NM_Join_Federation_Execution::NM_Join_Federation_Execution() {
+      this->messageName = "NM_Join_Federation_Execution";
+      this->type = NetworkMessage::JOIN_FEDERATION_EXECUTION;
+      //numberOfRegulators= <no default value in message spec using builtin>
+      //multicastAddress= <no default value in message spec using builtin>
+      //bestEffortAddress= <no default value in message spec using builtin>
+      //bestEffortPeer= <no default value in message spec using builtin>
+      //federationName= <no default value in message spec using builtin>
+      //federateName= <no default value in message spec using builtin>
+      //routingSpaces= <no default value in message spec using builtin>
+      //objectClasses= <no default value in message spec using builtin>
+      //interactionClasses= <no default value in message spec using builtin>
+   }
+
+   NM_Join_Federation_Execution::~NM_Join_Federation_Execution() {
+   }
+
+   void NM_Join_Federation_Execution::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_int32(numberOfRegulators);
+      msgBuffer.write_uint32(multicastAddress);
+      msgBuffer.write_uint32(bestEffortAddress);
+      msgBuffer.write_uint32(bestEffortPeer);
+      msgBuffer.write_string(federationName);
+      msgBuffer.write_string(federateName);
+      uint32_t routingSpacesSize = routingSpaces.size();
+      msgBuffer.write_uint32(routingSpacesSize);
+      for (uint32_t i = 0; i < routingSpacesSize; ++i) {
+         routingSpaces[i].serialize(msgBuffer);
+      }
+      uint32_t objectClassesSize = objectClasses.size();
+      msgBuffer.write_uint32(objectClassesSize);
+      for (uint32_t i = 0; i < objectClassesSize; ++i) {
+         objectClasses[i].serialize(msgBuffer);
+      }
+      uint32_t interactionClassesSize = interactionClasses.size();
+      msgBuffer.write_uint32(interactionClassesSize);
+      for (uint32_t i = 0; i < interactionClassesSize; ++i) {
+         interactionClasses[i].serialize(msgBuffer);
+      }
+   }
+
+   void NM_Join_Federation_Execution::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      numberOfRegulators = msgBuffer.read_int32();
+      multicastAddress = msgBuffer.read_uint32();
+      bestEffortAddress = msgBuffer.read_uint32();
+      bestEffortPeer = msgBuffer.read_uint32();
+      msgBuffer.read_string(federationName);
+      msgBuffer.read_string(federateName);
+      uint32_t routingSpacesSize = msgBuffer.read_uint32();
+      routingSpaces.resize(routingSpacesSize);
+      for (uint32_t i = 0; i < routingSpacesSize; ++i) {
+         routingSpaces[i].deserialize(msgBuffer);
+      }
+      uint32_t objectClassesSize = msgBuffer.read_uint32();
+      objectClasses.resize(objectClassesSize);
+      for (uint32_t i = 0; i < objectClassesSize; ++i) {
+         objectClasses[i].deserialize(msgBuffer);
+      }
+      uint32_t interactionClassesSize = msgBuffer.read_uint32();
+      interactionClasses.resize(interactionClassesSize);
+      for (uint32_t i = 0; i < interactionClassesSize; ++i) {
+         interactionClasses[i].deserialize(msgBuffer);
+      }
+   }
+
+   void NM_Join_Federation_Execution::show(std::ostream& out) {
+      out << "[NM_Join_Federation_Execution -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " numberOfRegulators = " << numberOfRegulators << " "       << std::endl;
+      out << " multicastAddress = " << multicastAddress << " "       << std::endl;
+      out << " bestEffortAddress = " << bestEffortAddress << " "       << std::endl;
+      out << " bestEffortPeer = " << bestEffortPeer << " "       << std::endl;
+      out << " federationName = " << federationName << " "       << std::endl;
+      out << " federateName = " << federateName << " "       << std::endl;
+      out << "    routingSpaces [] =" << std::endl;
+      for (uint32_t i = 0; i < getRoutingSpacesSize(); ++i) {
+         out << "FIXME inherited " ;
+      }
+      out << std::endl;
+      out << "    objectClasses [] =" << std::endl;
+      for (uint32_t i = 0; i < getObjectClassesSize(); ++i) {
+         out << "FIXME inherited " ;
+      }
+      out << std::endl;
+      out << "    interactionClasses [] =" << std::endl;
+      for (uint32_t i = 0; i < getInteractionClassesSize(); ++i) {
+         out << "FIXME inherited " ;
+      }
+      out << std::endl;
+      out << "[NM_Join_Federation_Execution -End]" << std::endl;   }
+
+   NM_Resign_Federation_Execution::NM_Resign_Federation_Execution() {
+      this->messageName = "NM_Resign_Federation_Execution";
+      this->type = NetworkMessage::RESIGN_FEDERATION_EXECUTION;
+   }
+
+   NM_Resign_Federation_Execution::~NM_Resign_Federation_Execution() {
+   }
+
+   NM_Set_Time_Regulating::NM_Set_Time_Regulating() {
+      this->messageName = "NM_Set_Time_Regulating";
+      this->type = NetworkMessage::SET_TIME_REGULATING;
+      //regulator= <no default value in message spec using builtin>
+   }
+
+   NM_Set_Time_Regulating::~NM_Set_Time_Regulating() {
+   }
+
+   void NM_Set_Time_Regulating::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_bool(regulator);
+   }
+
+   void NM_Set_Time_Regulating::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      regulator = msgBuffer.read_bool();
+   }
+
+   void NM_Set_Time_Regulating::show(std::ostream& out) {
+      out << "[NM_Set_Time_Regulating -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " regulator = " << regulator << " "       << std::endl;
+      out << "[NM_Set_Time_Regulating -End]" << std::endl;   }
+
+   NM_Set_Time_Constrained::NM_Set_Time_Constrained() {
+      this->messageName = "NM_Set_Time_Constrained";
+      this->type = NetworkMessage::SET_TIME_CONSTRAINED;
+      //constrained= <no default value in message spec using builtin>
+   }
+
+   NM_Set_Time_Constrained::~NM_Set_Time_Constrained() {
+   }
+
+   void NM_Set_Time_Constrained::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_bool(constrained);
+   }
+
+   void NM_Set_Time_Constrained::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      constrained = msgBuffer.read_bool();
+   }
+
+   void NM_Set_Time_Constrained::show(std::ostream& out) {
+      out << "[NM_Set_Time_Constrained -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " constrained = " << constrained << " "       << std::endl;
+      out << "[NM_Set_Time_Constrained -End]" << std::endl;   }
+
+   NM_Time_Regulation_Enabled::NM_Time_Regulation_Enabled() {
+      this->messageName = "NM_Time_Regulation_Enabled";
+      this->type = NetworkMessage::TIME_REGULATION_ENABLED;
+   }
+
+   NM_Time_Regulation_Enabled::~NM_Time_Regulation_Enabled() {
+   }
+
+   NM_Time_Constrained_Enabled::NM_Time_Constrained_Enabled() {
+      this->messageName = "NM_Time_Constrained_Enabled";
+      this->type = NetworkMessage::TIME_CONSTRAINED_ENABLED;
+   }
+
+   NM_Time_Constrained_Enabled::~NM_Time_Constrained_Enabled() {
+   }
+
+   NM_Set_Class_Relevance_Advisory_Switch::NM_Set_Class_Relevance_Advisory_Switch() {
+      this->messageName = "NM_Set_Class_Relevance_Advisory_Switch";
+      this->type = NetworkMessage::SET_CLASS_RELEVANCE_ADVISORY_SWITCH;
+      //classRelevanceAdvisorySwitch= <no default value in message spec using builtin>
+   }
+
+   NM_Set_Class_Relevance_Advisory_Switch::~NM_Set_Class_Relevance_Advisory_Switch() {
+   }
+
+   void NM_Set_Class_Relevance_Advisory_Switch::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_bool(classRelevanceAdvisorySwitch);
+   }
+
+   void NM_Set_Class_Relevance_Advisory_Switch::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      classRelevanceAdvisorySwitch = msgBuffer.read_bool();
+   }
+
+   void NM_Set_Class_Relevance_Advisory_Switch::show(std::ostream& out) {
+      out << "[NM_Set_Class_Relevance_Advisory_Switch -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " classRelevanceAdvisorySwitch = " << classRelevanceAdvisorySwitch << " "       << std::endl;
+      out << "[NM_Set_Class_Relevance_Advisory_Switch -End]" << std::endl;   }
+
+   NM_Set_Interaction_Relevance_Advisory_Switch::NM_Set_Interaction_Relevance_Advisory_Switch() {
+      this->messageName = "NM_Set_Interaction_Relevance_Advisory_Switch";
+      this->type = NetworkMessage::SET_INTERACTION_RELEVANCE_ADVISORY_SWITCH;
+      //interactionRelevanceAdvisorySwitch= <no default value in message spec using builtin>
+   }
+
+   NM_Set_Interaction_Relevance_Advisory_Switch::~NM_Set_Interaction_Relevance_Advisory_Switch() {
+   }
+
+   void NM_Set_Interaction_Relevance_Advisory_Switch::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_bool(interactionRelevanceAdvisorySwitch);
+   }
+
+   void NM_Set_Interaction_Relevance_Advisory_Switch::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      interactionRelevanceAdvisorySwitch = msgBuffer.read_bool();
+   }
+
+   void NM_Set_Interaction_Relevance_Advisory_Switch::show(std::ostream& out) {
+      out << "[NM_Set_Interaction_Relevance_Advisory_Switch -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " interactionRelevanceAdvisorySwitch = " << interactionRelevanceAdvisorySwitch << " "       << std::endl;
+      out << "[NM_Set_Interaction_Relevance_Advisory_Switch -End]" << std::endl;   }
+
+   NM_Set_Attribute_Relevance_Advisory_Switch::NM_Set_Attribute_Relevance_Advisory_Switch() {
+      this->messageName = "NM_Set_Attribute_Relevance_Advisory_Switch";
+      this->type = NetworkMessage::SET_ATTRIBUTE_RELEVANCE_ADVISORY_SWITCH;
+      //attributeRelevanceAdvisorySwitch= <no default value in message spec using builtin>
+   }
+
+   NM_Set_Attribute_Relevance_Advisory_Switch::~NM_Set_Attribute_Relevance_Advisory_Switch() {
+   }
+
+   void NM_Set_Attribute_Relevance_Advisory_Switch::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_bool(attributeRelevanceAdvisorySwitch);
+   }
+
+   void NM_Set_Attribute_Relevance_Advisory_Switch::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      attributeRelevanceAdvisorySwitch = msgBuffer.read_bool();
+   }
+
+   void NM_Set_Attribute_Relevance_Advisory_Switch::show(std::ostream& out) {
+      out << "[NM_Set_Attribute_Relevance_Advisory_Switch -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " attributeRelevanceAdvisorySwitch = " << attributeRelevanceAdvisorySwitch << " "       << std::endl;
+      out << "[NM_Set_Attribute_Relevance_Advisory_Switch -End]" << std::endl;   }
+
+   NM_Set_Attribute_Scope_Advisory_Switch::NM_Set_Attribute_Scope_Advisory_Switch() {
+      this->messageName = "NM_Set_Attribute_Scope_Advisory_Switch";
+      this->type = NetworkMessage::SET_ATTRIBUTE_SCOPE_ADVISORY_SWITCH;
+      //attributeScopeAdvisorySwitch= <no default value in message spec using builtin>
+   }
+
+   NM_Set_Attribute_Scope_Advisory_Switch::~NM_Set_Attribute_Scope_Advisory_Switch() {
+   }
+
+   void NM_Set_Attribute_Scope_Advisory_Switch::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_bool(attributeScopeAdvisorySwitch);
+   }
+
+   void NM_Set_Attribute_Scope_Advisory_Switch::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      attributeScopeAdvisorySwitch = msgBuffer.read_bool();
+   }
+
+   void NM_Set_Attribute_Scope_Advisory_Switch::show(std::ostream& out) {
+      out << "[NM_Set_Attribute_Scope_Advisory_Switch -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " attributeScopeAdvisorySwitch = " << attributeScopeAdvisorySwitch << " "       << std::endl;
+      out << "[NM_Set_Attribute_Scope_Advisory_Switch -End]" << std::endl;   }
+
+   NM_Register_Federation_Synchronization_Point::NM_Register_Federation_Synchronization_Point() {
+      this->messageName = "NM_Register_Federation_Synchronization_Point";
+      this->type = NetworkMessage::REGISTER_FEDERATION_SYNCHRONIZATION_POINT;
+      //exists= <no default value in message spec using builtin>
+      //federates= <no default value in message spec using builtin>
+   }
+
+   NM_Register_Federation_Synchronization_Point::~NM_Register_Federation_Synchronization_Point() {
+   }
+
+   void NM_Register_Federation_Synchronization_Point::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_bool(exists);
+      uint32_t federatesSize = federates.size();
+      msgBuffer.write_uint32(federatesSize);
+      for (uint32_t i = 0; i < federatesSize; ++i) {
+         msgBuffer.write_uint32(federates[i]);
+      }
+   }
+
+   void NM_Register_Federation_Synchronization_Point::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      exists = msgBuffer.read_bool();
+      uint32_t federatesSize = msgBuffer.read_uint32();
+      federates.resize(federatesSize);
+      for (uint32_t i = 0; i < federatesSize; ++i) {
+         federates[i] = static_cast<FederateHandle>(msgBuffer.read_uint32());
+      }
+   }
+
+   void NM_Register_Federation_Synchronization_Point::show(std::ostream& out) {
+      out << "[NM_Register_Federation_Synchronization_Point -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " exists = " << exists << " "       << std::endl;
+      out << "    federates [] =" << std::endl;
+      for (uint32_t i = 0; i < getFederatesSize(); ++i) {
+         out << federates[i] << " " ;
+      }
+      out << std::endl;
+      out << "[NM_Register_Federation_Synchronization_Point -End]" << std::endl;   }
+
+   NM_Synchronization_Point_Registration_Succeeded::NM_Synchronization_Point_Registration_Succeeded() {
+      this->messageName = "NM_Synchronization_Point_Registration_Succeeded";
+      this->type = NetworkMessage::SYNCHRONIZATION_POINT_REGISTRATION_SUCCEEDED;
+   }
+
+   NM_Synchronization_Point_Registration_Succeeded::~NM_Synchronization_Point_Registration_Succeeded() {
+   }
+
+   NM_Announce_Synchronization_Point::NM_Announce_Synchronization_Point() {
+      this->messageName = "NM_Announce_Synchronization_Point";
+      this->type = NetworkMessage::ANNOUNCE_SYNCHRONIZATION_POINT;
+   }
+
+   NM_Announce_Synchronization_Point::~NM_Announce_Synchronization_Point() {
+   }
+
+   NM_Synchronization_Point_Achieved::NM_Synchronization_Point_Achieved() {
+      this->messageName = "NM_Synchronization_Point_Achieved";
+      this->type = NetworkMessage::SYNCHRONIZATION_POINT_ACHIEVED;
+   }
+
+   NM_Synchronization_Point_Achieved::~NM_Synchronization_Point_Achieved() {
+   }
+
+   NM_Federation_Synchronized::NM_Federation_Synchronized() {
+      this->messageName = "NM_Federation_Synchronized";
+      this->type = NetworkMessage::FEDERATION_SYNCHRONIZED;
+   }
+
+   NM_Federation_Synchronized::~NM_Federation_Synchronized() {
+   }
+
+   NM_Request_Federation_Save::NM_Request_Federation_Save() {
+      this->messageName = "NM_Request_Federation_Save";
+      this->type = NetworkMessage::REQUEST_FEDERATION_SAVE;
+   }
+
+   NM_Request_Federation_Save::~NM_Request_Federation_Save() {
+   }
+
+   NM_Federate_Save_Begun::NM_Federate_Save_Begun() {
+      this->messageName = "NM_Federate_Save_Begun";
+      this->type = NetworkMessage::FEDERATE_SAVE_BEGUN;
+   }
+
+   NM_Federate_Save_Begun::~NM_Federate_Save_Begun() {
+   }
+
+   NM_Federate_Save_Complete::NM_Federate_Save_Complete() {
+      this->messageName = "NM_Federate_Save_Complete";
+      this->type = NetworkMessage::FEDERATE_SAVE_COMPLETE;
+   }
+
+   NM_Federate_Save_Complete::~NM_Federate_Save_Complete() {
+   }
+
+   NM_Federate_Save_Not_Complete::NM_Federate_Save_Not_Complete() {
+      this->messageName = "NM_Federate_Save_Not_Complete";
+      this->type = NetworkMessage::FEDERATE_SAVE_NOT_COMPLETE;
+   }
+
+   NM_Federate_Save_Not_Complete::~NM_Federate_Save_Not_Complete() {
+   }
+
+   NM_Initiate_Federate_Save::NM_Initiate_Federate_Save() {
+      this->messageName = "NM_Initiate_Federate_Save";
+      this->type = NetworkMessage::INITIATE_FEDERATE_SAVE;
+   }
+
+   NM_Initiate_Federate_Save::~NM_Initiate_Federate_Save() {
+   }
+
+   NM_Federation_Saved::NM_Federation_Saved() {
+      this->messageName = "NM_Federation_Saved";
+      this->type = NetworkMessage::FEDERATION_SAVED;
+   }
+
+   NM_Federation_Saved::~NM_Federation_Saved() {
+   }
+
+   NM_Federation_Not_Saved::NM_Federation_Not_Saved() {
+      this->messageName = "NM_Federation_Not_Saved";
+      this->type = NetworkMessage::FEDERATION_NOT_SAVED;
+   }
+
+   NM_Federation_Not_Saved::~NM_Federation_Not_Saved() {
+   }
+
+   NM_Request_Federation_Restore::NM_Request_Federation_Restore() {
+      this->messageName = "NM_Request_Federation_Restore";
+      this->type = NetworkMessage::REQUEST_FEDERATION_RESTORE;
+   }
+
+   NM_Request_Federation_Restore::~NM_Request_Federation_Restore() {
+   }
+
+   NM_Federate_Restore_Complete::NM_Federate_Restore_Complete() {
+      this->messageName = "NM_Federate_Restore_Complete";
+      this->type = NetworkMessage::FEDERATE_RESTORE_COMPLETE;
+   }
+
+   NM_Federate_Restore_Complete::~NM_Federate_Restore_Complete() {
+   }
+
+   NM_Federate_Restore_Not_Complete::NM_Federate_Restore_Not_Complete() {
+      this->messageName = "NM_Federate_Restore_Not_Complete";
+      this->type = NetworkMessage::FEDERATE_RESTORE_NOT_COMPLETE;
+   }
+
+   NM_Federate_Restore_Not_Complete::~NM_Federate_Restore_Not_Complete() {
+   }
+
+   NM_Request_Federation_Restore_Succeeded::NM_Request_Federation_Restore_Succeeded() {
+      this->messageName = "NM_Request_Federation_Restore_Succeeded";
+      this->type = NetworkMessage::REQUEST_FEDERATION_RESTORE_SUCCEEDED;
+   }
+
+   NM_Request_Federation_Restore_Succeeded::~NM_Request_Federation_Restore_Succeeded() {
+   }
+
+   NM_Request_Federation_Restore_Failed::NM_Request_Federation_Restore_Failed() {
+      this->messageName = "NM_Request_Federation_Restore_Failed";
+      this->type = NetworkMessage::REQUEST_FEDERATION_RESTORE_FAILED;
+   }
+
+   NM_Request_Federation_Restore_Failed::~NM_Request_Federation_Restore_Failed() {
+   }
+
+   NM_Federation_Restore_Begun::NM_Federation_Restore_Begun() {
+      this->messageName = "NM_Federation_Restore_Begun";
+      this->type = NetworkMessage::FEDERATION_RESTORE_BEGUN;
+   }
+
+   NM_Federation_Restore_Begun::~NM_Federation_Restore_Begun() {
+   }
+
+   NM_Initiate_Federate_Restore::NM_Initiate_Federate_Restore() {
+      this->messageName = "NM_Initiate_Federate_Restore";
+      this->type = NetworkMessage::INITIATE_FEDERATE_RESTORE;
+   }
+
+   NM_Initiate_Federate_Restore::~NM_Initiate_Federate_Restore() {
+   }
+
+   NM_Federation_Restored::NM_Federation_Restored() {
+      this->messageName = "NM_Federation_Restored";
+      this->type = NetworkMessage::FEDERATION_RESTORED;
+   }
+
+   NM_Federation_Restored::~NM_Federation_Restored() {
+   }
+
+   NM_Federation_Not_Restored::NM_Federation_Not_Restored() {
+      this->messageName = "NM_Federation_Not_Restored";
+      this->type = NetworkMessage::FEDERATION_NOT_RESTORED;
+   }
+
+   NM_Federation_Not_Restored::~NM_Federation_Not_Restored() {
+   }
+
+   NM_Publish_Object_Class::NM_Publish_Object_Class() {
+      this->messageName = "NM_Publish_Object_Class";
+      this->type = NetworkMessage::PUBLISH_OBJECT_CLASS;
+      //objectClass= <no default value in message spec using builtin>
+      //attributes= <no default value in message spec using builtin>
+   }
+
+   NM_Publish_Object_Class::~NM_Publish_Object_Class() {
+   }
+
+   void NM_Publish_Object_Class::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(objectClass);
+      uint32_t attributesSize = attributes.size();
+      msgBuffer.write_uint32(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         msgBuffer.write_uint32(attributes[i]);
+      }
+   }
+
+   void NM_Publish_Object_Class::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      objectClass = static_cast<ObjectClassHandle>(msgBuffer.read_uint32());
+      uint32_t attributesSize = msgBuffer.read_uint32();
+      attributes.resize(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         attributes[i] = static_cast<AttributeHandle>(msgBuffer.read_uint32());
+      }
+   }
+
+   void NM_Publish_Object_Class::show(std::ostream& out) {
+      out << "[NM_Publish_Object_Class -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " objectClass = " << objectClass << " "       << std::endl;
+      out << "    attributes [] =" << std::endl;
+      for (uint32_t i = 0; i < getAttributesSize(); ++i) {
+         out << attributes[i] << " " ;
+      }
+      out << std::endl;
+      out << "[NM_Publish_Object_Class -End]" << std::endl;   }
+
+   NM_Unpublish_Object_Class::NM_Unpublish_Object_Class() {
+      this->messageName = "NM_Unpublish_Object_Class";
+      this->type = NetworkMessage::UNPUBLISH_OBJECT_CLASS;
+   }
+
+   NM_Unpublish_Object_Class::~NM_Unpublish_Object_Class() {
+   }
+
+   NM_Publish_Interaction_Class::NM_Publish_Interaction_Class() {
+      this->messageName = "NM_Publish_Interaction_Class";
+      this->type = NetworkMessage::PUBLISH_INTERACTION_CLASS;
+      //interactionClass= <no default value in message spec using builtin>
+   }
+
+   NM_Publish_Interaction_Class::~NM_Publish_Interaction_Class() {
+   }
+
+   void NM_Publish_Interaction_Class::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(interactionClass);
+   }
+
+   void NM_Publish_Interaction_Class::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      interactionClass = static_cast<InteractionClassHandle>(msgBuffer.read_uint32());
+   }
+
+   void NM_Publish_Interaction_Class::show(std::ostream& out) {
+      out << "[NM_Publish_Interaction_Class -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " interactionClass = " << interactionClass << " "       << std::endl;
+      out << "[NM_Publish_Interaction_Class -End]" << std::endl;   }
+
+   NM_Unpublish_Interaction_Class::NM_Unpublish_Interaction_Class() {
+      this->messageName = "NM_Unpublish_Interaction_Class";
+      this->type = NetworkMessage::UNPUBLISH_INTERACTION_CLASS;
+   }
+
+   NM_Unpublish_Interaction_Class::~NM_Unpublish_Interaction_Class() {
+   }
+
+   NM_Subscribe_Object_Class::NM_Subscribe_Object_Class() {
+      this->messageName = "NM_Subscribe_Object_Class";
+      this->type = NetworkMessage::SUBSCRIBE_OBJECT_CLASS;
+      //objectClass= <no default value in message spec using builtin>
+      //attributes= <no default value in message spec using builtin>
+   }
+
+   NM_Subscribe_Object_Class::~NM_Subscribe_Object_Class() {
+   }
+
+   void NM_Subscribe_Object_Class::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(objectClass);
+      uint32_t attributesSize = attributes.size();
+      msgBuffer.write_uint32(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         msgBuffer.write_uint32(attributes[i]);
+      }
+   }
+
+   void NM_Subscribe_Object_Class::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      objectClass = static_cast<ObjectClassHandle>(msgBuffer.read_uint32());
+      uint32_t attributesSize = msgBuffer.read_uint32();
+      attributes.resize(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         attributes[i] = static_cast<AttributeHandle>(msgBuffer.read_uint32());
+      }
+   }
+
+   void NM_Subscribe_Object_Class::show(std::ostream& out) {
+      out << "[NM_Subscribe_Object_Class -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " objectClass = " << objectClass << " "       << std::endl;
+      out << "    attributes [] =" << std::endl;
+      for (uint32_t i = 0; i < getAttributesSize(); ++i) {
+         out << attributes[i] << " " ;
+      }
+      out << std::endl;
+      out << "[NM_Subscribe_Object_Class -End]" << std::endl;   }
+
+   NM_Unsubscribe_Object_Class::NM_Unsubscribe_Object_Class() {
+      this->messageName = "NM_Unsubscribe_Object_Class";
+      this->type = NetworkMessage::UNSUBSCRIBE_OBJECT_CLASS;
+   }
+
+   NM_Unsubscribe_Object_Class::~NM_Unsubscribe_Object_Class() {
+   }
+
+   NM_Subscribe_Interaction_Class::NM_Subscribe_Interaction_Class() {
+      this->messageName = "NM_Subscribe_Interaction_Class";
+      this->type = NetworkMessage::SUBSCRIBE_INTERACTION_CLASS;
+   }
+
+   NM_Subscribe_Interaction_Class::~NM_Subscribe_Interaction_Class() {
+   }
+
+   NM_Unsubscribe_Interaction_Class::NM_Unsubscribe_Interaction_Class() {
+      this->messageName = "NM_Unsubscribe_Interaction_Class";
+      this->type = NetworkMessage::UNSUBSCRIBE_INTERACTION_CLASS;
+   }
+
+   NM_Unsubscribe_Interaction_Class::~NM_Unsubscribe_Interaction_Class() {
+   }
+
+   NM_Turn_Interactions_On::NM_Turn_Interactions_On() {
+      this->messageName = "NM_Turn_Interactions_On";
+      this->type = NetworkMessage::TURN_INTERACTIONS_ON;
+   }
+
+   NM_Turn_Interactions_On::~NM_Turn_Interactions_On() {
+   }
+
+   NM_Turn_Interactions_Off::NM_Turn_Interactions_Off() {
+      this->messageName = "NM_Turn_Interactions_Off";
+      this->type = NetworkMessage::TURN_INTERACTIONS_OFF;
+   }
+
+   NM_Turn_Interactions_Off::~NM_Turn_Interactions_Off() {
+   }
+
+   NM_Register_Object::NM_Register_Object() {
+      this->messageName = "NM_Register_Object";
+      this->type = NetworkMessage::REGISTER_OBJECT;
+      //objectClass= <no default value in message spec using builtin>
+      //objectName= <no default value in message spec using builtin>
+      //object= <no default value in message spec using builtin>
+   }
+
+   NM_Register_Object::~NM_Register_Object() {
+   }
+
+   void NM_Register_Object::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(objectClass);
+      msgBuffer.write_bool(hasObjectName);
+      if (hasObjectName) {
+         msgBuffer.write_string(objectName);
+      }
+      msgBuffer.write_uint32(object);
+   }
+
+   void NM_Register_Object::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      objectClass = static_cast<ObjectClassHandle>(msgBuffer.read_uint32());
+      hasObjectName = msgBuffer.read_bool();
+      if (hasObjectName) {
+         msgBuffer.read_string(objectName);
+      }
+      object = static_cast<ObjectHandle>(msgBuffer.read_uint32());
+   }
+
+   void NM_Register_Object::show(std::ostream& out) {
+      out << "[NM_Register_Object -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " objectClass = " << objectClass << " "       << std::endl;
+      out << "(opt) objectName =" << objectName << " "       << std::endl;
+      out << " object = " << object << " "       << std::endl;
+      out << "[NM_Register_Object -End]" << std::endl;   }
+
+   NM_Discover_Object::NM_Discover_Object() {
+      this->messageName = "NM_Discover_Object";
+      this->type = NetworkMessage::DISCOVER_OBJECT;
+      //objectClass= <no default value in message spec using builtin>
+      //object= <no default value in message spec using builtin>
+   }
+
+   NM_Discover_Object::~NM_Discover_Object() {
+   }
+
+   void NM_Discover_Object::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(objectClass);
+      msgBuffer.write_uint32(object);
+   }
+
+   void NM_Discover_Object::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      objectClass = static_cast<ObjectClassHandle>(msgBuffer.read_uint32());
+      object = static_cast<ObjectHandle>(msgBuffer.read_uint32());
+   }
+
+   void NM_Discover_Object::show(std::ostream& out) {
+      out << "[NM_Discover_Object -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " objectClass = " << objectClass << " "       << std::endl;
+      out << " object = " << object << " "       << std::endl;
+      out << "[NM_Discover_Object -End]" << std::endl;   }
+
+   NM_Update_Attribute_Values::NM_Update_Attribute_Values() {
+      this->messageName = "NM_Update_Attribute_Values";
+      this->type = NetworkMessage::UPDATE_ATTRIBUTE_VALUES;
+      //object= <no default value in message spec using builtin>
+      //attributes= <no default value in message spec using builtin>
+      //values= <no default value in message spec using builtin>
+      //event= <no default value in message spec using builtin>
+   }
+
+   NM_Update_Attribute_Values::~NM_Update_Attribute_Values() {
+   }
+
+   void NM_Update_Attribute_Values::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(object);
+      uint32_t attributesSize = attributes.size();
+      msgBuffer.write_uint32(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         msgBuffer.write_uint32(attributes[i]);
+      }
+      uint32_t valuesSize = values.size();
+      msgBuffer.write_uint32(valuesSize);
+      for (uint32_t i = 0; i < valuesSize; ++i) {
+         msgBuffer.write_string(values[i]);
+      }
+      msgBuffer.write_bool(hasEvent);
+      if (hasEvent) {
+         // FIXME FIXME FIXME
+         // don't know how to serialize native field <event> of type <EventRetractionHandle>
+      }
+   }
+
+   void NM_Update_Attribute_Values::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      object = static_cast<ObjectHandle>(msgBuffer.read_uint32());
+      uint32_t attributesSize = msgBuffer.read_uint32();
+      attributes.resize(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         attributes[i] = static_cast<AttributeHandle>(msgBuffer.read_uint32());
+      }
+      uint32_t valuesSize = msgBuffer.read_uint32();
+      values.resize(valuesSize);
+      for (uint32_t i = 0; i < valuesSize; ++i) {
+         msgBuffer.read_string(values[i]);
+      }
+      hasEvent = msgBuffer.read_bool();
+      if (hasEvent) {
+         // FIXME FIXME FIXME
+         // don't know how to deserialize native field <event> of type <EventRetractionHandle>
+      }
+   }
+
+   void NM_Update_Attribute_Values::show(std::ostream& out) {
+      out << "[NM_Update_Attribute_Values -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " object = " << object << " "       << std::endl;
+      out << "    attributes [] =" << std::endl;
+      for (uint32_t i = 0; i < getAttributesSize(); ++i) {
+         out << attributes[i] << " " ;
+      }
+      out << std::endl;
+      out << "    values [] =" << std::endl;
+      for (uint32_t i = 0; i < getValuesSize(); ++i) {
+         out << values[i] << " " ;
+      }
+      out << std::endl;
+      out << "(opt) event =" << "      //FIXME FIXME don't know how to serialize native field <event> of type <EventRetractionHandle>"      << std::endl;
+      out << "[NM_Update_Attribute_Values -End]" << std::endl;   }
+
+   NM_Reflect_Attribute_Values::NM_Reflect_Attribute_Values() {
+      this->messageName = "NM_Reflect_Attribute_Values";
+      this->type = NetworkMessage::REFLECT_ATTRIBUTE_VALUES;
+      //object= <no default value in message spec using builtin>
+      //attributes= <no default value in message spec using builtin>
+      //values= <no default value in message spec using builtin>
+      //event= <no default value in message spec using builtin>
+   }
+
+   NM_Reflect_Attribute_Values::~NM_Reflect_Attribute_Values() {
+   }
+
+   void NM_Reflect_Attribute_Values::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(object);
+      uint32_t attributesSize = attributes.size();
+      msgBuffer.write_uint32(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         msgBuffer.write_uint32(attributes[i]);
+      }
+      uint32_t valuesSize = values.size();
+      msgBuffer.write_uint32(valuesSize);
+      for (uint32_t i = 0; i < valuesSize; ++i) {
+         msgBuffer.write_string(values[i]);
+      }
+      msgBuffer.write_bool(hasEvent);
+      if (hasEvent) {
+         // FIXME FIXME FIXME
+         // don't know how to serialize native field <event> of type <EventRetractionHandle>
+      }
+   }
+
+   void NM_Reflect_Attribute_Values::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      object = static_cast<ObjectHandle>(msgBuffer.read_uint32());
+      uint32_t attributesSize = msgBuffer.read_uint32();
+      attributes.resize(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         attributes[i] = static_cast<AttributeHandle>(msgBuffer.read_uint32());
+      }
+      uint32_t valuesSize = msgBuffer.read_uint32();
+      values.resize(valuesSize);
+      for (uint32_t i = 0; i < valuesSize; ++i) {
+         msgBuffer.read_string(values[i]);
+      }
+      hasEvent = msgBuffer.read_bool();
+      if (hasEvent) {
+         // FIXME FIXME FIXME
+         // don't know how to deserialize native field <event> of type <EventRetractionHandle>
+      }
+   }
+
+   void NM_Reflect_Attribute_Values::show(std::ostream& out) {
+      out << "[NM_Reflect_Attribute_Values -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " object = " << object << " "       << std::endl;
+      out << "    attributes [] =" << std::endl;
+      for (uint32_t i = 0; i < getAttributesSize(); ++i) {
+         out << attributes[i] << " " ;
+      }
+      out << std::endl;
+      out << "    values [] =" << std::endl;
+      for (uint32_t i = 0; i < getValuesSize(); ++i) {
+         out << values[i] << " " ;
+      }
+      out << std::endl;
+      out << "(opt) event =" << "      //FIXME FIXME don't know how to serialize native field <event> of type <EventRetractionHandle>"      << std::endl;
+      out << "[NM_Reflect_Attribute_Values -End]" << std::endl;   }
+
+   NM_Send_Interaction::NM_Send_Interaction() {
+      this->messageName = "NM_Send_Interaction";
+      this->type = NetworkMessage::SEND_INTERACTION;
+      //interactionClass= <no default value in message spec using builtin>
+      //parameters= <no default value in message spec using builtin>
+      //values= <no default value in message spec using builtin>
+      //region= <no default value in message spec using builtin>
+   }
+
+   NM_Send_Interaction::~NM_Send_Interaction() {
+   }
+
+   void NM_Send_Interaction::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(interactionClass);
+      uint32_t parametersSize = parameters.size();
+      msgBuffer.write_uint32(parametersSize);
+      for (uint32_t i = 0; i < parametersSize; ++i) {
+         msgBuffer.write_uint32(parameters[i]);
+      }
+      uint32_t valuesSize = values.size();
+      msgBuffer.write_uint32(valuesSize);
+      for (uint32_t i = 0; i < valuesSize; ++i) {
+         msgBuffer.write_string(values[i]);
+      }
+      msgBuffer.write_uint32(region);
+   }
+
+   void NM_Send_Interaction::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      interactionClass = static_cast<InteractionClassHandle>(msgBuffer.read_uint32());
+      uint32_t parametersSize = msgBuffer.read_uint32();
+      parameters.resize(parametersSize);
+      for (uint32_t i = 0; i < parametersSize; ++i) {
+         parameters[i] = static_cast<ParameterHandle>(msgBuffer.read_uint32());
+      }
+      uint32_t valuesSize = msgBuffer.read_uint32();
+      values.resize(valuesSize);
+      for (uint32_t i = 0; i < valuesSize; ++i) {
+         msgBuffer.read_string(values[i]);
+      }
+      region = static_cast<RegionHandle>(msgBuffer.read_uint32());
+   }
+
+   void NM_Send_Interaction::show(std::ostream& out) {
+      out << "[NM_Send_Interaction -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " interactionClass = " << interactionClass << " "       << std::endl;
+      out << "    parameters [] =" << std::endl;
+      for (uint32_t i = 0; i < getParametersSize(); ++i) {
+         out << parameters[i] << " " ;
+      }
+      out << std::endl;
+      out << "    values [] =" << std::endl;
+      for (uint32_t i = 0; i < getValuesSize(); ++i) {
+         out << values[i] << " " ;
+      }
+      out << std::endl;
+      out << " region = " << region << " "       << std::endl;
+      out << "[NM_Send_Interaction -End]" << std::endl;   }
+
+   NM_Receive_Interaction::NM_Receive_Interaction() {
+      this->messageName = "NM_Receive_Interaction";
+      this->type = NetworkMessage::RECEIVE_INTERACTION;
+      //interactionClass= <no default value in message spec using builtin>
+      //parameters= <no default value in message spec using builtin>
+      //values= <no default value in message spec using builtin>
+      //event= <no default value in message spec using builtin>
+   }
+
+   NM_Receive_Interaction::~NM_Receive_Interaction() {
+   }
+
+   void NM_Receive_Interaction::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(interactionClass);
+      uint32_t parametersSize = parameters.size();
+      msgBuffer.write_uint32(parametersSize);
+      for (uint32_t i = 0; i < parametersSize; ++i) {
+         msgBuffer.write_uint32(parameters[i]);
+      }
+      uint32_t valuesSize = values.size();
+      msgBuffer.write_uint32(valuesSize);
+      for (uint32_t i = 0; i < valuesSize; ++i) {
+         msgBuffer.write_string(values[i]);
+      }
+      msgBuffer.write_bool(hasEvent);
+      if (hasEvent) {
+         // FIXME FIXME FIXME
+         // don't know how to serialize native field <event> of type <EventRetractionHandle>
+      }
+   }
+
+   void NM_Receive_Interaction::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      interactionClass = static_cast<InteractionClassHandle>(msgBuffer.read_uint32());
+      uint32_t parametersSize = msgBuffer.read_uint32();
+      parameters.resize(parametersSize);
+      for (uint32_t i = 0; i < parametersSize; ++i) {
+         parameters[i] = static_cast<ParameterHandle>(msgBuffer.read_uint32());
+      }
+      uint32_t valuesSize = msgBuffer.read_uint32();
+      values.resize(valuesSize);
+      for (uint32_t i = 0; i < valuesSize; ++i) {
+         msgBuffer.read_string(values[i]);
+      }
+      hasEvent = msgBuffer.read_bool();
+      if (hasEvent) {
+         // FIXME FIXME FIXME
+         // don't know how to deserialize native field <event> of type <EventRetractionHandle>
+      }
+   }
+
+   void NM_Receive_Interaction::show(std::ostream& out) {
+      out << "[NM_Receive_Interaction -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " interactionClass = " << interactionClass << " "       << std::endl;
+      out << "    parameters [] =" << std::endl;
+      for (uint32_t i = 0; i < getParametersSize(); ++i) {
+         out << parameters[i] << " " ;
+      }
+      out << std::endl;
+      out << "    values [] =" << std::endl;
+      for (uint32_t i = 0; i < getValuesSize(); ++i) {
+         out << values[i] << " " ;
+      }
+      out << std::endl;
+      out << "(opt) event =" << "      //FIXME FIXME don't know how to serialize native field <event> of type <EventRetractionHandle>"      << std::endl;
+      out << "[NM_Receive_Interaction -End]" << std::endl;   }
+
+   NM_Delete_Object::NM_Delete_Object() {
+      this->messageName = "NM_Delete_Object";
+      this->type = NetworkMessage::DELETE_OBJECT;
+      //object= <no default value in message spec using builtin>
+      //event= <no default value in message spec using builtin>
+   }
+
+   NM_Delete_Object::~NM_Delete_Object() {
+   }
+
+   void NM_Delete_Object::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(object);
+      msgBuffer.write_bool(hasEvent);
+      if (hasEvent) {
+         // FIXME FIXME FIXME
+         // don't know how to serialize native field <event> of type <EventRetractionHandle>
+      }
+   }
+
+   void NM_Delete_Object::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      object = static_cast<ObjectHandle>(msgBuffer.read_uint32());
+      hasEvent = msgBuffer.read_bool();
+      if (hasEvent) {
+         // FIXME FIXME FIXME
+         // don't know how to deserialize native field <event> of type <EventRetractionHandle>
+      }
+   }
+
+   void NM_Delete_Object::show(std::ostream& out) {
+      out << "[NM_Delete_Object -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " object = " << object << " "       << std::endl;
+      out << "(opt) event =" << "      //FIXME FIXME don't know how to serialize native field <event> of type <EventRetractionHandle>"      << std::endl;
+      out << "[NM_Delete_Object -End]" << std::endl;   }
+
+   NM_Remove_Object::NM_Remove_Object() {
+      this->messageName = "NM_Remove_Object";
+      this->type = NetworkMessage::REMOVE_OBJECT;
+      //object= <no default value in message spec using builtin>
+      //objectClass= <no default value in message spec using builtin>
+      //event= <no default value in message spec using builtin>
+   }
+
+   NM_Remove_Object::~NM_Remove_Object() {
+   }
+
+   void NM_Remove_Object::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(object);
+      msgBuffer.write_uint32(objectClass);
+      msgBuffer.write_bool(hasEvent);
+      if (hasEvent) {
+         // FIXME FIXME FIXME
+         // don't know how to serialize native field <event> of type <EventRetractionHandle>
+      }
+   }
+
+   void NM_Remove_Object::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      object = static_cast<ObjectHandle>(msgBuffer.read_uint32());
+      objectClass = static_cast<ObjectClassHandle>(msgBuffer.read_uint32());
+      hasEvent = msgBuffer.read_bool();
+      if (hasEvent) {
+         // FIXME FIXME FIXME
+         // don't know how to deserialize native field <event> of type <EventRetractionHandle>
+      }
+   }
+
+   void NM_Remove_Object::show(std::ostream& out) {
+      out << "[NM_Remove_Object -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " object = " << object << " "       << std::endl;
+      out << " objectClass = " << objectClass << " "       << std::endl;
+      out << "(opt) event =" << "      //FIXME FIXME don't know how to serialize native field <event> of type <EventRetractionHandle>"      << std::endl;
+      out << "[NM_Remove_Object -End]" << std::endl;   }
+
+   NM_Change_Attribute_Transport_Type::NM_Change_Attribute_Transport_Type() {
+      this->messageName = "NM_Change_Attribute_Transport_Type";
+      this->type = NetworkMessage::CHANGE_ATTRIBUTE_TRANSPORT_TYPE;
+      //object= <no default value in message spec using builtin>
+      //attributes= <no default value in message spec using builtin>
+      //transport= <no default value in message spec using builtin>
+   }
+
+   NM_Change_Attribute_Transport_Type::~NM_Change_Attribute_Transport_Type() {
+   }
+
+   void NM_Change_Attribute_Transport_Type::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(object);
+      uint32_t attributesSize = attributes.size();
+      msgBuffer.write_uint32(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         msgBuffer.write_uint32(attributes[i]);
+      }
+      msgBuffer.write_uint8(transport);
+   }
+
+   void NM_Change_Attribute_Transport_Type::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      object = static_cast<ObjectHandle>(msgBuffer.read_uint32());
+      uint32_t attributesSize = msgBuffer.read_uint32();
+      attributes.resize(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         attributes[i] = static_cast<AttributeHandle>(msgBuffer.read_uint32());
+      }
+      transport = static_cast<TransportType>(msgBuffer.read_uint8());
+   }
+
+   void NM_Change_Attribute_Transport_Type::show(std::ostream& out) {
+      out << "[NM_Change_Attribute_Transport_Type -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " object = " << object << " "       << std::endl;
+      out << "    attributes [] =" << std::endl;
+      for (uint32_t i = 0; i < getAttributesSize(); ++i) {
+         out << attributes[i] << " " ;
+      }
+      out << std::endl;
+      out << " transport = " << transport << " "       << std::endl;
+      out << "[NM_Change_Attribute_Transport_Type -End]" << std::endl;   }
+
+   NM_Change_Attribute_Order_Type::NM_Change_Attribute_Order_Type() {
+      this->messageName = "NM_Change_Attribute_Order_Type";
+      this->type = NetworkMessage::CHANGE_ATTRIBUTE_ORDER_TYPE;
+      //object= <no default value in message spec using builtin>
+      //attributes= <no default value in message spec using builtin>
+      //order= <no default value in message spec using builtin>
+   }
+
+   NM_Change_Attribute_Order_Type::~NM_Change_Attribute_Order_Type() {
+   }
+
+   void NM_Change_Attribute_Order_Type::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(object);
+      uint32_t attributesSize = attributes.size();
+      msgBuffer.write_uint32(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         msgBuffer.write_uint32(attributes[i]);
+      }
+      msgBuffer.write_uint8(order);
+   }
+
+   void NM_Change_Attribute_Order_Type::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      object = static_cast<ObjectHandle>(msgBuffer.read_uint32());
+      uint32_t attributesSize = msgBuffer.read_uint32();
+      attributes.resize(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         attributes[i] = static_cast<AttributeHandle>(msgBuffer.read_uint32());
+      }
+      order = static_cast<OrderType>(msgBuffer.read_uint8());
+   }
+
+   void NM_Change_Attribute_Order_Type::show(std::ostream& out) {
+      out << "[NM_Change_Attribute_Order_Type -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " object = " << object << " "       << std::endl;
+      out << "    attributes [] =" << std::endl;
+      for (uint32_t i = 0; i < getAttributesSize(); ++i) {
+         out << attributes[i] << " " ;
+      }
+      out << std::endl;
+      out << " order = " << order << " "       << std::endl;
+      out << "[NM_Change_Attribute_Order_Type -End]" << std::endl;   }
+
+   NM_Change_Interaction_Transport_Type::NM_Change_Interaction_Transport_Type() {
+      this->messageName = "NM_Change_Interaction_Transport_Type";
+      this->type = NetworkMessage::CHANGE_INTERACTION_TRANSPORT_TYPE;
+      //interactionClass= <no default value in message spec using builtin>
+      //transport= <no default value in message spec using builtin>
+   }
+
+   NM_Change_Interaction_Transport_Type::~NM_Change_Interaction_Transport_Type() {
+   }
+
+   void NM_Change_Interaction_Transport_Type::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(interactionClass);
+      msgBuffer.write_uint8(transport);
+   }
+
+   void NM_Change_Interaction_Transport_Type::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      interactionClass = static_cast<InteractionClassHandle>(msgBuffer.read_uint32());
+      transport = static_cast<TransportType>(msgBuffer.read_uint8());
+   }
+
+   void NM_Change_Interaction_Transport_Type::show(std::ostream& out) {
+      out << "[NM_Change_Interaction_Transport_Type -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " interactionClass = " << interactionClass << " "       << std::endl;
+      out << " transport = " << transport << " "       << std::endl;
+      out << "[NM_Change_Interaction_Transport_Type -End]" << std::endl;   }
+
+   NM_Change_Interaction_Order_Type::NM_Change_Interaction_Order_Type() {
+      this->messageName = "NM_Change_Interaction_Order_Type";
+      this->type = NetworkMessage::CHANGE_INTERACTION_ORDER_TYPE;
+      //interactionClass= <no default value in message spec using builtin>
+      //order= <no default value in message spec using builtin>
+   }
+
+   NM_Change_Interaction_Order_Type::~NM_Change_Interaction_Order_Type() {
+   }
+
+   void NM_Change_Interaction_Order_Type::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(interactionClass);
+      msgBuffer.write_uint8(order);
+   }
+
+   void NM_Change_Interaction_Order_Type::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      interactionClass = static_cast<InteractionClassHandle>(msgBuffer.read_uint32());
+      order = static_cast<OrderType>(msgBuffer.read_uint8());
+   }
+
+   void NM_Change_Interaction_Order_Type::show(std::ostream& out) {
+      out << "[NM_Change_Interaction_Order_Type -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " interactionClass = " << interactionClass << " "       << std::endl;
+      out << " order = " << order << " "       << std::endl;
+      out << "[NM_Change_Interaction_Order_Type -End]" << std::endl;   }
+
+   NM_Request_Class_Attribute_Value_Update::NM_Request_Class_Attribute_Value_Update() {
+      this->messageName = "NM_Request_Class_Attribute_Value_Update";
+      this->type = NetworkMessage::REQUEST_CLASS_ATTRIBUTE_VALUE_UPDATE;
+      //objectClass= <no default value in message spec using builtin>
+      //attributes= <no default value in message spec using builtin>
+   }
+
+   NM_Request_Class_Attribute_Value_Update::~NM_Request_Class_Attribute_Value_Update() {
+   }
+
+   void NM_Request_Class_Attribute_Value_Update::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(objectClass);
+      uint32_t attributesSize = attributes.size();
+      msgBuffer.write_uint32(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         msgBuffer.write_uint32(attributes[i]);
+      }
+   }
+
+   void NM_Request_Class_Attribute_Value_Update::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      objectClass = static_cast<ObjectClassHandle>(msgBuffer.read_uint32());
+      uint32_t attributesSize = msgBuffer.read_uint32();
+      attributes.resize(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         attributes[i] = static_cast<AttributeHandle>(msgBuffer.read_uint32());
+      }
+   }
+
+   void NM_Request_Class_Attribute_Value_Update::show(std::ostream& out) {
+      out << "[NM_Request_Class_Attribute_Value_Update -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " objectClass = " << objectClass << " "       << std::endl;
+      out << "    attributes [] =" << std::endl;
+      for (uint32_t i = 0; i < getAttributesSize(); ++i) {
+         out << attributes[i] << " " ;
+      }
+      out << std::endl;
+      out << "[NM_Request_Class_Attribute_Value_Update -End]" << std::endl;   }
+
+   NM_Request_Object_Attribute_Value_Update::NM_Request_Object_Attribute_Value_Update() {
+      this->messageName = "NM_Request_Object_Attribute_Value_Update";
+      this->type = NetworkMessage::REQUEST_OBJECT_ATTRIBUTE_VALUE_UPDATE;
+      //object= <no default value in message spec using builtin>
+      //attributes= <no default value in message spec using builtin>
+   }
+
+   NM_Request_Object_Attribute_Value_Update::~NM_Request_Object_Attribute_Value_Update() {
+   }
+
+   void NM_Request_Object_Attribute_Value_Update::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(object);
+      uint32_t attributesSize = attributes.size();
+      msgBuffer.write_uint32(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         msgBuffer.write_uint32(attributes[i]);
+      }
+   }
+
+   void NM_Request_Object_Attribute_Value_Update::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      object = static_cast<ObjectHandle>(msgBuffer.read_uint32());
+      uint32_t attributesSize = msgBuffer.read_uint32();
+      attributes.resize(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         attributes[i] = static_cast<AttributeHandle>(msgBuffer.read_uint32());
+      }
+   }
+
+   void NM_Request_Object_Attribute_Value_Update::show(std::ostream& out) {
+      out << "[NM_Request_Object_Attribute_Value_Update -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " object = " << object << " "       << std::endl;
+      out << "    attributes [] =" << std::endl;
+      for (uint32_t i = 0; i < getAttributesSize(); ++i) {
+         out << attributes[i] << " " ;
+      }
+      out << std::endl;
+      out << "[NM_Request_Object_Attribute_Value_Update -End]" << std::endl;   }
+
+   NM_Is_Attribute_Owned_By_Federate::NM_Is_Attribute_Owned_By_Federate() {
+      this->messageName = "NM_Is_Attribute_Owned_By_Federate";
+      this->type = NetworkMessage::IS_ATTRIBUTE_OWNED_BY_FEDERATE;
+      //object= <no default value in message spec using builtin>
+      //attribute= <no default value in message spec using builtin>
+   }
+
+   NM_Is_Attribute_Owned_By_Federate::~NM_Is_Attribute_Owned_By_Federate() {
+   }
+
+   void NM_Is_Attribute_Owned_By_Federate::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(object);
+      msgBuffer.write_uint32(attribute);
+   }
+
+   void NM_Is_Attribute_Owned_By_Federate::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      object = static_cast<ObjectHandle>(msgBuffer.read_uint32());
+      attribute = static_cast<AttributeHandle>(msgBuffer.read_uint32());
+   }
+
+   void NM_Is_Attribute_Owned_By_Federate::show(std::ostream& out) {
+      out << "[NM_Is_Attribute_Owned_By_Federate -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " object = " << object << " "       << std::endl;
+      out << " attribute = " << attribute << " "       << std::endl;
+      out << "[NM_Is_Attribute_Owned_By_Federate -End]" << std::endl;   }
+
+   NM_Query_Attribute_Ownership::NM_Query_Attribute_Ownership() {
+      this->messageName = "NM_Query_Attribute_Ownership";
+      this->type = NetworkMessage::QUERY_ATTRIBUTE_OWNERSHIP;
+      //object= <no default value in message spec using builtin>
+      //attribute= <no default value in message spec using builtin>
+   }
+
+   NM_Query_Attribute_Ownership::~NM_Query_Attribute_Ownership() {
+   }
+
+   void NM_Query_Attribute_Ownership::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(object);
+      msgBuffer.write_uint32(attribute);
+   }
+
+   void NM_Query_Attribute_Ownership::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      object = static_cast<ObjectHandle>(msgBuffer.read_uint32());
+      attribute = static_cast<AttributeHandle>(msgBuffer.read_uint32());
+   }
+
+   void NM_Query_Attribute_Ownership::show(std::ostream& out) {
+      out << "[NM_Query_Attribute_Ownership -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " object = " << object << " "       << std::endl;
+      out << " attribute = " << attribute << " "       << std::endl;
+      out << "[NM_Query_Attribute_Ownership -End]" << std::endl;   }
+
+   NM_Attribute_Is_Not_Owned::NM_Attribute_Is_Not_Owned() {
+      this->messageName = "NM_Attribute_Is_Not_Owned";
+      this->type = NetworkMessage::ATTRIBUTE_IS_NOT_OWNED;
+      //object= <no default value in message spec using builtin>
+      //attribute= <no default value in message spec using builtin>
+   }
+
+   NM_Attribute_Is_Not_Owned::~NM_Attribute_Is_Not_Owned() {
+   }
+
+   void NM_Attribute_Is_Not_Owned::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(object);
+      msgBuffer.write_uint32(attribute);
+   }
+
+   void NM_Attribute_Is_Not_Owned::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      object = static_cast<ObjectHandle>(msgBuffer.read_uint32());
+      attribute = static_cast<AttributeHandle>(msgBuffer.read_uint32());
+   }
+
+   void NM_Attribute_Is_Not_Owned::show(std::ostream& out) {
+      out << "[NM_Attribute_Is_Not_Owned -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " object = " << object << " "       << std::endl;
+      out << " attribute = " << attribute << " "       << std::endl;
+      out << "[NM_Attribute_Is_Not_Owned -End]" << std::endl;   }
+
+   NM_Inform_Attribute_Ownership::NM_Inform_Attribute_Ownership() {
+      this->messageName = "NM_Inform_Attribute_Ownership";
+      this->type = NetworkMessage::INFORM_ATTRIBUTE_OWNERSHIP;
+      //object= <no default value in message spec using builtin>
+      //attribute= <no default value in message spec using builtin>
+   }
+
+   NM_Inform_Attribute_Ownership::~NM_Inform_Attribute_Ownership() {
+   }
+
+   void NM_Inform_Attribute_Ownership::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(object);
+      msgBuffer.write_uint32(attribute);
+   }
+
+   void NM_Inform_Attribute_Ownership::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      object = static_cast<ObjectHandle>(msgBuffer.read_uint32());
+      attribute = static_cast<AttributeHandle>(msgBuffer.read_uint32());
+   }
+
+   void NM_Inform_Attribute_Ownership::show(std::ostream& out) {
+      out << "[NM_Inform_Attribute_Ownership -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " object = " << object << " "       << std::endl;
+      out << " attribute = " << attribute << " "       << std::endl;
+      out << "[NM_Inform_Attribute_Ownership -End]" << std::endl;   }
+
+   NM_Attribute_Ownership_Base::NM_Attribute_Ownership_Base() {
+      this->messageName = "NM_Attribute_Ownership_Base";
+      this->type = NetworkMessage::ATTRIBUTE_OWNERSHIP_BASE;
+      //object= <no default value in message spec using builtin>
+      //attributes= <no default value in message spec using builtin>
+   }
+
+   NM_Attribute_Ownership_Base::~NM_Attribute_Ownership_Base() {
+   }
+
+   void NM_Attribute_Ownership_Base::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(object);
+      uint32_t attributesSize = attributes.size();
+      msgBuffer.write_uint32(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         msgBuffer.write_uint32(attributes[i]);
+      }
+   }
+
+   void NM_Attribute_Ownership_Base::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      object = static_cast<ObjectHandle>(msgBuffer.read_uint32());
+      uint32_t attributesSize = msgBuffer.read_uint32();
+      attributes.resize(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         attributes[i] = static_cast<AttributeHandle>(msgBuffer.read_uint32());
+      }
+   }
+
+   void NM_Attribute_Ownership_Base::show(std::ostream& out) {
+      out << "[NM_Attribute_Ownership_Base -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " object = " << object << " "       << std::endl;
+      out << "    attributes [] =" << std::endl;
+      for (uint32_t i = 0; i < getAttributesSize(); ++i) {
+         out << attributes[i] << " " ;
+      }
+      out << std::endl;
+      out << "[NM_Attribute_Ownership_Base -End]" << std::endl;   }
+
+   NM_Negotiated_Attribute_Ownership_Divestiture::NM_Negotiated_Attribute_Ownership_Divestiture() {
+      this->messageName = "NM_Negotiated_Attribute_Ownership_Divestiture";
+      this->type = NetworkMessage::NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE;
+   }
+
+   NM_Negotiated_Attribute_Ownership_Divestiture::~NM_Negotiated_Attribute_Ownership_Divestiture() {
+   }
+
+   NM_Attribute_Ownership_Acquisition_Notification::NM_Attribute_Ownership_Acquisition_Notification() {
+      this->messageName = "NM_Attribute_Ownership_Acquisition_Notification";
+      this->type = NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION_NOTIFICATION;
+   }
+
+   NM_Attribute_Ownership_Acquisition_Notification::~NM_Attribute_Ownership_Acquisition_Notification() {
+   }
+
+   NM_Attribute_Ownership_Divestiture_Notification::NM_Attribute_Ownership_Divestiture_Notification() {
+      this->messageName = "NM_Attribute_Ownership_Divestiture_Notification";
+      this->type = NetworkMessage::ATTRIBUTE_OWNERSHIP_DIVESTITURE_NOTIFICATION;
+   }
+
+   NM_Attribute_Ownership_Divestiture_Notification::~NM_Attribute_Ownership_Divestiture_Notification() {
+   }
+
+   NM_Request_Attribute_Ownership_Assumption::NM_Request_Attribute_Ownership_Assumption() {
+      this->messageName = "NM_Request_Attribute_Ownership_Assumption";
+      this->type = NetworkMessage::REQUEST_ATTRIBUTE_OWNERSHIP_ASSUMPTION;
+   }
+
+   NM_Request_Attribute_Ownership_Assumption::~NM_Request_Attribute_Ownership_Assumption() {
+   }
+
+   NM_Attribute_Ownership_Unavailable::NM_Attribute_Ownership_Unavailable() {
+      this->messageName = "NM_Attribute_Ownership_Unavailable";
+      this->type = NetworkMessage::ATTRIBUTE_OWNERSHIP_UNAVAILABLE;
+   }
+
+   NM_Attribute_Ownership_Unavailable::~NM_Attribute_Ownership_Unavailable() {
+   }
+
+   NM_Attribute_Ownership_Acquisition_If_Available::NM_Attribute_Ownership_Acquisition_If_Available() {
+      this->messageName = "NM_Attribute_Ownership_Acquisition_If_Available";
+      this->type = NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION_IF_AVAILABLE;
+   }
+
+   NM_Attribute_Ownership_Acquisition_If_Available::~NM_Attribute_Ownership_Acquisition_If_Available() {
+   }
+
+   NM_Unconditional_Attribute_Ownership_Divestiture::NM_Unconditional_Attribute_Ownership_Divestiture() {
+      this->messageName = "NM_Unconditional_Attribute_Ownership_Divestiture";
+      this->type = NetworkMessage::UNCONDITIONAL_ATTRIBUTE_OWNERSHIP_DIVESTITURE;
+   }
+
+   NM_Unconditional_Attribute_Ownership_Divestiture::~NM_Unconditional_Attribute_Ownership_Divestiture() {
+   }
+
+   NM_Attribute_Ownership_Acquisition::NM_Attribute_Ownership_Acquisition() {
+      this->messageName = "NM_Attribute_Ownership_Acquisition";
+      this->type = NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION;
+   }
+
+   NM_Attribute_Ownership_Acquisition::~NM_Attribute_Ownership_Acquisition() {
+   }
+
+   NM_Request_Attribute_Ownership_Release::NM_Request_Attribute_Ownership_Release() {
+      this->messageName = "NM_Request_Attribute_Ownership_Release";
+      this->type = NetworkMessage::REQUEST_ATTRIBUTE_OWNERSHIP_RELEASE;
+   }
+
+   NM_Request_Attribute_Ownership_Release::~NM_Request_Attribute_Ownership_Release() {
+   }
+
+   NM_Cancel_Negotiated_Attribute_Ownership_Divestiture::NM_Cancel_Negotiated_Attribute_Ownership_Divestiture() {
+      this->messageName = "NM_Cancel_Negotiated_Attribute_Ownership_Divestiture";
+      this->type = NetworkMessage::CANCEL_NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE;
+   }
+
+   NM_Cancel_Negotiated_Attribute_Ownership_Divestiture::~NM_Cancel_Negotiated_Attribute_Ownership_Divestiture() {
+   }
+
+   NM_Attribute_Ownership_Release_Response::NM_Attribute_Ownership_Release_Response() {
+      this->messageName = "NM_Attribute_Ownership_Release_Response";
+      this->type = NetworkMessage::ATTRIBUTE_OWNERSHIP_RELEASE_RESPONSE;
+   }
+
+   NM_Attribute_Ownership_Release_Response::~NM_Attribute_Ownership_Release_Response() {
+   }
+
+   NM_Cancel_Attribute_Ownership_Acquisition::NM_Cancel_Attribute_Ownership_Acquisition() {
+      this->messageName = "NM_Cancel_Attribute_Ownership_Acquisition";
+      this->type = NetworkMessage::CANCEL_ATTRIBUTE_OWNERSHIP_ACQUISITION;
+   }
+
+   NM_Cancel_Attribute_Ownership_Acquisition::~NM_Cancel_Attribute_Ownership_Acquisition() {
+   }
+
+   NM_Confirm_Attribute_Ownership_Acquisition_Cancellation::NM_Confirm_Attribute_Ownership_Acquisition_Cancellation() {
+      this->messageName = "NM_Confirm_Attribute_Ownership_Acquisition_Cancellation";
+      this->type = NetworkMessage::CONFIRM_ATTRIBUTE_OWNERSHIP_ACQUISITION_CANCELLATION;
+   }
+
+   NM_Confirm_Attribute_Ownership_Acquisition_Cancellation::~NM_Confirm_Attribute_Ownership_Acquisition_Cancellation() {
+   }
+
+   NM_DDM_Create_Region::NM_DDM_Create_Region() {
+      this->messageName = "NM_DDM_Create_Region";
+      this->type = NetworkMessage::DDM_CREATE_REGION;
+      //attributes= <no default value in message spec using builtin>
+      DDM_bool=false;
+      //space= <no default value in message spec using builtin>
+      //region= <no default value in message spec using builtin>
+      //nbExtents= <no default value in message spec using builtin>
+   }
+
+   NM_DDM_Create_Region::~NM_DDM_Create_Region() {
+   }
+
+   void NM_DDM_Create_Region::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      uint32_t attributesSize = attributes.size();
+      msgBuffer.write_uint32(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         msgBuffer.write_uint32(attributes[i]);
+      }
+      msgBuffer.write_bool(DDM_bool);
+      msgBuffer.write_uint32(space);
+      msgBuffer.write_uint32(region);
+      msgBuffer.write_uint32(nbExtents);
+   }
+
+   void NM_DDM_Create_Region::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      uint32_t attributesSize = msgBuffer.read_uint32();
+      attributes.resize(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         attributes[i] = static_cast<AttributeHandle>(msgBuffer.read_uint32());
+      }
+      DDM_bool = msgBuffer.read_bool();
+      space = static_cast<SpaceHandle>(msgBuffer.read_uint32());
+      region = static_cast<RegionHandle>(msgBuffer.read_uint32());
+      nbExtents = msgBuffer.read_uint32();
+   }
+
+   void NM_DDM_Create_Region::show(std::ostream& out) {
+      out << "[NM_DDM_Create_Region -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << "    attributes [] =" << std::endl;
+      for (uint32_t i = 0; i < getAttributesSize(); ++i) {
+         out << attributes[i] << " " ;
+      }
+      out << std::endl;
+      out << " DDM_bool = " << DDM_bool << " "       << std::endl;
+      out << " space = " << space << " "       << std::endl;
+      out << " region = " << region << " "       << std::endl;
+      out << " nbExtents = " << nbExtents << " "       << std::endl;
+      out << "[NM_DDM_Create_Region -End]" << std::endl;   }
+
+   NM_DDM_Modify_Region::NM_DDM_Modify_Region() {
+      this->messageName = "NM_DDM_Modify_Region";
+      this->type = NetworkMessage::DDM_MODIFY_REGION;
+      //attributes= <no default value in message spec using builtin>
+      DDM_bool=false;
+      //region= <no default value in message spec using builtin>
+   }
+
+   NM_DDM_Modify_Region::~NM_DDM_Modify_Region() {
+   }
+
+   void NM_DDM_Modify_Region::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      uint32_t attributesSize = attributes.size();
+      msgBuffer.write_uint32(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         msgBuffer.write_uint32(attributes[i]);
+      }
+      msgBuffer.write_bool(DDM_bool);
+      msgBuffer.write_uint32(region);
+   }
+
+   void NM_DDM_Modify_Region::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      uint32_t attributesSize = msgBuffer.read_uint32();
+      attributes.resize(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         attributes[i] = static_cast<AttributeHandle>(msgBuffer.read_uint32());
+      }
+      DDM_bool = msgBuffer.read_bool();
+      region = static_cast<RegionHandle>(msgBuffer.read_uint32());
+   }
+
+   void NM_DDM_Modify_Region::show(std::ostream& out) {
+      out << "[NM_DDM_Modify_Region -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << "    attributes [] =" << std::endl;
+      for (uint32_t i = 0; i < getAttributesSize(); ++i) {
+         out << attributes[i] << " " ;
+      }
+      out << std::endl;
+      out << " DDM_bool = " << DDM_bool << " "       << std::endl;
+      out << " region = " << region << " "       << std::endl;
+      out << "[NM_DDM_Modify_Region -End]" << std::endl;   }
+
+   NM_DDM_Delete_Region::NM_DDM_Delete_Region() {
+      this->messageName = "NM_DDM_Delete_Region";
+      this->type = NetworkMessage::DDM_DELETE_REGION;
+      //region= <no default value in message spec using builtin>
+   }
+
+   NM_DDM_Delete_Region::~NM_DDM_Delete_Region() {
+   }
+
+   void NM_DDM_Delete_Region::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(region);
+   }
+
+   void NM_DDM_Delete_Region::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      region = static_cast<RegionHandle>(msgBuffer.read_uint32());
+   }
+
+   void NM_DDM_Delete_Region::show(std::ostream& out) {
+      out << "[NM_DDM_Delete_Region -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " region = " << region << " "       << std::endl;
+      out << "[NM_DDM_Delete_Region -End]" << std::endl;   }
+
+   NM_DDM_Associate_Region::NM_DDM_Associate_Region() {
+      this->messageName = "NM_DDM_Associate_Region";
+      this->type = NetworkMessage::DDM_ASSOCIATE_REGION;
+      //attributes= <no default value in message spec using builtin>
+      DDM_bool=false;
+      //region= <no default value in message spec using builtin>
+      //object= <no default value in message spec using builtin>
+   }
+
+   NM_DDM_Associate_Region::~NM_DDM_Associate_Region() {
+   }
+
+   void NM_DDM_Associate_Region::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      uint32_t attributesSize = attributes.size();
+      msgBuffer.write_uint32(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         msgBuffer.write_uint32(attributes[i]);
+      }
+      msgBuffer.write_bool(DDM_bool);
+      msgBuffer.write_uint32(region);
+      msgBuffer.write_uint32(object);
+   }
+
+   void NM_DDM_Associate_Region::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      uint32_t attributesSize = msgBuffer.read_uint32();
+      attributes.resize(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         attributes[i] = static_cast<AttributeHandle>(msgBuffer.read_uint32());
+      }
+      DDM_bool = msgBuffer.read_bool();
+      region = static_cast<RegionHandle>(msgBuffer.read_uint32());
+      object = static_cast<ObjectHandle>(msgBuffer.read_uint32());
+   }
+
+   void NM_DDM_Associate_Region::show(std::ostream& out) {
+      out << "[NM_DDM_Associate_Region -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << "    attributes [] =" << std::endl;
+      for (uint32_t i = 0; i < getAttributesSize(); ++i) {
+         out << attributes[i] << " " ;
+      }
+      out << std::endl;
+      out << " DDM_bool = " << DDM_bool << " "       << std::endl;
+      out << " region = " << region << " "       << std::endl;
+      out << " object = " << object << " "       << std::endl;
+      out << "[NM_DDM_Associate_Region -End]" << std::endl;   }
+
+   NM_DDM_Unassociate_Region::NM_DDM_Unassociate_Region() {
+      this->messageName = "NM_DDM_Unassociate_Region";
+      this->type = NetworkMessage::DDM_UNASSOCIATE_REGION;
+      //attributes= <no default value in message spec using builtin>
+      //region= <no default value in message spec using builtin>
+      //object= <no default value in message spec using builtin>
+      DDM_bool=false;
+   }
+
+   NM_DDM_Unassociate_Region::~NM_DDM_Unassociate_Region() {
+   }
+
+   void NM_DDM_Unassociate_Region::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      uint32_t attributesSize = attributes.size();
+      msgBuffer.write_uint32(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         msgBuffer.write_uint32(attributes[i]);
+      }
+      msgBuffer.write_uint32(region);
+      msgBuffer.write_uint32(object);
+      msgBuffer.write_bool(DDM_bool);
+   }
+
+   void NM_DDM_Unassociate_Region::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      uint32_t attributesSize = msgBuffer.read_uint32();
+      attributes.resize(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         attributes[i] = static_cast<AttributeHandle>(msgBuffer.read_uint32());
+      }
+      region = static_cast<RegionHandle>(msgBuffer.read_uint32());
+      object = static_cast<ObjectHandle>(msgBuffer.read_uint32());
+      DDM_bool = msgBuffer.read_bool();
+   }
+
+   void NM_DDM_Unassociate_Region::show(std::ostream& out) {
+      out << "[NM_DDM_Unassociate_Region -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << "    attributes [] =" << std::endl;
+      for (uint32_t i = 0; i < getAttributesSize(); ++i) {
+         out << attributes[i] << " " ;
+      }
+      out << std::endl;
+      out << " region = " << region << " "       << std::endl;
+      out << " object = " << object << " "       << std::endl;
+      out << " DDM_bool = " << DDM_bool << " "       << std::endl;
+      out << "[NM_DDM_Unassociate_Region -End]" << std::endl;   }
+
+   NM_DDM_Register_Object::NM_DDM_Register_Object() {
+      this->messageName = "NM_DDM_Register_Object";
+      this->type = NetworkMessage::DDM_REGISTER_OBJECT;
+      //objectClass= <no default value in message spec using builtin>
+      //attributes= <no default value in message spec using builtin>
+      //region= <no default value in message spec using builtin>
+      //objectInstanceName= <no default value in message spec using builtin>
+      //object= <no default value in message spec using builtin>
+      DDM_bool=false;
+   }
+
+   NM_DDM_Register_Object::~NM_DDM_Register_Object() {
+   }
+
+   void NM_DDM_Register_Object::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(objectClass);
+      uint32_t attributesSize = attributes.size();
+      msgBuffer.write_uint32(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         msgBuffer.write_uint32(attributes[i]);
+      }
+      msgBuffer.write_uint32(region);
+      msgBuffer.write_bool(hasObjectInstanceName);
+      if (hasObjectInstanceName) {
+         msgBuffer.write_string(objectInstanceName);
+      }
+      msgBuffer.write_uint32(object);
+      msgBuffer.write_bool(DDM_bool);
+   }
+
+   void NM_DDM_Register_Object::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      objectClass = static_cast<ObjectClassHandle>(msgBuffer.read_uint32());
+      uint32_t attributesSize = msgBuffer.read_uint32();
+      attributes.resize(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         attributes[i] = static_cast<AttributeHandle>(msgBuffer.read_uint32());
+      }
+      region = static_cast<RegionHandle>(msgBuffer.read_uint32());
+      hasObjectInstanceName = msgBuffer.read_bool();
+      if (hasObjectInstanceName) {
+         msgBuffer.read_string(objectInstanceName);
+      }
+      object = static_cast<ObjectHandle>(msgBuffer.read_uint32());
+      DDM_bool = msgBuffer.read_bool();
+   }
+
+   void NM_DDM_Register_Object::show(std::ostream& out) {
+      out << "[NM_DDM_Register_Object -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " objectClass = " << objectClass << " "       << std::endl;
+      out << "    attributes [] =" << std::endl;
+      for (uint32_t i = 0; i < getAttributesSize(); ++i) {
+         out << attributes[i] << " " ;
+      }
+      out << std::endl;
+      out << " region = " << region << " "       << std::endl;
+      out << "(opt) objectInstanceName =" << objectInstanceName << " "       << std::endl;
+      out << " object = " << object << " "       << std::endl;
+      out << " DDM_bool = " << DDM_bool << " "       << std::endl;
+      out << "[NM_DDM_Register_Object -End]" << std::endl;   }
+
+   NM_DDM_Subscribe_Attributes::NM_DDM_Subscribe_Attributes() {
+      this->messageName = "NM_DDM_Subscribe_Attributes";
+      this->type = NetworkMessage::DDM_SUBSCRIBE_ATTRIBUTES;
+      //objectClass= <no default value in message spec using builtin>
+      //region= <no default value in message spec using builtin>
+      //attributes= <no default value in message spec using builtin>
+      DDM_bool=false;
+   }
+
+   NM_DDM_Subscribe_Attributes::~NM_DDM_Subscribe_Attributes() {
+   }
+
+   void NM_DDM_Subscribe_Attributes::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(objectClass);
+      msgBuffer.write_uint32(region);
+      uint32_t attributesSize = attributes.size();
+      msgBuffer.write_uint32(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         msgBuffer.write_uint32(attributes[i]);
+      }
+      msgBuffer.write_bool(DDM_bool);
+   }
+
+   void NM_DDM_Subscribe_Attributes::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      objectClass = static_cast<ObjectClassHandle>(msgBuffer.read_uint32());
+      region = static_cast<RegionHandle>(msgBuffer.read_uint32());
+      uint32_t attributesSize = msgBuffer.read_uint32();
+      attributes.resize(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         attributes[i] = static_cast<AttributeHandle>(msgBuffer.read_uint32());
+      }
+      DDM_bool = msgBuffer.read_bool();
+   }
+
+   void NM_DDM_Subscribe_Attributes::show(std::ostream& out) {
+      out << "[NM_DDM_Subscribe_Attributes -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " objectClass = " << objectClass << " "       << std::endl;
+      out << " region = " << region << " "       << std::endl;
+      out << "    attributes [] =" << std::endl;
+      for (uint32_t i = 0; i < getAttributesSize(); ++i) {
+         out << attributes[i] << " " ;
+      }
+      out << std::endl;
+      out << " DDM_bool = " << DDM_bool << " "       << std::endl;
+      out << "[NM_DDM_Subscribe_Attributes -End]" << std::endl;   }
+
+   NM_DDM_Unsubscribe_Attributes::NM_DDM_Unsubscribe_Attributes() {
+      this->messageName = "NM_DDM_Unsubscribe_Attributes";
+      this->type = NetworkMessage::DDM_UNSUBSCRIBE_ATTRIBUTES;
+      //objectClass= <no default value in message spec using builtin>
+      //region= <no default value in message spec using builtin>
+      //attributes= <no default value in message spec using builtin>
+      DDM_bool=false;
+   }
+
+   NM_DDM_Unsubscribe_Attributes::~NM_DDM_Unsubscribe_Attributes() {
+   }
+
+   void NM_DDM_Unsubscribe_Attributes::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(objectClass);
+      msgBuffer.write_uint32(region);
+      uint32_t attributesSize = attributes.size();
+      msgBuffer.write_uint32(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         msgBuffer.write_uint32(attributes[i]);
+      }
+      msgBuffer.write_bool(DDM_bool);
+   }
+
+   void NM_DDM_Unsubscribe_Attributes::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      objectClass = static_cast<ObjectClassHandle>(msgBuffer.read_uint32());
+      region = static_cast<RegionHandle>(msgBuffer.read_uint32());
+      uint32_t attributesSize = msgBuffer.read_uint32();
+      attributes.resize(attributesSize);
+      for (uint32_t i = 0; i < attributesSize; ++i) {
+         attributes[i] = static_cast<AttributeHandle>(msgBuffer.read_uint32());
+      }
+      DDM_bool = msgBuffer.read_bool();
+   }
+
+   void NM_DDM_Unsubscribe_Attributes::show(std::ostream& out) {
+      out << "[NM_DDM_Unsubscribe_Attributes -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " objectClass = " << objectClass << " "       << std::endl;
+      out << " region = " << region << " "       << std::endl;
+      out << "    attributes [] =" << std::endl;
+      for (uint32_t i = 0; i < getAttributesSize(); ++i) {
+         out << attributes[i] << " " ;
+      }
+      out << std::endl;
+      out << " DDM_bool = " << DDM_bool << " "       << std::endl;
+      out << "[NM_DDM_Unsubscribe_Attributes -End]" << std::endl;   }
+
+   NM_DDM_Subscribe_Interaction::NM_DDM_Subscribe_Interaction() {
+      this->messageName = "NM_DDM_Subscribe_Interaction";
+      this->type = NetworkMessage::DDM_SUBSCRIBE_INTERACTION;
+      //interactionClass= <no default value in message spec using builtin>
+      //region= <no default value in message spec using builtin>
+      DDM_bool=false;
+   }
+
+   NM_DDM_Subscribe_Interaction::~NM_DDM_Subscribe_Interaction() {
+   }
+
+   void NM_DDM_Subscribe_Interaction::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(interactionClass);
+      msgBuffer.write_uint32(region);
+      msgBuffer.write_bool(DDM_bool);
+   }
+
+   void NM_DDM_Subscribe_Interaction::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      interactionClass = static_cast<InteractionClassHandle>(msgBuffer.read_uint32());
+      region = static_cast<RegionHandle>(msgBuffer.read_uint32());
+      DDM_bool = msgBuffer.read_bool();
+   }
+
+   void NM_DDM_Subscribe_Interaction::show(std::ostream& out) {
+      out << "[NM_DDM_Subscribe_Interaction -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " interactionClass = " << interactionClass << " "       << std::endl;
+      out << " region = " << region << " "       << std::endl;
+      out << " DDM_bool = " << DDM_bool << " "       << std::endl;
+      out << "[NM_DDM_Subscribe_Interaction -End]" << std::endl;   }
+
+   NM_DDM_Unsubscribe_Interaction::NM_DDM_Unsubscribe_Interaction() {
+      this->messageName = "NM_DDM_Unsubscribe_Interaction";
+      this->type = NetworkMessage::DDM_UNSUBSCRIBE_INTERACTION;
+   }
+
+   NM_DDM_Unsubscribe_Interaction::~NM_DDM_Unsubscribe_Interaction() {
+   }
+
+   NM_Provide_Attribute_Value_Update::NM_Provide_Attribute_Value_Update() {
+      this->messageName = "NM_Provide_Attribute_Value_Update";
+      this->type = NetworkMessage::PROVIDE_ATTRIBUTE_VALUE_UPDATE;
+   }
+
+   NM_Provide_Attribute_Value_Update::~NM_Provide_Attribute_Value_Update() {
+   }
+
+   NM_Start_Registration_For_Object_Class::NM_Start_Registration_For_Object_Class() {
+      this->messageName = "NM_Start_Registration_For_Object_Class";
+      this->type = NetworkMessage::START_REGISTRATION_FOR_OBJECT_CLASS;
+      //objectClass= <no default value in message spec using builtin>
+   }
+
+   NM_Start_Registration_For_Object_Class::~NM_Start_Registration_For_Object_Class() {
+   }
+
+   void NM_Start_Registration_For_Object_Class::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(objectClass);
+   }
+
+   void NM_Start_Registration_For_Object_Class::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      objectClass = static_cast<ObjectClassHandle>(msgBuffer.read_uint32());
+   }
+
+   void NM_Start_Registration_For_Object_Class::show(std::ostream& out) {
+      out << "[NM_Start_Registration_For_Object_Class -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " objectClass = " << objectClass << " "       << std::endl;
+      out << "[NM_Start_Registration_For_Object_Class -End]" << std::endl;   }
+
+   NM_Stop_Registration_For_Object_Class::NM_Stop_Registration_For_Object_Class() {
+      this->messageName = "NM_Stop_Registration_For_Object_Class";
+      this->type = NetworkMessage::STOP_REGISTRATION_FOR_OBJECT_CLASS;
+      //objectClass= <no default value in message spec using builtin>
+   }
+
+   NM_Stop_Registration_For_Object_Class::~NM_Stop_Registration_For_Object_Class() {
+   }
+
+   void NM_Stop_Registration_For_Object_Class::serialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::serialize(msgBuffer);
+      //Specific serialization code
+      msgBuffer.write_uint32(objectClass);
+   }
+
+   void NM_Stop_Registration_For_Object_Class::deserialize(MessageBuffer& msgBuffer) {
+      //Call mother class
+      Super::deserialize(msgBuffer);
+      //Specific deserialization code
+      objectClass = static_cast<ObjectClassHandle>(msgBuffer.read_uint32());
+   }
+
+   void NM_Stop_Registration_For_Object_Class::show(std::ostream& out) {
+      out << "[NM_Stop_Registration_For_Object_Class -Begin]" << std::endl;      //Call mother class
+      Super::show(out);
+      //Specific show code
+      out << " objectClass = " << objectClass << " "       << std::endl;
+      out << "[NM_Stop_Registration_For_Object_Class -End]" << std::endl;   }
+
+   New_NetworkMessage::New_NetworkMessage() {
+      type=0;
+      //date= <no default value in message spec using builtin>
+      //label= <no default value in message spec using builtin>
+      //tag= <no default value in message spec using builtin>
+   }
+
+   New_NetworkMessage::~New_NetworkMessage() {
+   }
+
+   void New_NetworkMessage::serialize(MessageBuffer& msgBuffer) {
+      //Specific serialization code
+      msgBuffer.write_uint32(type);
+      msgBuffer.write_bool(hasDate);
+      if (hasDate) {
+         // FIXME FIXME FIXME
+         // don't know how to serialize native field <date> of type <FederationTime>
+      }
+      msgBuffer.write_bool(hasLabel);
+      if (hasLabel) {
+         msgBuffer.write_string(label);
+      }
+      msgBuffer.write_bool(hasTag);
+      if (hasTag) {
+         msgBuffer.write_string(tag);
+      }
+   }
+
+   void New_NetworkMessage::deserialize(MessageBuffer& msgBuffer) {
+      //Specific deserialization code
+      type = msgBuffer.read_uint32();
+      hasDate = msgBuffer.read_bool();
+      if (hasDate) {
+         // FIXME FIXME FIXME
+         // don't know how to deserialize native field <date> of type <FederationTime>
+      }
+      hasLabel = msgBuffer.read_bool();
+      if (hasLabel) {
+         msgBuffer.read_string(label);
+      }
+      hasTag = msgBuffer.read_bool();
+      if (hasTag) {
+         msgBuffer.read_string(tag);
+      }
+   }
+
+   void New_NetworkMessage::show(std::ostream& out) {
+      out << "[New_NetworkMessage -Begin]" << std::endl;      //Specific show code
+      out << " type = " << type << " "       << std::endl;
+      out << "(opt) date =" << "      //FIXME FIXME don't know how to serialize native field <date> of type <FederationTime>"      << std::endl;
+      out << "(opt) label =" << label << " "       << std::endl;
+      out << "(opt) tag =" << tag << " "       << std::endl;
+      out << "[New_NetworkMessage -End]" << std::endl;   }
+
+   NetworkMessage* NM_Factory::create(NM_Type type) throw (RTIinternalError) {
+      NetworkMessage* msg = NULL;
+
+      switch (type) {
+         case NetworkMessage::NOT_USED:
+            throw RTIinternalError("NOT_USED message type should not be used!!");
+            break;
+         case NetworkMessage::CLOSE_CONNEXION:
+            msg = new NM_Close_Connexion();
+            break;
+         case NetworkMessage::MESSAGE_NULL:
+            msg = new NM_Message_Null();
+            break;
+         case NetworkMessage::CREATE_FEDERATION_EXECUTION:
+            msg = new NM_Create_Federation_Execution();
+            break;
+         case NetworkMessage::DESTROY_FEDERATION_EXECUTION:
+            msg = new NM_Destroy_Federation_Execution();
+            break;
+         case NetworkMessage::JOIN_FEDERATION_EXECUTION:
+            msg = new NM_Join_Federation_Execution();
+            break;
+         case NetworkMessage::RESIGN_FEDERATION_EXECUTION:
+            msg = new NM_Resign_Federation_Execution();
+            break;
+         case NetworkMessage::SET_TIME_REGULATING:
+            msg = new NM_Set_Time_Regulating();
+            break;
+         case NetworkMessage::SET_TIME_CONSTRAINED:
+            msg = new NM_Set_Time_Constrained();
+            break;
+         case NetworkMessage::TIME_REGULATION_ENABLED:
+            msg = new NM_Time_Regulation_Enabled();
+            break;
+         case NetworkMessage::TIME_CONSTRAINED_ENABLED:
+            msg = new NM_Time_Constrained_Enabled();
+            break;
+         case NetworkMessage::SET_CLASS_RELEVANCE_ADVISORY_SWITCH:
+            msg = new NM_Set_Class_Relevance_Advisory_Switch();
+            break;
+         case NetworkMessage::SET_INTERACTION_RELEVANCE_ADVISORY_SWITCH:
+            msg = new NM_Set_Interaction_Relevance_Advisory_Switch();
+            break;
+         case NetworkMessage::SET_ATTRIBUTE_RELEVANCE_ADVISORY_SWITCH:
+            msg = new NM_Set_Attribute_Relevance_Advisory_Switch();
+            break;
+         case NetworkMessage::SET_ATTRIBUTE_SCOPE_ADVISORY_SWITCH:
+            msg = new NM_Set_Attribute_Scope_Advisory_Switch();
+            break;
+         case NetworkMessage::REGISTER_FEDERATION_SYNCHRONIZATION_POINT:
+            msg = new NM_Register_Federation_Synchronization_Point();
+            break;
+         case NetworkMessage::SYNCHRONIZATION_POINT_REGISTRATION_SUCCEEDED:
+            msg = new NM_Synchronization_Point_Registration_Succeeded();
+            break;
+         case NetworkMessage::ANNOUNCE_SYNCHRONIZATION_POINT:
+            msg = new NM_Announce_Synchronization_Point();
+            break;
+         case NetworkMessage::SYNCHRONIZATION_POINT_ACHIEVED:
+            msg = new NM_Synchronization_Point_Achieved();
+            break;
+         case NetworkMessage::FEDERATION_SYNCHRONIZED:
+            msg = new NM_Federation_Synchronized();
+            break;
+         case NetworkMessage::REQUEST_FEDERATION_SAVE:
+            msg = new NM_Request_Federation_Save();
+            break;
+         case NetworkMessage::FEDERATE_SAVE_BEGUN:
+            msg = new NM_Federate_Save_Begun();
+            break;
+         case NetworkMessage::FEDERATE_SAVE_COMPLETE:
+            msg = new NM_Federate_Save_Complete();
+            break;
+         case NetworkMessage::FEDERATE_SAVE_NOT_COMPLETE:
+            msg = new NM_Federate_Save_Not_Complete();
+            break;
+         case NetworkMessage::INITIATE_FEDERATE_SAVE:
+            msg = new NM_Initiate_Federate_Save();
+            break;
+         case NetworkMessage::FEDERATION_SAVED:
+            msg = new NM_Federation_Saved();
+            break;
+         case NetworkMessage::FEDERATION_NOT_SAVED:
+            msg = new NM_Federation_Not_Saved();
+            break;
+         case NetworkMessage::REQUEST_FEDERATION_RESTORE:
+            msg = new NM_Request_Federation_Restore();
+            break;
+         case NetworkMessage::FEDERATE_RESTORE_COMPLETE:
+            msg = new NM_Federate_Restore_Complete();
+            break;
+         case NetworkMessage::FEDERATE_RESTORE_NOT_COMPLETE:
+            msg = new NM_Federate_Restore_Not_Complete();
+            break;
+         case NetworkMessage::REQUEST_FEDERATION_RESTORE_SUCCEEDED:
+            msg = new NM_Request_Federation_Restore_Succeeded();
+            break;
+         case NetworkMessage::REQUEST_FEDERATION_RESTORE_FAILED:
+            msg = new NM_Request_Federation_Restore_Failed();
+            break;
+         case NetworkMessage::FEDERATION_RESTORE_BEGUN:
+            msg = new NM_Federation_Restore_Begun();
+            break;
+         case NetworkMessage::INITIATE_FEDERATE_RESTORE:
+            msg = new NM_Initiate_Federate_Restore();
+            break;
+         case NetworkMessage::FEDERATION_RESTORED:
+            msg = new NM_Federation_Restored();
+            break;
+         case NetworkMessage::FEDERATION_NOT_RESTORED:
+            msg = new NM_Federation_Not_Restored();
+            break;
+         case NetworkMessage::PUBLISH_OBJECT_CLASS:
+            msg = new NM_Publish_Object_Class();
+            break;
+         case NetworkMessage::UNPUBLISH_OBJECT_CLASS:
+            msg = new NM_Unpublish_Object_Class();
+            break;
+         case NetworkMessage::PUBLISH_INTERACTION_CLASS:
+            msg = new NM_Publish_Interaction_Class();
+            break;
+         case NetworkMessage::UNPUBLISH_INTERACTION_CLASS:
+            msg = new NM_Unpublish_Interaction_Class();
+            break;
+         case NetworkMessage::SUBSCRIBE_OBJECT_CLASS:
+            msg = new NM_Subscribe_Object_Class();
+            break;
+         case NetworkMessage::UNSUBSCRIBE_OBJECT_CLASS:
+            msg = new NM_Unsubscribe_Object_Class();
+            break;
+         case NetworkMessage::SUBSCRIBE_INTERACTION_CLASS:
+            msg = new NM_Subscribe_Interaction_Class();
+            break;
+         case NetworkMessage::UNSUBSCRIBE_INTERACTION_CLASS:
+            msg = new NM_Unsubscribe_Interaction_Class();
+            break;
+         case NetworkMessage::TURN_INTERACTIONS_ON:
+            msg = new NM_Turn_Interactions_On();
+            break;
+         case NetworkMessage::TURN_INTERACTIONS_OFF:
+            msg = new NM_Turn_Interactions_Off();
+            break;
+         case NetworkMessage::REGISTER_OBJECT:
+            msg = new NM_Register_Object();
+            break;
+         case NetworkMessage::DISCOVER_OBJECT:
+            msg = new NM_Discover_Object();
+            break;
+         case NetworkMessage::UPDATE_ATTRIBUTE_VALUES:
+            msg = new NM_Update_Attribute_Values();
+            break;
+         case NetworkMessage::REFLECT_ATTRIBUTE_VALUES:
+            msg = new NM_Reflect_Attribute_Values();
+            break;
+         case NetworkMessage::SEND_INTERACTION:
+            msg = new NM_Send_Interaction();
+            break;
+         case NetworkMessage::RECEIVE_INTERACTION:
+            msg = new NM_Receive_Interaction();
+            break;
+         case NetworkMessage::DELETE_OBJECT:
+            msg = new NM_Delete_Object();
+            break;
+         case NetworkMessage::REMOVE_OBJECT:
+            msg = new NM_Remove_Object();
+            break;
+         case NetworkMessage::CHANGE_ATTRIBUTE_TRANSPORT_TYPE:
+            msg = new NM_Change_Attribute_Transport_Type();
+            break;
+         case NetworkMessage::CHANGE_ATTRIBUTE_ORDER_TYPE:
+            msg = new NM_Change_Attribute_Order_Type();
+            break;
+         case NetworkMessage::CHANGE_INTERACTION_TRANSPORT_TYPE:
+            msg = new NM_Change_Interaction_Transport_Type();
+            break;
+         case NetworkMessage::CHANGE_INTERACTION_ORDER_TYPE:
+            msg = new NM_Change_Interaction_Order_Type();
+            break;
+         case NetworkMessage::REQUEST_CLASS_ATTRIBUTE_VALUE_UPDATE:
+            msg = new NM_Request_Class_Attribute_Value_Update();
+            break;
+         case NetworkMessage::REQUEST_OBJECT_ATTRIBUTE_VALUE_UPDATE:
+            msg = new NM_Request_Object_Attribute_Value_Update();
+            break;
+         case NetworkMessage::IS_ATTRIBUTE_OWNED_BY_FEDERATE:
+            msg = new NM_Is_Attribute_Owned_By_Federate();
+            break;
+         case NetworkMessage::QUERY_ATTRIBUTE_OWNERSHIP:
+            msg = new NM_Query_Attribute_Ownership();
+            break;
+         case NetworkMessage::ATTRIBUTE_IS_NOT_OWNED:
+            msg = new NM_Attribute_Is_Not_Owned();
+            break;
+         case NetworkMessage::INFORM_ATTRIBUTE_OWNERSHIP:
+            msg = new NM_Inform_Attribute_Ownership();
+            break;
+         case NetworkMessage::ATTRIBUTE_OWNERSHIP_BASE:
+            msg = new NM_Attribute_Ownership_Base();
+            break;
+         case NetworkMessage::NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE:
+            msg = new NM_Negotiated_Attribute_Ownership_Divestiture();
+            break;
+         case NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION_NOTIFICATION:
+            msg = new NM_Attribute_Ownership_Acquisition_Notification();
+            break;
+         case NetworkMessage::ATTRIBUTE_OWNERSHIP_DIVESTITURE_NOTIFICATION:
+            msg = new NM_Attribute_Ownership_Divestiture_Notification();
+            break;
+         case NetworkMessage::REQUEST_ATTRIBUTE_OWNERSHIP_ASSUMPTION:
+            msg = new NM_Request_Attribute_Ownership_Assumption();
+            break;
+         case NetworkMessage::ATTRIBUTE_OWNERSHIP_UNAVAILABLE:
+            msg = new NM_Attribute_Ownership_Unavailable();
+            break;
+         case NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION_IF_AVAILABLE:
+            msg = new NM_Attribute_Ownership_Acquisition_If_Available();
+            break;
+         case NetworkMessage::UNCONDITIONAL_ATTRIBUTE_OWNERSHIP_DIVESTITURE:
+            msg = new NM_Unconditional_Attribute_Ownership_Divestiture();
+            break;
+         case NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION:
+            msg = new NM_Attribute_Ownership_Acquisition();
+            break;
+         case NetworkMessage::REQUEST_ATTRIBUTE_OWNERSHIP_RELEASE:
+            msg = new NM_Request_Attribute_Ownership_Release();
+            break;
+         case NetworkMessage::CANCEL_NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE:
+            msg = new NM_Cancel_Negotiated_Attribute_Ownership_Divestiture();
+            break;
+         case NetworkMessage::ATTRIBUTE_OWNERSHIP_RELEASE_RESPONSE:
+            msg = new NM_Attribute_Ownership_Release_Response();
+            break;
+         case NetworkMessage::CANCEL_ATTRIBUTE_OWNERSHIP_ACQUISITION:
+            msg = new NM_Cancel_Attribute_Ownership_Acquisition();
+            break;
+         case NetworkMessage::CONFIRM_ATTRIBUTE_OWNERSHIP_ACQUISITION_CANCELLATION:
+            msg = new NM_Confirm_Attribute_Ownership_Acquisition_Cancellation();
+            break;
+         case NetworkMessage::DDM_CREATE_REGION:
+            msg = new NM_DDM_Create_Region();
+            break;
+         case NetworkMessage::DDM_MODIFY_REGION:
+            msg = new NM_DDM_Modify_Region();
+            break;
+         case NetworkMessage::DDM_DELETE_REGION:
+            msg = new NM_DDM_Delete_Region();
+            break;
+         case NetworkMessage::DDM_ASSOCIATE_REGION:
+            msg = new NM_DDM_Associate_Region();
+            break;
+         case NetworkMessage::DDM_UNASSOCIATE_REGION:
+            msg = new NM_DDM_Unassociate_Region();
+            break;
+         case NetworkMessage::DDM_REGISTER_OBJECT:
+            msg = new NM_DDM_Register_Object();
+            break;
+         case NetworkMessage::DDM_SUBSCRIBE_ATTRIBUTES:
+            msg = new NM_DDM_Subscribe_Attributes();
+            break;
+         case NetworkMessage::DDM_UNSUBSCRIBE_ATTRIBUTES:
+            msg = new NM_DDM_Unsubscribe_Attributes();
+            break;
+         case NetworkMessage::DDM_SUBSCRIBE_INTERACTION:
+            msg = new NM_DDM_Subscribe_Interaction();
+            break;
+         case NetworkMessage::DDM_UNSUBSCRIBE_INTERACTION:
+            msg = new NM_DDM_Unsubscribe_Interaction();
+            break;
+         case NetworkMessage::PROVIDE_ATTRIBUTE_VALUE_UPDATE:
+            msg = new NM_Provide_Attribute_Value_Update();
+            break;
+         case NetworkMessage::START_REGISTRATION_FOR_OBJECT_CLASS:
+            msg = new NM_Start_Registration_For_Object_Class();
+            break;
+         case NetworkMessage::STOP_REGISTRATION_FOR_OBJECT_CLASS:
+            msg = new NM_Stop_Registration_For_Object_Class();
+            break;
+         case NetworkMessage::LAST:
+            throw RTIinternalError("LAST message type should not be used!!");
+            break;
+      } // end if switch (type)
+      return msg;
+   } /* end of NM_Factory::create */
+
+   NetworkMessage* NM_Factory::receive(NMStreamType stream) throw (RTIinternalError) {
+      // FIXME This is not thread safe
+      static MessageBuffer msgBuffer;
+      NetworkMessage  msgGen;
+      NetworkMessage* msg;
+
+      // receive generic message 
+      msgGen.receive(stream,msgBuffer);
+      // create specific message from type 
+      msg = NM_Factory::create(msgGen.getType());
+      msgBuffer.assumeSizeFromReservedBytes();
+      msg->deserialize(msgBuffer);
+      return msg;
+   } /* end of NM_Factory::receive */ 
 
-} /* end of certi namespace */
+} // end of namespace certi 
Index: libCERTI/LBTS.cc
===================================================================
RCS file: /sources/certi/certi/libCERTI/LBTS.cc,v
retrieving revision 3.16
diff -u -r3.16 LBTS.cc
--- libCERTI/LBTS.cc	24 Nov 2009 21:44:47 -0000	3.16
+++ libCERTI/LBTS.cc	18 Mar 2010 18:31:09 -0000
@@ -119,7 +119,7 @@
     ClockSet::iterator it = clocks.find(num_fed);
 
     if (it == clocks.end())
-        throw RTIinternalError("LBTS: Federate not found.");
+        throw RTIinternalError(stringize() << "LBTS: Federate <" << num_fed << "> not found.");
 
     // Coherence test.
     if (it->second > time)
@@ -144,7 +144,7 @@
     ClockSet::iterator it = clocks.find(num_fed);
 
     if (it == clocks.end())
-        throw RTIinternalError("LBTS: Federate not found.");
+        throw RTIinternalError(stringize() << "LBTS: Federate <"<< num_fed << "not found.");
 
     clocks.erase(it);
     compute();
Index: libCERTI/ObjectClass.hh
===================================================================
RCS file: /sources/certi/certi/libCERTI/ObjectClass.hh,v
retrieving revision 3.52
diff -u -r3.52 ObjectClass.hh
--- libCERTI/ObjectClass.hh	27 Feb 2010 16:53:35 -0000	3.52
+++ libCERTI/ObjectClass.hh	18 Mar 2010 18:31:10 -0000
@@ -40,6 +40,7 @@
 #include "SecurityServer.hh"
 #include "Named.hh"
 #include "GAV.hh"
+#include "NM_Classes.hh"
 
 // Standard
 #include <map>
@@ -155,7 +156,7 @@
 			bool PubOrUnpub)
 	throw (AttributeNotDefined, RTIinternalError, SecurityError);
 
-	bool subscribe(FederateHandle, std::vector <AttributeHandle> &, int, const RTIRegion *)
+	bool subscribe(FederateHandle, const std::vector <AttributeHandle> &, int, const RTIRegion *)
 	throw (AttributeNotDefined, RTIinternalError, SecurityError);
 
 	void unsubscribe(FederateHandle, const RTIRegion *);
@@ -165,7 +166,7 @@
 	ObjectClassBroadcastList *
 	negotiatedAttributeOwnershipDivestiture(FederateHandle theFederateHandle,
                         Object* object,
-			std::vector <AttributeHandle> &theAttributeList,
+			const std::vector <AttributeHandle> &theAttributeList,
 			const std::string& theTag)
 			throw (AttributeNotDefined, AttributeNotOwned,
 					AttributeAlreadyBeingDivested, RTIinternalError);
@@ -174,7 +175,7 @@
 	void
 	attributeOwnershipAcquisitionIfAvailable(FederateHandle theFederateHandle,
 			Object* object,
-			std::vector <AttributeHandle> &theAttributeList)
+			const std::vector <AttributeHandle> &theAttributeList)
 	throw (ObjectClassNotPublished, AttributeNotDefined,
 			AttributeNotPublished, FederateOwnsAttributes,
 			AttributeAlreadyBeingAcquired, RTIinternalError);
@@ -182,14 +183,14 @@
 	ObjectClassBroadcastList *
 	unconditionalAttributeOwnershipDivestiture(FederateHandle,
 			Object* object,
-			std::vector <AttributeHandle> &)
+			const std::vector <AttributeHandle> &)
 			throw (AttributeNotDefined, AttributeNotOwned,
 					RTIinternalError);
 
 	void
 	attributeOwnershipAcquisition(FederateHandle theFederateHandle,
 			Object* object,
-			std::vector <AttributeHandle> &theAttributeList,
+			const std::vector <AttributeHandle> &theAttributeList,
 			const std::string& theTag)
 	throw (ObjectClassNotPublished, AttributeNotDefined,
 			AttributeNotPublished, FederateOwnsAttributes, RTIinternalError);
@@ -197,13 +198,13 @@
 	AttributeHandleSet *
 	attributeOwnershipReleaseResponse(FederateHandle theFederateHandle,
 			Object* object,
-			std::vector <AttributeHandle> &theAttributeList)
+			const std::vector <AttributeHandle> &theAttributeList)
 			throw (AttributeNotDefined, AttributeNotOwned,
 					FederateWasNotAskedToReleaseAttribute, RTIinternalError);
 
 	void cancelAttributeOwnershipAcquisition(FederateHandle theFederateHandle,
 			Object* object,
-			std::vector <AttributeHandle> &theAttributeList)
+			const std::vector <AttributeHandle> &theAttributeList)
 	throw (AttributeNotDefined, AttributeAlreadyOwned,
 			AttributeAcquisitionWasNotRequested, RTIinternalError);
 
@@ -249,14 +250,14 @@
 			const Object * = NULL);
 
 	ObjectClassBroadcastList *
-	updateAttributeValues(FederateHandle, Object *, std::vector <AttributeHandle> &,
-			std::vector <AttributeValue_t> &, int, FederationTime, const std::string&)
+	updateAttributeValues(FederateHandle, Object *, const std::vector <AttributeHandle> &,
+			const std::vector <AttributeValue_t> &, int, FederationTime, const std::string&)
 			throw (AttributeNotDefined, AttributeNotOwned,
 					RTIinternalError, InvalidObjectHandle);
 
 	ObjectClassBroadcastList *
-	updateAttributeValues(FederateHandle, Object *, std::vector <AttributeHandle> &,
-			std::vector <AttributeValue_t> &, int, const std::string&)
+	updateAttributeValues(FederateHandle, Object *, const std::vector <AttributeHandle> &,
+			const std::vector <AttributeValue_t> &, int, const std::string&)
 			throw (AttributeNotDefined, AttributeNotOwned,
 					RTIinternalError, InvalidObjectHandle);
 
@@ -288,7 +289,7 @@
 			Object* object,
 			FederateHandle theFederate,
 			const std::string& theTag,
-			NetworkMessage::Type type);
+			NM_Attribute_Ownership_Base& msg);
 
 	void sendMessage(NetworkMessage *msg, FederateHandle theDest);
 
Index: libCERTI/ObjectClassSet.cc
===================================================================
RCS file: /sources/certi/certi/libCERTI/ObjectClassSet.cc,v
retrieving revision 3.51
diff -u -r3.51 ObjectClassSet.cc
--- libCERTI/ObjectClassSet.cc	27 Feb 2010 16:53:35 -0000	3.51
+++ libCERTI/ObjectClassSet.cc	18 Mar 2010 18:31:10 -0000
@@ -373,7 +373,7 @@
 void
 ObjectClassSet::subscribe(FederateHandle federate,
                           ObjectClassHandle class_handle,
-                          std::vector <AttributeHandle> &attributes,
+                          const std::vector <AttributeHandle> &attributes,
                           int nb,
 			  const RTIRegion *region)
     throw (ObjectClassNotDefined, AttributeNotDefined, RTIinternalError,
@@ -392,8 +392,8 @@
 void
 ObjectClassSet::updateAttributeValues(FederateHandle federate,
                                       Object* object,
-                                      std::vector <AttributeHandle> &attributes,
-                                      std::vector <AttributeValue_t> &values,
+                                      const std::vector <AttributeHandle> &attributes,
+                                      const std::vector <AttributeValue_t> &values,
                                       const FederationTime& time,
                                       const std::string& tag)
     throw (AttributeNotDefined,
@@ -435,8 +435,8 @@
 void
 ObjectClassSet::updateAttributeValues(FederateHandle federate,
                                       Object* object,
-                                      std::vector <AttributeHandle> &attributes,
-                                      std::vector <AttributeValue_t> &values,
+                                      const std::vector <AttributeHandle> &attributes,
+                                      const std::vector <AttributeValue_t> &values,
                                       const std::string& tag)
     throw (AttributeNotDefined,
            AttributeNotOwned,
@@ -478,7 +478,7 @@
 ObjectClassSet::
 negotiatedAttributeOwnershipDivestiture(FederateHandle theFederateHandle,
                                         Object* object,
-                                        std::vector <AttributeHandle> &theAttributeList,
+                                        const std::vector <AttributeHandle> &theAttributeList,
                                         const std::string& theTag)
     throw (AttributeNotDefined,
            AttributeNotOwned,
@@ -521,7 +521,7 @@
 ObjectClassSet::
 attributeOwnershipAcquisitionIfAvailable(FederateHandle theFederateHandle,
                                          Object* object,
-                                         std::vector <AttributeHandle> &theAttributeList)
+                                         const std::vector <AttributeHandle> &theAttributeList)
     throw (ObjectClassNotPublished,
            AttributeNotDefined,
            AttributeNotPublished,
@@ -544,7 +544,7 @@
 ObjectClassSet::
 unconditionalAttributeOwnershipDivestiture(FederateHandle theFederateHandle,
                                            Object* object,
-                                           std::vector <AttributeHandle> &theAttributeList)
+                                           const std::vector <AttributeHandle> &theAttributeList)
     throw (AttributeNotDefined,
            AttributeNotOwned,
            RTIinternalError)
@@ -581,7 +581,7 @@
 ObjectClassSet::
 attributeOwnershipAcquisition(FederateHandle theFederateHandle,
                               Object* object,
-                              std::vector <AttributeHandle> &theAttributeList,
+                              const std::vector <AttributeHandle> &theAttributeList,
                               const std::string& theTag)
     throw (ObjectClassNotPublished,
            AttributeNotDefined,
@@ -601,7 +601,7 @@
 AttributeHandleSet * ObjectClassSet::
 attributeOwnershipReleaseResponse(FederateHandle theFederateHandle,
                                   Object* object,
-                                  std::vector <AttributeHandle> &theAttributeList)
+                                  const std::vector <AttributeHandle> &theAttributeList)
     throw (AttributeNotDefined,
            AttributeNotOwned,
            FederateWasNotAskedToReleaseAttribute,
@@ -619,7 +619,7 @@
 void ObjectClassSet::
 cancelAttributeOwnershipAcquisition(FederateHandle theFederateHandle,
                                     Object* object,
-                                    std::vector <AttributeHandle> &theAttributeList)
+                                    const std::vector <AttributeHandle> &theAttributeList)
     throw (AttributeNotDefined,
            AttributeAlreadyOwned,
            AttributeAcquisitionWasNotRequested,
Index: libCERTI/ObjectClassAttribute.cc
===================================================================
RCS file: /sources/certi/certi/libCERTI/ObjectClassAttribute.cc,v
retrieving revision 3.36
diff -u -r3.36 ObjectClassAttribute.cc
--- libCERTI/ObjectClassAttribute.cc	24 Nov 2009 16:39:20 -0000	3.36
+++ libCERTI/ObjectClassAttribute.cc	18 Mar 2010 18:31:10 -0000
@@ -39,20 +39,20 @@
 // ----------------------------------------------------------------------------
 //! Constructor : Set const attribute handle and name
 ObjectClassAttribute::ObjectClassAttribute(const std::string& name, AttributeHandle attributeHandle)
-  : Subscribable(name), level(PublicLevelID), order(0), transport(0), server(0), handle(attributeHandle), space(0)
+: Subscribable(name), level(PublicLevelID), order(0), transport(0), server(0), handle(attributeHandle), space(0)
 {
 }
 
 // ----------------------------------------------------------------------------
 //! Constructor : Copy Handle, Name, Space, Order and Transport
 ObjectClassAttribute::ObjectClassAttribute(const ObjectClassAttribute& objectClassAttribute)
-  : Subscribable(objectClassAttribute.getName()),
-    level(objectClassAttribute.level),
-    order(objectClassAttribute.order),
-    transport(objectClassAttribute.transport),
-    server(objectClassAttribute.server),
-    handle(objectClassAttribute.handle),
-    space(objectClassAttribute.space)
+: Subscribable(objectClassAttribute.getName()),
+  level(objectClassAttribute.level),
+  order(objectClassAttribute.order),
+  transport(objectClassAttribute.transport),
+  server(objectClassAttribute.server),
+  handle(objectClassAttribute.handle),
+  space(objectClassAttribute.space)
 {
 }
 
@@ -65,16 +65,16 @@
 // ----------------------------------------------------------------------------
 /*! Throw SecurityError if the Federate is not allowed to access the Object
   Class, and print an Audit message containing Reason.
-*/
+ */
 void
 ObjectClassAttribute::checkFederateAccess(FederateHandle fed,
-					  const std::string& reason) const
+		const std::string& reason) const
 {
-    if (server && !server->canFederateAccessData(fed, level)) {
-        cout << "Attribute " << handle << " : SecurityError for federate "
-             << fed << '(' << reason << ")." << endl ;
-        throw SecurityError("Federate should not access ObjectClassAttribute.");
-    }
+	if (server && !server->canFederateAccessData(fed, level)) {
+		cout << "Attribute " << handle << " : SecurityError for federate "
+				<< fed << '(' << reason << ")." << endl ;
+		throw SecurityError("Federate should not access ObjectClassAttribute.");
+	}
 }
 
 // ----------------------------------------------------------------------------
@@ -82,9 +82,9 @@
 void
 ObjectClassAttribute::deletePublisher(FederateHandle fed)
 {
-    PublishersList_t::iterator it = publishers.find(fed);
-    if (it != publishers.end())
-	publishers.erase(it);
+	PublishersList_t::iterator it = publishers.find(fed);
+	if (it != publishers.end())
+		publishers.erase(it);
 }
 
 // ----------------------------------------------------------------------------
@@ -92,14 +92,14 @@
 void
 ObjectClassAttribute::display() const
 {
-    cout << " Attribute " << handle << ':' ;
+	cout << " Attribute " << handle << ':' ;
 
-    if (name.length() > 0)
-        cout << '\"' << name << '\"' ;
-    else
-        cout << "(no name)" ;
+	if (name.length() > 0)
+		cout << '\"' << name << '\"' ;
+	else
+		cout << "(no name)" ;
 
-    cout << "[Level " << level << ']' << endl ;
+	cout << "[Level " << level << ']' << endl ;
 }
 
 // ----------------------------------------------------------------------------
@@ -107,64 +107,64 @@
 bool
 ObjectClassAttribute::isPublishing(FederateHandle fed) const
 {
-    return publishers.find(fed) != publishers.end();
+	return publishers.find(fed) != publishers.end();
 }
 
 // ----------------------------------------------------------------------------
 //! publish
 void
 ObjectClassAttribute::publish(FederateHandle fed)
-    throw (RTIinternalError, SecurityError)
+throw (RTIinternalError, SecurityError)
 {
-    if (!isPublishing(fed)) {
-        checkFederateAccess(fed, "Publish");
-        Debug(D, pdInit) << "Attribute " << handle << ": Added Federate " << fed
-		  << " to publishers list." << endl ;
-	publishers.insert(fed);
-    }
-    else
-        Debug(D, pdError) << "Attribute " << handle
-		   << ": Inconsistent publish request from Federate "
-		   << fed << endl ;
+	if (!isPublishing(fed)) {
+		checkFederateAccess(fed, "Publish");
+		Debug(D, pdInit) << "Attribute " << handle << ": Added Federate " << fed
+				<< " to publishers list." << endl ;
+		publishers.insert(fed);
+	}
+	else
+		Debug(D, pdError) << "Attribute " << handle
+		<< ": Inconsistent publish request from Federate "
+		<< fed << endl ;
 }
 
 // ----------------------------------------------------------------------------
 //! unpublish
 void
 ObjectClassAttribute::unpublish(FederateHandle fed)
-    throw (RTIinternalError, SecurityError)
+throw (RTIinternalError, SecurityError)
 {
-    if (isPublishing(fed)) {
-        Debug(D, pdTerm) << "Attribute " << handle << ": Removed Federate " << fed
-		  << " from publishers list." << endl ;
-        deletePublisher(fed);
-    }
-
-    else
-        Debug(D, pdError) << "Attribute " << handle
-		   << ": Inconsistent publish request from Federate "
-		   << fed << endl ;
+	if (isPublishing(fed)) {
+		Debug(D, pdTerm) << "Attribute " << handle << ": Removed Federate " << fed
+				<< " from publishers list." << endl ;
+		deletePublisher(fed);
+	}
+
+	else
+		Debug(D, pdError) << "Attribute " << handle
+		<< ": Inconsistent publish request from Federate "
+		<< fed << endl ;
 }
 
 // ----------------------------------------------------------------------------
 AttributeHandle
 ObjectClassAttribute::getHandle() const
 {
-    return handle ;
+	return handle ;
 }
 
 // ----------------------------------------------------------------------------
 void
 ObjectClassAttribute::setSpace(SpaceHandle h)
 {
-    space = h ;
+	space = h ;
 }
 
 // ----------------------------------------------------------------------------
 SpaceHandle
 ObjectClassAttribute::getSpace() const
 {
-    return space ;
+	return space ;
 }
 
 
@@ -172,22 +172,23 @@
 //! Add all attribute's subscribers to the broadcast list
 void
 ObjectClassAttribute::updateBroadcastList(ObjectClassBroadcastList *ocblist,
-					  const RTIRegion *region)
+		const RTIRegion *region)
 {
-    switch(ocblist->message->getType()) {
+	switch(ocblist->getMsg()->getType()) {
 
-      case NetworkMessage::REFLECT_ATTRIBUTE_VALUES: {
-	  addFederatesIfOverlap(*ocblist, region, handle);
-      } break ;
-      case NetworkMessage::REQUEST_ATTRIBUTE_OWNERSHIP_ASSUMPTION: {
-          PublishersList_t::iterator i ;
-          for (i = publishers.begin(); i != publishers.end(); i++) {
-              ocblist->addFederate(*i, handle);
-          }
-      } break ;
+	case NetworkMessage::REFLECT_ATTRIBUTE_VALUES: {
+		addFederatesIfOverlap(*ocblist, region, handle);
+	}
+	break ;
+	case NetworkMessage::REQUEST_ATTRIBUTE_OWNERSHIP_ASSUMPTION: {
+		PublishersList_t::iterator i ;
+		for (i = publishers.begin(); i != publishers.end(); i++) {
+			ocblist->addFederate(*i, handle);
+		}
+	} break ;
 
-      default: ; // nothing done
-    }
+	default: ; // nothing done
+	}
 }
 
 } // namespace
Index: libCERTI/ObjectClass.cc
===================================================================
RCS file: /sources/certi/certi/libCERTI/ObjectClass.cc,v
retrieving revision 3.78
diff -u -r3.78 ObjectClass.cc
--- libCERTI/ObjectClass.cc	7 Mar 2010 21:30:30 -0000	3.78
+++ libCERTI/ObjectClass.cc	18 Mar 2010 18:31:10 -0000
@@ -105,42 +105,45 @@
 {
     G.Out(pdGendoc,"enter ObjectClass::broadcastClassMessage");
     // 1. Set ObjectHandle to local class Handle.
-    ocbList->message->objectClass = handle ;
+    ocbList->upcastTo(handle) ;
 
     G.Out(pdGendoc,"      ObjectClass::broadcastClassMessage handle=%d",handle);
 
     // 2. Update message attribute list by removing child's attributes.
-    if ((ocbList->message->getType() == NetworkMessage::REFLECT_ATTRIBUTE_VALUES) ||
-        (ocbList->message->getType() == NetworkMessage::REQUEST_ATTRIBUTE_OWNERSHIP_ASSUMPTION)) {
-        for (int attr = 0; attr < ocbList->message->handleArraySize;) {
-            // If the attribute is not in that class, remove it from
-            // the message.
-            if (hasAttribute(ocbList->message->handleArray[attr]))
+    if ((ocbList->getMsg()->getType() == NetworkMessage::REFLECT_ATTRIBUTE_VALUES) ||
+        (ocbList->getMsg()->getType() == NetworkMessage::REQUEST_ATTRIBUTE_OWNERSHIP_ASSUMPTION)) {
+
+        for (uint32_t attr = 0; attr < (ocbList->getMsgRAV()->getAttributesSize());) {
+            // If the attribute is not in that class, remove it from the message.
+            if (hasAttribute(ocbList->getMsgRAV()->getAttributes(attr))) {
                 ++attr;
-            else
-                ocbList->message->removeAttribute(attr);
+            }
+            else {
+                ocbList->getMsgRAV()->removeAttributes(attr);
+            }
         }
     }
 
     // 3. Add class/attributes subscribers to the list.
-    switch(ocbList->message->getType()) {
+    switch(ocbList->getMsg()->getType()) {
       case NetworkMessage::DISCOVER_OBJECT:
       case NetworkMessage::REMOVE_OBJECT: {
           // For each federate, add it to list if at least one attribute has
           // been subscribed.
           FederateHandle federate = 0 ;
           for (federate = 1 ; federate <= maxSubscriberHandle ; federate++) {
-              if (isSubscribed(federate) && (federate != ocbList->message->federate)) {
+              if (isSubscribed(federate) && (federate != (ocbList->getMsg()->federate))) {
                   ocbList->addFederate(federate);
               }
           }
-      } break ;
+      }
+      break ;
 
       case NetworkMessage::REFLECT_ATTRIBUTE_VALUES: {
-          // For each class attribute, update the list be adding federates who
+          // For each class attribute, update the list by adding federates who
           // subscribed to the attribute.
-          for (int i = 0 ; i < ocbList->message->handleArraySize ; ++i) {
-              AttributeHandle attributeHandle = ocbList->message->handleArray[i];
+          for (uint32_t i = 0 ; i < ocbList->getMsgRAV()->getAttributesSize() ; ++i) {
+              AttributeHandle attributeHandle = ocbList->getMsgRAV()->getAttributes(i);
 
               HandleClassAttributeMap::iterator a = _handleClassAttributeMap.find(attributeHandle);
               // May be this is a hard error?
@@ -166,7 +169,7 @@
       } break ;
 
       default:
-        throw RTIinternalError("BroadcastClassMsg: Unknown type.");
+        throw RTIinternalError("BroadcastClassMsg: Unexpected message type.");
     }
 
     // 4. Send pending messages.
@@ -206,7 +209,7 @@
                           Object* object,
                           FederateHandle theFederate,
                           const std::string& theTag,
-                          NetworkMessage::Type type)
+                          NM_Attribute_Ownership_Base& answer)
 {
     int nbAttributes = diffusionList->size ;
 
@@ -214,12 +217,11 @@
     for (int i = 0 ; i < nbAttributes ; i++) {
         toFederate = diffusionList->DiffArray[i].federate ;
         if (toFederate != 0) {
-            std::auto_ptr<NetworkMessage> answer(NM_Factory::create(type));
-            answer->federation = server->federation();
-            answer->federate = theFederate ;
-            answer->object = object->getHandle() ;
-            answer->setLabel(theTag);
-            answer->handleArray.resize(nbAttributes) ;
+            answer.federation = server->federation();
+            answer.federate = theFederate ;
+            answer.setObject(object->getHandle());
+            answer.setLabel(theTag);
+            answer.setAttributesSize(nbAttributes) ;
 
             int index = 0 ;
             for (int j = i ; j < nbAttributes ; j++) {
@@ -227,14 +229,12 @@
                     D.Out(pdDebug, "handle : %u",
                           diffusionList->DiffArray[j].attribute);
                     diffusionList->DiffArray[j].federate = 0 ;
-                    answer->handleArray[index] = diffusionList
-                        ->DiffArray[j].attribute ;
+                    answer.setAttributes(diffusionList->DiffArray[j].attribute,index) ;
                     index++ ;
                 }
             }
-            answer->handleArraySize = index ;
-            D.Out(pdDebug, "Envoi message type %u ", type);
-            sendToFederate(answer.get(), toFederate);
+            D.Out(pdDebug, "Envoi message type %s ", answer.getMessageName());
+            sendToFederate(&answer, toFederate);
         }
     }
 }
@@ -330,12 +330,12 @@
               "Object %u deleted in class %u, now broadcasting...",
               object->getHandle(), handle);
 
-        NetworkMessage *answer = NM_Factory::create(NetworkMessage::REMOVE_OBJECT);
+        NM_Remove_Object *answer = new NM_Remove_Object();
         answer->federation = server->federation();
         answer->federate = the_federate ;
         answer->setException(e_NO_EXCEPTION);
-        answer->objectClass = handle ; // Class Handle
-        answer->object = object->getHandle() ;
+        answer->setObjectClass(handle); // Class Handle FIXME why this
+        answer->setObject(object->getHandle());
 
 	// with time
         answer->setDate(theTime);
@@ -391,14 +391,13 @@
               "Object %u deleted in class %u, now broadcasting...",
               object->getHandle(), handle);
 
-        NetworkMessage *answer = NM_Factory::create(NetworkMessage::REMOVE_OBJECT);
+        NM_Remove_Object *answer = new NM_Remove_Object();
         answer->federation = server->federation();
         answer->federate = the_federate ;
-        answer->objectClass = handle ; // Class Handle
-        answer->object = object->getHandle() ;
+        answer->setObjectClass(handle); // Class Handle FIXME why do we have a class handle in REMOVE OBJECT?
+        answer->setObject(object->getHandle());
 
 	    // without time
-
 	    answer->setLabel(the_tag);
 
         ocbList = new ObjectClassBroadcastList(answer, 0);
@@ -493,7 +492,7 @@
     D.Out(pdExcept, "ObjectClass %d: Attribute %d not defined.",
           handle, the_handle);
 
-    throw AttributeNotDefined("");
+    throw AttributeNotDefined(stringize() << "ObjectClass::getAttribute(AttributeHandle) Attribute <" <<the_handle<<"> unknown for ObjectClass <"<<getName()<<">.");
 }
 
 // ----------------------------------------------------------------------------
@@ -691,8 +690,8 @@
         answer->federation  = server->federation();
         answer->federate    = the_federate ;
         answer->setException(e_NO_EXCEPTION) ;
-        answer->objectClass = handle ; // Class Handle
-        answer->object      = the_object->getHandle();
+        answer->setObjectClass(handle); // Class Handle
+        answer->setObject(the_object->getHandle());
         answer->setLabel(the_object->getName());
 	// BUG FIXME strange!!
 	//answer->setDate(0.0);
@@ -740,8 +739,8 @@
 	    message.federation  = server->federation();
 	    message.federate    = federate ;
 	    message.setException(e_NO_EXCEPTION) ;
-	    message.objectClass = super_handle ;
-	    message.object      = i->second->getHandle();
+	    message.setObjectClass(super_handle);
+	    message.setObject(i->second->getHandle());
 	    message.setLabel(i->second->getName());
 	    //BUG FIXME strange!!
 	    //message.setDate(0.0);
@@ -749,6 +748,7 @@
 	    Socket *socket = NULL ;
 	    try {
 		socket = server->getSocketLink(federate);
+		message.show(std::cerr);
 		message.send(socket,NM_msgBufSend);
 	    }
 	    catch (RTIinternalError &e) {
@@ -786,7 +786,7 @@
  */
 bool
 ObjectClass::subscribe(FederateHandle fed,
-		std::vector <AttributeHandle> &attributes,
+		const std::vector <AttributeHandle> &attributes,
 		int nb_attributes,
 		const RTIRegion *region)
 throw (AttributeNotDefined, RTIinternalError, SecurityError)
@@ -820,8 +820,8 @@
 ObjectClassBroadcastList *
 ObjectClass::updateAttributeValues(FederateHandle the_federate,
                                    Object *object,
-                                   std::vector <AttributeHandle> &the_attributes,
-                                   std::vector <AttributeValue_t> &the_values,
+                                   const std::vector <AttributeHandle> &the_attributes,
+                                   const std::vector <AttributeValue_t> &the_values,
                                    int the_size,
                                    FederationTime the_time,
                                    const std::string& the_tag)
@@ -842,21 +842,20 @@
     // Prepare and Broadcast message for this class
     ObjectClassBroadcastList *ocbList = NULL ;
     if (server != NULL) {
-        NetworkMessage *answer = NM_Factory::create(NetworkMessage::REFLECT_ATTRIBUTE_VALUES);
+    	NM_Reflect_Attribute_Values *answer = new NM_Reflect_Attribute_Values();
         answer->federation = server->federation();
         answer->federate = the_federate ;
         answer->setException(e_NO_EXCEPTION) ;
-        answer->object = object->getHandle();
+        answer->setObject(object->getHandle());
         // with time
         answer->setDate(the_time);
         answer->setLabel(the_tag);
-        answer->handleArray.resize(the_size) ;
-        answer->handleArraySize = the_size ;
-        answer->sizeValueArray(the_size) ;
-
-        for (int i = 0 ; i < the_size ; i++) {
-            answer->handleArray[i] = the_attributes[i] ;
-            answer->valueArray[i] = the_values[i] ;
+        answer->setAttributesSize(the_size) ;
+        answer->setValuesSize(the_size);
+
+        for (int32_t i = 0 ; i < the_size ; i++) {
+            answer->setAttributes(the_attributes[i],i);
+            answer->setValues(the_values[i],i) ;
         }
 
         ocbList = new ObjectClassBroadcastList(answer, _handleClassAttributeMap.size());
@@ -883,8 +882,8 @@
 ObjectClassBroadcastList *
 ObjectClass::updateAttributeValues(FederateHandle the_federate,
                                    Object *object,
-                                   std::vector <AttributeHandle> &the_attributes,
-                                   std::vector <AttributeValue_t> &the_values,
+                                   const std::vector <AttributeHandle> &the_attributes,
+                                   const std::vector <AttributeValue_t> &the_values,
                                    int the_size,
                                    const std::string& the_tag)
     throw (AttributeNotDefined,
@@ -904,22 +903,21 @@
     // Prepare and Broadcast message for this class
     ObjectClassBroadcastList *ocbList = NULL ;
     if (server != NULL) {
-        NetworkMessage *answer = NM_Factory::create(NetworkMessage::REFLECT_ATTRIBUTE_VALUES) ;
+    	NM_Reflect_Attribute_Values *answer = new NM_Reflect_Attribute_Values() ;
         answer->federation = server->federation();
         answer->federate = the_federate ;
         answer->setException(e_NO_EXCEPTION) ;
-        answer->object = object->getHandle();
+        answer->setObject(object->getHandle());
         // without time
 
         answer->setLabel(the_tag);
 
-        answer->handleArraySize = the_size ;
-        answer->handleArray.resize(the_size) ;
-        answer->sizeValueArray(the_size) ;
-
-        for (int i = 0 ; i < the_size ; i++) {
-            answer->handleArray[i] = the_attributes[i] ;
-            answer->valueArray[i] = the_values[i];
+        answer->setAttributesSize(the_size);
+        answer->setValuesSize(the_size);
+
+        for (int32_t i = 0 ; i < the_size ; i++) {
+            answer->setAttributes(the_attributes[i],i);
+            answer->setValues(the_values[i],i);
         }
 
         ocbList = new ObjectClassBroadcastList(answer, _handleClassAttributeMap.size());
@@ -946,7 +944,7 @@
 ObjectClassBroadcastList * ObjectClass::
 negotiatedAttributeOwnershipDivestiture(FederateHandle theFederateHandle,
                                         Object* object,
-                                        std::vector <AttributeHandle> &theAttributeList,
+                                        const std::vector <AttributeHandle> &theAttributeList,
                                         const std::string& theTag)
     throw (AttributeNotDefined,
            AttributeNotOwned,
@@ -985,20 +983,16 @@
     FederateHandle NewOwner ;
 
     if (server != NULL) {
-        NetworkMessage *AnswerAssumption = NM_Factory::create(NetworkMessage::REQUEST_ATTRIBUTE_OWNERSHIP_ASSUMPTION) ;
+    	NM_Request_Attribute_Ownership_Assumption *AnswerAssumption = new NM_Request_Attribute_Ownership_Assumption() ;
         NM_Attribute_Ownership_Divestiture_Notification AnswerDivestiture;
 
-        AnswerAssumption->handleArraySize = theAttributeList.size() ;
-        AnswerAssumption->handleArray.resize(theAttributeList.size()) ;
-
-        // Maximum size
-        AnswerDivestiture.handleArray.resize(theAttributeList.size()) ;
+        AnswerAssumption->setAttributesSize(theAttributeList.size());
 
         CDiffusion diffusionAcquisition;
 
         ObjectAttribute * oa ;
         ObjectClassAttribute * oca ;
-        for (unsigned i = 0 ; i < theAttributeList.size() ; i++) {
+        for (uint32_t i = 0 ; i < theAttributeList.size() ; i++) {
             oa = object->getAttribute(theAttributeList[i]);
 
             if (oa->hasCandidates()) {
@@ -1022,8 +1016,7 @@
                     .attribute = oa->getHandle();
                 compteur_acquisition++ ;
 
-                AnswerDivestiture.handleArray[compteur_divestiture]
-                    = theAttributeList[i] ;
+                AnswerDivestiture.setAttributes(theAttributeList[i],compteur_divestiture);
                 compteur_divestiture++ ;
 
                 if (oca->isNamed("privilegeToDelete")) {
@@ -1031,26 +1024,26 @@
                 }
             }
             else {
-                AnswerAssumption->handleArray[compteur_assumption]
-                    = theAttributeList[i] ;
+                AnswerAssumption->setAttributes(theAttributeList[i],compteur_assumption) ;
                 oa->setDivesting(true);
                 compteur_assumption++ ;
             }
         }
 
         if (compteur_acquisition != 0) {
+        	NM_Attribute_Ownership_Acquisition_Notification AOAN;
             diffusionAcquisition.size = compteur_acquisition ;
             sendToOwners(&diffusionAcquisition, object,
                          theFederateHandle, theTag,
-                         NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION_NOTIFICATION);
+                         AOAN);
         }
 
         if (compteur_divestiture !=0) {
             AnswerDivestiture.federation = server->federation();
             AnswerDivestiture.federate = theFederateHandle ;
-            AnswerDivestiture.object = object->getHandle();
+            AnswerDivestiture.setObject(object->getHandle());
             AnswerDivestiture.setLabel(std::string());
-            AnswerDivestiture.handleArraySize = compteur_divestiture ;
+            AnswerDivestiture.setAttributesSize(compteur_divestiture);
 
             sendToFederate(&AnswerDivestiture, theFederateHandle);
         }
@@ -1059,9 +1052,9 @@
             AnswerAssumption->federation = server->federation();
             AnswerAssumption->federate = theFederateHandle ;
             AnswerAssumption->setException(e_NO_EXCEPTION) ;
-            AnswerAssumption->object = object->getHandle();
+            AnswerAssumption->setObject(object->getHandle());
             AnswerAssumption->setLabel(theTag);
-            AnswerAssumption->handleArraySize = compteur_assumption ;
+            AnswerAssumption->setAttributesSize(compteur_assumption);
 
             List = new ObjectClassBroadcastList(AnswerAssumption,
                                                 _handleClassAttributeMap.size());
@@ -1092,7 +1085,7 @@
 void ObjectClass::
 attributeOwnershipAcquisitionIfAvailable(FederateHandle the_federate,
                                          Object* object,
-                                         std::vector <AttributeHandle> &the_attributes)
+                                         const std::vector <AttributeHandle> &the_attributes)
     throw (ObjectClassNotPublished,
            AttributeNotDefined,
            AttributeNotPublished,
@@ -1130,19 +1123,19 @@
                 throw AttributeAlreadyBeingAcquired("");
         }
 
-        NetworkMessage *Answer_notification = NM_Factory::create(NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION_NOTIFICATION);
+        NM_Attribute_Ownership_Acquisition_Notification *Answer_notification = new NM_Attribute_Ownership_Acquisition_Notification();
         Answer_notification->federation = server->federation();
         Answer_notification->federate = the_federate ;
         Answer_notification->setException(e_NO_EXCEPTION) ;
-        Answer_notification->object = object->getHandle();
-        Answer_notification->handleArray.resize(the_attributes.size()) ;
+        Answer_notification->setObject(object->getHandle());
+        Answer_notification->setAttributesSize(the_attributes.size());
 
-        NetworkMessage *Answer_unavailable = NM_Factory::create(NetworkMessage::ATTRIBUTE_OWNERSHIP_UNAVAILABLE) ;
+        NM_Attribute_Ownership_Unavailable *Answer_unavailable = new NM_Attribute_Ownership_Unavailable();
         Answer_unavailable->federation = server->federation();
         Answer_unavailable->federate = the_federate ;
         Answer_unavailable->setException(e_NO_EXCEPTION) ;
-        Answer_unavailable->object = object->getHandle();
-        Answer_unavailable->handleArray.resize(the_attributes.size()) ;
+        Answer_unavailable->setObject(object->getHandle());
+        Answer_unavailable->setAttributesSize(the_attributes.size()) ;
 
         CDiffusion *diffusionDivestiture = new CDiffusion();
 
@@ -1155,7 +1148,7 @@
         int compteur_divestiture = 0 ;
         FederateHandle oldOwner ;
 
-        for (unsigned i = 0 ; i < the_attributes.size() ; i++) {
+        for (uint32_t i = 0 ; i < the_attributes.size() ; i++) {
             ObjectClassAttribute * oca = getAttribute(the_attributes[i]);
             ObjectAttribute * oa = object->getAttribute(the_attributes[i]);
 
@@ -1171,8 +1164,7 @@
                     compteur_divestiture++ ;
                 }
                 //Qu'il soit offert ou libre
-                Answer_notification->handleArray[compteur_notification]
-                    = the_attributes[i] ;
+                Answer_notification->setAttributes(the_attributes[i],compteur_notification);
                 oa->setOwner(the_federate);
                 oa->setDivesting(false);
                 compteur_notification++ ;
@@ -1183,15 +1175,14 @@
             }
             else {
                 //Cet attribut n'est pas disponible!!!
-                Answer_unavailable->handleArray[compteur_unavailable]
-                    = the_attributes[i] ;
+                Answer_unavailable->setAttributes(the_attributes[i],compteur_unavailable);
                 oa->addCandidate(the_federate);
                 compteur_unavailable++ ;
             }
         }
 
         if (compteur_notification != 0) {
-            Answer_notification->handleArraySize = compteur_notification ;
+            Answer_notification->setAttributesSize(compteur_notification);
             sendToFederate(Answer_notification, the_federate);
         }
         else
@@ -1201,15 +1192,16 @@
               "Debut traitement : send divestiture notification message");
 
         if (compteur_divestiture != 0) {
+        	NM_Attribute_Ownership_Divestiture_Notification AODN;
             diffusionDivestiture->size =compteur_divestiture ;
             sendToOwners(diffusionDivestiture, object,
                          the_federate, "\0",
-                         NetworkMessage::ATTRIBUTE_OWNERSHIP_DIVESTITURE_NOTIFICATION);
+                         AODN);
         }
         delete diffusionDivestiture ;
 
         if (compteur_unavailable != 0) {
-            Answer_unavailable->handleArraySize = compteur_unavailable ;
+            Answer_unavailable->setAttributesSize(compteur_unavailable);
             sendToFederate(Answer_unavailable, the_federate);
         }
         else
@@ -1228,7 +1220,7 @@
 ObjectClassBroadcastList * ObjectClass::
 unconditionalAttributeOwnershipDivestiture(FederateHandle theFederateHandle,
                                            Object* object,
-                                           std::vector <AttributeHandle> &theAttributeList)
+                                           const std::vector <AttributeHandle> &theAttributeList)
     throw (AttributeNotDefined,
            AttributeNotOwned,
            RTIinternalError)
@@ -1256,8 +1248,7 @@
 
     if (server != NULL) {
         AnswerAssumption = new NM_Request_Attribute_Ownership_Assumption();
-        AnswerAssumption->handleArraySize = theAttributeList.size() ;
-        AnswerAssumption->handleArray.resize(theAttributeList.size()) ;
+        AnswerAssumption->setAttributesSize(theAttributeList.size());
         CDiffusion *diffusionAcquisition = new CDiffusion();
 
         for (unsigned i = 0 ; i < theAttributeList.size() ; i++) {
@@ -1290,8 +1281,7 @@
                 }
             }
             else {
-                AnswerAssumption->handleArray[compteur_assumption] =
-                    theAttributeList[i] ;
+                AnswerAssumption->setAttributes(theAttributeList[i],compteur_assumption);
                 oa->setOwner(0);
                 oa->setDivesting(false);
                 compteur_assumption++ ;
@@ -1302,9 +1292,9 @@
             AnswerAssumption->federation = server->federation();
             AnswerAssumption->federate = theFederateHandle ;
             AnswerAssumption->setException(e_NO_EXCEPTION) ;
-            AnswerAssumption->object = object->getHandle() ;
+            AnswerAssumption->setObject(object->getHandle());
             AnswerAssumption->setLabel(std::string());
-            AnswerAssumption->handleArraySize = compteur_assumption ;
+            AnswerAssumption->setAttributesSize(compteur_assumption);
 
             List = new ObjectClassBroadcastList(AnswerAssumption,
                                                 _handleClassAttributeMap.size());
@@ -1319,10 +1309,11 @@
             delete AnswerAssumption ;
 
         if (compteur_acquisition != 0) {
+        	NM_Attribute_Ownership_Acquisition_Notification AOAN;
             diffusionAcquisition->size =compteur_acquisition ;
             sendToOwners(diffusionAcquisition, object,
                          theFederateHandle, "\0",
-                         NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION_NOTIFICATION);
+                         AOAN);
         }
         delete diffusionAcquisition ;
     }
@@ -1343,7 +1334,7 @@
 void
 ObjectClass::attributeOwnershipAcquisition(FederateHandle theFederateHandle,
                                            Object* object,
-                                           std::vector <AttributeHandle> &theAttributeList,
+                                           const std::vector <AttributeHandle> &theAttributeList,
                                            const std::string& theTag)
     throw (ObjectClassNotPublished,
            AttributeNotDefined,
@@ -1375,19 +1366,19 @@
     int compteur_release = 0 ;
     FederateHandle oldOwner ;
     if (server != NULL) {
-        //Le f�d�r� doit publier la classe
+        // The federate have to publish the class
         if (!isFederatePublisher(theFederateHandle)) {
             D.Out(pdExcept, "exception : ObjectClassNotPublished.");
             throw ObjectClassNotPublished("");
         }
 
-        NetworkMessage *AnswerNotification = NM_Factory::create(NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION_NOTIFICATION);
+        NM_Attribute_Ownership_Acquisition_Notification *AnswerNotification = new NM_Attribute_Ownership_Acquisition_Notification();
 
         AnswerNotification->federation = server->federation();
         AnswerNotification->federate = theFederateHandle ;
         AnswerNotification->setException(e_NO_EXCEPTION) ;
-        AnswerNotification->object = object->getHandle() ;
-        AnswerNotification->handleArray.resize(theAttributeList.size()) ;
+        AnswerNotification->setObject(object->getHandle());
+        AnswerNotification->setAttributesSize(theAttributeList.size()) ;
 
         CDiffusion *diffusionDivestiture = new CDiffusion();
 
@@ -1410,13 +1401,12 @@
                 //Qu'il soit offert ou libre
                 if (oa->isCandidate(theFederateHandle))
                     oa->removeCandidate(theFederateHandle);
-                AnswerNotification->handleArray[compteur_notification]
-                    = theAttributeList[i] ;
+                AnswerNotification->setAttributes(theAttributeList[i],compteur_notification) ;
                 oa->setOwner(theFederateHandle);
                 oa->setDivesting(false);
                 compteur_notification++ ;
 
-                // object->Owner reste le champ de r�f�rence pour
+                // object->Owner reste le champ de reference pour
                 // le privilegeToDelete
                 if (oca->isNamed("privilegeToDelete"))
                     object->setOwner(theFederateHandle);
@@ -1427,7 +1417,7 @@
                     oa->getHandle();
                 compteur_release++ ;
 
-                //On l'enl�ve de la liste des demandeurs s'il y �tait
+                //On l'enleve de la liste des demandeurs s'il y �tait
                 oa->removeCandidate(theFederateHandle);
 
                 //pour le rajouter en 1ere position
@@ -1436,24 +1426,26 @@
         }
 
         if (compteur_notification != 0) {
-            AnswerNotification->handleArraySize = compteur_notification ;
+            AnswerNotification->setAttributesSize(compteur_notification);
             sendToFederate(AnswerNotification, theFederateHandle);
         }
         else
             delete AnswerNotification ;
 
         if (compteur_divestiture != 0) {
+        	NM_Attribute_Ownership_Divestiture_Notification AODN;
             diffusionDivestiture->size =compteur_divestiture ;
             sendToOwners(diffusionDivestiture, object,
                          theFederateHandle, "\0",
-                         NetworkMessage::ATTRIBUTE_OWNERSHIP_DIVESTITURE_NOTIFICATION);
+                         AODN);
         }
         delete diffusionDivestiture ;
 
         if (compteur_release != 0) {
+        	NM_Request_Attribute_Ownership_Release RAOR;
             diffusionRelease->size =compteur_release ;
             sendToOwners(diffusionRelease, object, theFederateHandle,
-                         theTag, NetworkMessage::REQUEST_ATTRIBUTE_OWNERSHIP_RELEASE);
+                         theTag, RAOR);
         }
         delete diffusionRelease ;
     }
@@ -1472,7 +1464,7 @@
 ObjectClass::
 attributeOwnershipReleaseResponse(FederateHandle the_federate,
                                   Object* object,
-                                  std::vector <AttributeHandle> &the_attributes)
+                                  const std::vector <AttributeHandle> &the_attributes)
     throw (AttributeNotDefined,
            AttributeNotOwned,
            FederateWasNotAskedToReleaseAttribute,
@@ -1535,9 +1527,10 @@
         }
 
         if (compteur_acquisition != 0) {
+        	NM_Attribute_Ownership_Acquisition_Notification AOAN;
             diffusionAcquisition->size =compteur_acquisition ;
             sendToOwners(diffusionAcquisition, object, the_federate, "\0",
-                         NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION_NOTIFICATION);
+                         AOAN);
         }
         delete diffusionAcquisition ;
     }
@@ -1557,7 +1550,7 @@
 ObjectClass::
 cancelAttributeOwnershipAcquisition(FederateHandle federate_handle,
                                     Object* object,
-                                    std::vector <AttributeHandle> &attribute_list)
+                                    const std::vector <AttributeHandle> &attribute_list)
     throw (AttributeNotDefined,
            AttributeAlreadyOwned,
            AttributeAcquisitionWasNotRequested,
@@ -1588,18 +1581,18 @@
                 throw AttributeAcquisitionWasNotRequested("");
         }
 
-        NetworkMessage *answer_confirmation = NM_Factory::create(NetworkMessage::CONFIRM_ATTRIBUTE_OWNERSHIP_ACQUISITION_CANCELLATION);
+        NM_Confirm_Attribute_Ownership_Acquisition_Cancellation *answer_confirmation = new NM_Confirm_Attribute_Ownership_Acquisition_Cancellation();
         answer_confirmation->federation = server->federation();
         answer_confirmation->federate = federate_handle ;
         answer_confirmation->setException(e_NO_EXCEPTION) ;
-        answer_confirmation->object = object->getHandle() ;
-        answer_confirmation->handleArray.resize(attribute_list.size()) ;
+        answer_confirmation->setObject(object->getHandle());
+        answer_confirmation->setAttributesSize(attribute_list.size()) ;
 
         int compteur_confirmation = 0 ;
         for (unsigned i = 0 ; i < attribute_list.size(); i++) {
             ObjectAttribute * oa = object->getAttribute(attribute_list[i]);
 
-            answer_confirmation->handleArray[compteur_confirmation] = attribute_list[i] ;
+            answer_confirmation->setAttributes(attribute_list[i],compteur_confirmation) ;
 
             // We remove federate from candidates.
             oa->removeCandidate(federate_handle);
@@ -1609,7 +1602,7 @@
         }
 
         if (compteur_confirmation != 0) {
-            answer_confirmation->handleArraySize = compteur_confirmation ;
+            answer_confirmation->setAttributesSize(compteur_confirmation);
             sendToFederate(answer_confirmation, federate_handle);
         }
         else
Index: libCERTI/SocketMC.cc
===================================================================
RCS file: /sources/certi/certi/libCERTI/SocketMC.cc,v
retrieving revision 3.20
diff -u -r3.20 SocketMC.cc
--- libCERTI/SocketMC.cc	7 Mar 2010 18:23:39 -0000	3.20
+++ libCERTI/SocketMC.cc	18 Mar 2010 18:31:12 -0000
@@ -195,6 +195,7 @@
     assert(_est_init_mc);
     assert(message != NULL);
 
+    message->send(this,MCMessageBuffer); // FXIME to be checked
     cnt = sendto(_socket_emetteur, (char *)message, TAILLE_MSG_RESEAU, 0,
                  (struct sockaddr *)&_sin_e, _sinlen_e);
 
Index: libCERTI/NetworkMessage_RW.cc
===================================================================
RCS file: /sources/certi/certi/libCERTI/NetworkMessage_RW.cc,v
retrieving revision 3.55
diff -u -r3.55 NetworkMessage_RW.cc
--- libCERTI/NetworkMessage_RW.cc	24 Nov 2009 19:11:37 -0000	3.55
+++ libCERTI/NetworkMessage_RW.cc	18 Mar 2010 18:31:10 -0000
@@ -39,7 +39,7 @@
 	if ((type==NOT_USED) || (type==LAST)) {
 		throw RTIinternalError("Invalid network type (not a valid type);");
 	}
-	D.Out(pdDebug, "Serialize <%s>", getName());
+	D.Out(pdDebug, "Serialize <%s>", getMessageName());
 	/* type of message */
 	msgBuffer.write_int32(type);
 	msgBuffer.write_int32(exception);
@@ -72,7 +72,7 @@
 	/* We serialize the common Network message part
 	 * ALL Network Messages will contain the following
 	 */
-	Debug(D, pdDebug) << "Deserialize <" << getName() << ">" << endl;
+	Debug(D, pdDebug) << "Deserialize <" << getMessageName() << ">" << endl;
 	/* deserialize common part */
 	type        = static_cast<NetworkMessage::Type>(msgBuffer.read_int32());
 	exception   = static_cast<TypeException>(msgBuffer.read_int32());
@@ -112,7 +112,7 @@
 	serialize(msgBuffer);
 	/* 2- update message buffer 'reserved bytes' header */
 	msgBuffer.updateReservedBytes();
-	D.Out(pdDebug,"Sending <%s> whose buffer has <%u> bytes",getName(),msgBuffer.size());
+	D.Out(pdDebug,"Sending <%s> whose buffer has <%u> bytes",getMessageName(),msgBuffer.size());
 	//msgBuffer.show(msgBuf(0),5);
 	/* 3- effectively send the raw message to socket */
 
Index: RTIG/Federation.cc
===================================================================
RCS file: /sources/certi/certi/RTIG/Federation.cc,v
retrieving revision 3.124
diff -u -r3.124 Federation.cc
--- RTIG/Federation.cc	14 Mar 2010 14:38:27 -0000	3.124
+++ RTIG/Federation.cc	18 Mar 2010 18:31:08 -0000
@@ -89,279 +89,279 @@
 #ifdef FEDERATION_USES_MULTICAST
 
 Federation::Federation(const std::string& federation_name,
-                       FederationHandle federation_handle,
-                       SocketServer &socket_server,
-                       AuditFile &audit_server,
-                       SocketMC *mc_link,
-                       int theVerboseLevel)
+		FederationHandle federation_handle,
+		SocketServer &socket_server,
+		AuditFile &audit_server,
+		SocketMC *mc_link,
+		int theVerboseLevel)
 #else
-    Federation::Federation(const std::string& federation_name,
-                           Handle federation_handle,
-                           SocketServer &socket_server,
-                           AuditFile &audit_server,
-                           const std::string& FEDid_name,
-                           int theVerboseLevel)
+	Federation::Federation(const std::string& federation_name,
+			Handle federation_handle,
+			SocketServer &socket_server,
+			AuditFile &audit_server,
+			const std::string& FEDid_name,
+			int theVerboseLevel)
 #endif
-    throw (CouldNotOpenFED, ErrorReadingFED, MemoryExhausted, SecurityError,
-           RTIinternalError)
-    : federateHandles(1), objectHandles(1), saveInProgress(false),
-      restoreInProgress(false), saveStatus(true), restoreStatus(true),
-      verboseLevel(theVerboseLevel)
+throw (CouldNotOpenFED, ErrorReadingFED, MemoryExhausted, SecurityError,
+		RTIinternalError)
+		: federateHandles(1), objectHandles(1), saveInProgress(false),
+		  restoreInProgress(false), saveStatus(true), restoreStatus(true),
+		  verboseLevel(theVerboseLevel)
 
 {
-    //    fedparser::FedParser *fed_reader ;
-  STAT_STRUCT file_stat;
+	//    fedparser::FedParser *fed_reader ;
+	STAT_STRUCT file_stat;
 
 #ifdef FEDERATION_USES_MULTICAST // -----------------
-    // Initialize Multicast
-    if (mc_link == NULL) {
-        D.Out(pdExcept, "Null Multicast socket for new Federation.");
-        throw RTIinternalError("NULL Multicast socket for new Federation.");
-    }
+	// Initialize Multicast
+	if (mc_link == NULL) {
+		D.Out(pdExcept, "Null Multicast socket for new Federation.");
+		throw RTIinternalError("NULL Multicast socket for new Federation.");
+	}
 
-    D.Out(pdInit, "New Federation %d will use Multicast.", federation_handle);
-    MCLink = mc_link ;
+	D.Out(pdInit, "New Federation %d will use Multicast.", federation_handle);
+	MCLink = mc_link ;
 #endif // FEDERATION_USES_MULTICAST // --------------
 
-    G.Out(pdGendoc,"enter Federation::Federation");
-    // Allocates Name
-    if (federation_name.empty() || (federation_handle == 0))
-        throw RTIinternalError("Null init parameter in Federation creation.");
+	G.Out(pdGendoc,"enter Federation::Federation");
+	// Allocates Name
+	if (federation_name.empty() || (federation_handle == 0))
+		throw RTIinternalError("Null init parameter in Federation creation.");
 
-    name = federation_name;
+	name = federation_name;
 
-    // Default Attribute values
-    handle = federation_handle;
-    FEDid  = FEDid_name;
+	// Default Attribute values
+	handle = federation_handle;
+	FEDid  = FEDid_name;
 
-    D.Out(pdInit, "New Federation created with Handle %d, now reading FOM.",
-          handle);
+	D.Out(pdInit, "New Federation created with Handle %d, now reading FOM.",
+			handle);
 
-    // Initialize the Security Server.
-    server = new SecurityServer(socket_server, audit_server, handle);
+	// Initialize the Security Server.
+	server = new SecurityServer(socket_server, audit_server, handle);
 
-    // Read FOM File to initialize Root Object.
-    root = new RootObject(server);
+	// Read FOM File to initialize Root Object.
+	root = new RootObject(server);
 
 	if (verboseLevel>0) {
 		cout << "New federation: " << name << endl ;
 	}
 
-    // We should try to open FOM file from different
-    // predefined places:
-    //
-    // 1 - bare filename considered as a path provided through FEDid_name
-    //
-    // 2 - getenv(CERTI_HOME)+"/share/federations"+ FEDid_name
-    //
-    // 3 - Installation place plus FEDid_name
-    //     PACKAGE_INSTALL_PREFIX + "/share/federation/" + FEDid_name
+	// We should try to open FOM file from different
+	// predefined places:
+	//
+	// 1 - bare filename considered as a path provided through FEDid_name
+	//
+	// 2 - getenv(CERTI_HOME)+"/share/federations"+ FEDid_name
+	//
+	// 3 - Installation place plus FEDid_name
+	//     PACKAGE_INSTALL_PREFIX + "/share/federation/" + FEDid_name
 	//
 	// 4 - "/usr/local/share/federation/" +  FEDid_name
 	//     last resort Unix-only case [for backward compatibility]
-    //
-    string filename   = FEDid;
-    bool   filefound  = false;
-    if (verboseLevel>0) {
-    	cout << "Looking for FOM file... " << endl ;
-
-    	cout << "   Trying... " << filename;
-    }
-    filefound = (0==STAT_FUNCTION(filename.c_str(),&file_stat));
+	//
+	string filename   = FEDid;
+	bool   filefound  = false;
+	if (verboseLevel>0) {
+		cout << "Looking for FOM file... " << endl ;
+
+		cout << "   Trying... " << filename;
+	}
+	filefound = (0==STAT_FUNCTION(filename.c_str(),&file_stat));
 
 #ifdef _WIN32
-    if (!filefound) {
-      char temp[260];
-      if (verboseLevel>0) {
-    	  cout << " --> cannot access." <<endl;
-      }
-      GetCurrentDirectory(260,temp);
-      filename = string(temp);
-      filename = filename + "\\share\\federations\\"+FEDid_name;
-      if (verboseLevel>0) {
-    	  cout << "   Now trying..." << filename;
-      }
-      filefound = (0==STAT_FUNCTION(filename.c_str(),&file_stat));
-    }
-
-    if (!filefound && (NULL!=getenv("CERTI_HOME"))) {
-      if (verboseLevel>0) {
-    		cout << " --> cannot access." <<endl;
-      }
-      filename = string(getenv("CERTI_HOME"))+"\\share\\federations\\"+FEDid_name;
-      if (verboseLevel>0) {
-        cout << "   Now trying..." << filename;
-      }
-      filefound = (0==STAT_FUNCTION(filename.c_str(),&file_stat));
-    }
-
-    if (!filefound) {
-      if (verboseLevel>0) {
-         cout << " --> cannot access." <<endl;
-      }
-      filename = PACKAGE_INSTALL_PREFIX "\\share\\federations\\"+FEDid_name;
-      if (verboseLevel>0) {
-         cout << "   Now trying..." << filename;
-      }
-      filefound = (0==STAT_FUNCTION(filename.c_str(),&file_stat));
-    }
+	if (!filefound) {
+		char temp[260];
+		if (verboseLevel>0) {
+			cout << " --> cannot access." <<endl;
+		}
+		GetCurrentDirectory(260,temp);
+		filename = string(temp);
+		filename = filename + "\\share\\federations\\"+FEDid_name;
+		if (verboseLevel>0) {
+			cout << "   Now trying..." << filename;
+		}
+		filefound = (0==STAT_FUNCTION(filename.c_str(),&file_stat));
+	}
+
+	if (!filefound && (NULL!=getenv("CERTI_HOME"))) {
+		if (verboseLevel>0) {
+			cout << " --> cannot access." <<endl;
+		}
+		filename = string(getenv("CERTI_HOME"))+"\\share\\federations\\"+FEDid_name;
+		if (verboseLevel>0) {
+			cout << "   Now trying..." << filename;
+		}
+		filefound = (0==STAT_FUNCTION(filename.c_str(),&file_stat));
+	}
+
+	if (!filefound) {
+		if (verboseLevel>0) {
+			cout << " --> cannot access." <<endl;
+		}
+		filename = PACKAGE_INSTALL_PREFIX "\\share\\federations\\"+FEDid_name;
+		if (verboseLevel>0) {
+			cout << "   Now trying..." << filename;
+		}
+		filefound = (0==STAT_FUNCTION(filename.c_str(),&file_stat));
+	}
+#else
+	if (!filefound && (NULL!=getenv("CERTI_HOME"))) {
+		if (verboseLevel>0) {
+			cout << " --> cannot access." <<endl;
+		}
+		filename = string(getenv("CERTI_HOME"))+"/share/federations/"+FEDid_name;
+		if (verboseLevel>0) {
+			cout << "   Now trying..." << filename;
+		}
+		filefound = (0==STAT_FUNCTION(filename.c_str(),&file_stat));
+	}
+
+	if (!filefound) {
+		if (verboseLevel>0) {
+			cout << " --> cannot access." << endl;
+		}
+		filename = PACKAGE_INSTALL_PREFIX "/share/federations/"+FEDid_name;
+		if (verboseLevel>0) {
+			cout << "   Now trying..." << filename;
+		}
+		filefound = (0==STAT_FUNCTION(filename.c_str(),&file_stat));
+	}
+
+	if (!filefound) {
+		if (verboseLevel>0) {
+			cout << " --> cannot access." << endl;
+		}
+		filename = "/usr/local/share/federations/"+FEDid_name;
+		if (verboseLevel>0) {
+			cout << "   Now trying..." << filename;
+		}
+		filefound = (0==STAT_FUNCTION(filename.c_str(),&file_stat));
+	}
+#endif
+
+	if (!filefound) {
+		if (verboseLevel>0) {
+			cout << " --> cannot access." <<endl;
+		}
+		cerr << "Next step will fail"<<endl;
+		G.Out(pdGendoc,"exit Federation::Federation on exception CouldNotOpenFED");
+		throw CouldNotOpenFED("RTIG cannot find FED file.");
+	}
+
+	// now really assign FEDid
+	FEDid = filename;
+
+	// Try to open to verify if file exists
+	std::ifstream fedTry(FEDid.c_str());
+	if (!fedTry.is_open())
+	{
+		if (verboseLevel>0) {
+			cout << "... failed : ";
+		}
+		G.Out(pdGendoc,"exit Federation::Federation on exception CouldNotOpenFED");
+		throw CouldNotOpenFED("RTIG have found but cannot open FED file");
+	}
+	else {
+		if (verboseLevel>0) {
+			cout << "... opened." << endl ;
+		}
+		fedTry.close();
+	}
+
+	int  nbcar_filename = filename.length() ;
+	bool is_a_fed       = false ;
+	bool is_an_xml      = false ;
+
+	// hope there is a . before fed or xml
+	if ( filename[nbcar_filename-4] != '.' )
+	{
+		G.Out(pdGendoc,"exit Federation::Federation on exception CouldNotOpenFED");
+		throw CouldNotOpenFED("Incorrect FED file name, cannot find "
+				"extension (character '.' is missing [or not in reverse 4th place])");
+	}
+
+	string extension = filename.substr(nbcar_filename-3,3) ;
+	D.Out(pdTrace,"filename is: %s (extension is <%s>",filename.c_str(),extension.c_str());
+	if ( !strcasecmp(extension.c_str(),"fed") )
+	{
+		is_a_fed = true ;
+		D.Out(pdTrace, "Trying to use .fed file");
+	}
+	else if  ( !strcasecmp(extension.c_str(),"xml") )
+	{
+		is_an_xml = true ;
+		D.Out(pdTrace, "Trying to use .xml file");
+	}
+	else {
+		G.Out(pdGendoc,"exit Federation::Federation on exception CouldNotOpenFED");
+		throw CouldNotOpenFED("Incorrect FED file name : nor .fed nor .xml file");
+	}
+
+	std::ifstream fedFile(filename.c_str());
+
+	if (fedFile.is_open())
+	{
+		fedFile.close();
+		if ( is_a_fed )
+		{
+			// parse FED file and show the parse on stdout if verboseLevel>=2
+			int err = fedparser::build(filename.c_str(), root, (verboseLevel>=2));
+			if (err != 0 )
+			{
+				G.Out(pdGendoc,"exit Federation::Federation on exception ErrorReadingFED");
+				throw ErrorReadingFED("fed parser found error in FED file");
+			}
+
+			// Retrieve the FED file last modification time(for Audit)
+			STAT_STRUCT StatBuffer ;
+#if defined(_WIN32) && _MSC_VER >= 1400
+			char MTimeBuffer[26];
 #else
-    if (!filefound && (NULL!=getenv("CERTI_HOME"))) {
-      if (verboseLevel>0) {
-         cout << " --> cannot access." <<endl;
-      }
-      filename = string(getenv("CERTI_HOME"))+"/share/federations/"+FEDid_name;
-      if (verboseLevel>0) {
-         cout << "   Now trying..." << filename;
-      }
-      filefound = (0==STAT_FUNCTION(filename.c_str(),&file_stat));
-    }
-
-    if (!filefound) {
-      if (verboseLevel>0) {
-         cout << " --> cannot access." << endl;
-      }
-      filename = PACKAGE_INSTALL_PREFIX "/share/federations/"+FEDid_name;
-      if (verboseLevel>0) {
-         cout << "   Now trying..." << filename;
-      }
-      filefound = (0==STAT_FUNCTION(filename.c_str(),&file_stat));
-    }
-
-    if (!filefound) {
-    	if (verboseLevel>0) {
-    		cout << " --> cannot access." << endl;
-    	}
-    	filename = "/usr/local/share/federations/"+FEDid_name;
-    	if (verboseLevel>0) {
-    		cout << "   Now trying..." << filename;
-    	}
-    	filefound = (0==STAT_FUNCTION(filename.c_str(),&file_stat));
-    }
+			char *MTimeBuffer ;
 #endif
 
-    if (!filefound) {
-      if (verboseLevel>0) {
-        cout << " --> cannot access." <<endl;
-      }
-      cerr << "Next step will fail"<<endl;
-      G.Out(pdGendoc,"exit Federation::Federation on exception CouldNotOpenFED");
-      throw CouldNotOpenFED("RTIG cannot find FED file.");
-    }
-
-    // now really assign FEDid
-    FEDid = filename;
-
-    // Try to open to verify if file exists
-    std::ifstream fedTry(FEDid.c_str());
-    if (!fedTry.is_open())
-        {
-    	if (verboseLevel>0) {
-           cout << "... failed : ";
-    	}
-        G.Out(pdGendoc,"exit Federation::Federation on exception CouldNotOpenFED");
-        throw CouldNotOpenFED("RTIG have found but cannot open FED file");
-        }
-    else {
-    	if (verboseLevel>0) {
-    		cout << "... opened." << endl ;
-    	}
-        fedTry.close();
-    }
-
-    int  nbcar_filename = filename.length() ;
-    bool is_a_fed       = false ;
-    bool is_an_xml      = false ;
-
-    // hope there is a . before fed or xml
-    if ( filename[nbcar_filename-4] != '.' )
-        {
-        G.Out(pdGendoc,"exit Federation::Federation on exception CouldNotOpenFED");
-        throw CouldNotOpenFED("Incorrect FED file name, cannot find "
-         "extension (character '.' is missing [or not in reverse 4th place])");
-        }
-
-    string extension = filename.substr(nbcar_filename-3,3) ;
-    D.Out(pdTrace,"filename is: %s (extension is <%s>",filename.c_str(),extension.c_str());
-    if ( !strcasecmp(extension.c_str(),"fed") )
-        {
-        is_a_fed = true ;
-        D.Out(pdTrace, "Trying to use .fed file");
-        }
-    else if  ( !strcasecmp(extension.c_str(),"xml") )
-        {
-        is_an_xml = true ;
-        D.Out(pdTrace, "Trying to use .xml file");
-        }
-    else {
-        G.Out(pdGendoc,"exit Federation::Federation on exception CouldNotOpenFED");
-        throw CouldNotOpenFED("Incorrect FED file name : nor .fed nor .xml file");
-    }
-
-    std::ifstream fedFile(filename.c_str());
-
-    if (fedFile.is_open())
-        {
-    	fedFile.close();
-        if ( is_a_fed )
-            {
-        	// parse FED file and show the parse on stdout if verboseLevel>=2
-	    int err = fedparser::build(filename.c_str(), root, (verboseLevel>=2));
-	    if (err != 0 )
-                {
-                G.Out(pdGendoc,"exit Federation::Federation on exception ErrorReadingFED");
-                throw ErrorReadingFED("fed parser found error in FED file");
-	        }
-
-            // Retrieve the FED file last modification time(for Audit)
-            STAT_STRUCT StatBuffer ;
-            #if defined(_WIN32) && _MSC_VER >= 1400
-            char MTimeBuffer[26];
-            #else
-            char *MTimeBuffer ;
-            #endif
-
-            if (STAT_FUNCTION(filename.c_str(), &StatBuffer) == 0) {
-            #if defined(_WIN32) && _MSC_VER >= 1400
-                ctime_s(&MTimeBuffer[0],26,&StatBuffer.st_mtime);
-            #else
-                MTimeBuffer = ctime(&StatBuffer.st_mtime);
-            #endif
-                MTimeBuffer[strlen(MTimeBuffer) - 1] = 0 ; // Remove trailing \n
-                server->audit << "(Last modified " << MTimeBuffer << ")" ;
-            }
-            else
-                server->audit << "(could not retrieve last modif time, errno "
-		    	  << errno << ")." ;
-            }
-        else if ( is_an_xml )
-            {
-            if (XmlParser::exists()) {
-                XmlParser *parser = new XmlParser(root);
-                server->audit << ", XML File : " << filename ;
-
-                try {
-                    parser->parse(filename);
-                }
-                catch (Exception *e) {
-                    delete parser ;
-                    delete server ;
-                    server = NULL ;
-                    delete root ;
-                    root = NULL ;
-                    throw e ;
-                }
-                delete parser ;
-            }
-            else {
-                cout << "nor fed nor xml" << endl ;
-                G.Out(pdGendoc,"exit Federation::Federation on exception CouldNotOpenFED");
-		throw CouldNotOpenFED("Incorrect FED file name : nor fed nor xml");
-	    }
-        }
-    }
+			if (STAT_FUNCTION(filename.c_str(), &StatBuffer) == 0) {
+#if defined(_WIN32) && _MSC_VER >= 1400
+				ctime_s(&MTimeBuffer[0],26,&StatBuffer.st_mtime);
+#else
+				MTimeBuffer = ctime(&StatBuffer.st_mtime);
+#endif
+				MTimeBuffer[strlen(MTimeBuffer) - 1] = 0 ; // Remove trailing \n
+				server->audit << "(Last modified " << MTimeBuffer << ")" ;
+			}
+			else
+				server->audit << "(could not retrieve last modif time, errno "
+				<< errno << ")." ;
+		}
+		else if ( is_an_xml )
+		{
+			if (XmlParser::exists()) {
+				XmlParser *parser = new XmlParser(root);
+				server->audit << ", XML File : " << filename ;
+
+				try {
+					parser->parse(filename);
+				}
+				catch (Exception *e) {
+					delete parser ;
+					delete server ;
+					server = NULL ;
+					delete root ;
+					root = NULL ;
+					throw e ;
+				}
+				delete parser ;
+			}
+			else {
+				cout << "nor fed nor xml" << endl ;
+				G.Out(pdGendoc,"exit Federation::Federation on exception CouldNotOpenFED");
+				throw CouldNotOpenFED("Incorrect FED file name : nor fed nor xml");
+			}
+		}
+	}
 
-    G.Out(pdGendoc,"exit Federation::Federation");
+	G.Out(pdGendoc,"exit Federation::Federation");
 
 }
 
@@ -369,21 +369,21 @@
 // Destructor
 Federation::~Federation()
 {
-    D.Out(pdInit, "Destroying Federation %d...", handle);
+	D.Out(pdInit, "Destroying Federation %d...", handle);
 
-    // If there are Federates, delete them all!
-//     for (list<Federate *>::const_iterator i = begin(); i != end(); i++) {
-//         delete(*i);
-//     }
-//     clear();
-
-    // Free local allocations
-    delete root ;
-    delete server ;
+	// If there are Federates, delete them all!
+	//     for (list<Federate *>::const_iterator i = begin(); i != end(); i++) {
+	//         delete(*i);
+	//     }
+	//     clear();
+
+	// Free local allocations
+	delete root ;
+	delete server ;
 
 #ifdef FEDERATION_USES_MULTICAST
-    FermerConnexion(mc_link);
-    delete mc_link ;
+	FermerConnexion(mc_link);
+	delete mc_link ;
 #endif
 
 }
@@ -393,7 +393,7 @@
 int
 Federation::getNbFederates() const
 {
-    return _handleFederateMap.size();
+	return _handleFederateMap.size();
 }
 
 // ----------------------------------------------------------------------------
@@ -401,7 +401,7 @@
 bool
 Federation::isSynchronizing() const
 {
-    return !synchronizationLabels.empty();
+	return !synchronizationLabels.empty();
 }
 
 // ----------------------------------------------------------------------------
@@ -409,7 +409,7 @@
 Handle
 Federation::getHandle() const
 {
-    return handle ;
+	return handle ;
 }
 
 // ----------------------------------------------------------------------------
@@ -417,7 +417,7 @@
 const std::string&
 Federation::getName() const
 {
-    return name;
+	return name;
 }
 
 // ----------------------------------------------------------------------------
@@ -425,7 +425,7 @@
 int
 Federation::getNbRegulators() const
 {
-    return regulators.size();
+	return regulators.size();
 }
 
 // ----------------------------------------------------------------------------
@@ -433,7 +433,7 @@
 const std::string&
 Federation::getFEDid() const
 {
-    return FEDid;
+	return FEDid;
 }
 
 // ----------------------------------------------------------------------------
@@ -441,67 +441,67 @@
   Also send
   Null messages from all others federates to initialize its LBTS, and
   finally a RequestPause message if the Federation is already paused.
-*/
+ */
 FederateHandle
 Federation::add(const std::string& federate_name, SocketTCP *tcp_link)
-    throw (FederateAlreadyExecutionMember, MemoryExhausted, RTIinternalError)
+throw (FederateAlreadyExecutionMember, MemoryExhausted, RTIinternalError)
 {
-    try {
-        getFederate(federate_name);
-        throw FederateAlreadyExecutionMember("");
-    }
-    catch (FederateNotExecutionMember &e) {
-        // Nothing to do.
-    }
-
-    FederateHandle federate_handle = federateHandles.provide();
-    _handleFederateMap.insert(HandleFederateMap::value_type(federate_handle, Federate(federate_name, federate_handle)));
-    Federate& federate = getFederate(federate_handle);
-    D.Out(pdInit, "Federate %d joined Federation %d.", federate_handle, handle);
-
-    // Send, to the newly added federate, a Null message from each regulating
-    // federate (i) with their logical time h(i). This permits to calculate
-    // its LBTS.
-    NM_Message_Null nullMessage;
-    NM_Announce_Synchronization_Point ASPMessage;
-    try {
-	std::vector<LBTS::FederateClock> v ;
-	regulators.get(v);
-
-        for (unsigned int i = 0 ; i < v.size(); ++i) {
-            nullMessage.federation = handle ;
-	        nullMessage.federate = v[i].first ;
-	        nullMessage.setDate(v[i].second);
-            D.Out(pdTerm,
-		  "Sending NULL message(type %d) from %d to new federate.",
-                  nullMessage.getType(), nullMessage.federate);
-
-            nullMessage.send(tcp_link,NM_msgBufSend);
-        }
-
-        // If federation is synchronizing, put federate in same state.
-        if (isSynchronizing()) {
-            ASPMessage.federate = federate_handle ;
-            ASPMessage.federation = handle ;
-
-            std::map<std::string, std::string>::const_iterator i ;
-            i = synchronizationLabels.begin();
-            for (; i != synchronizationLabels.end(); i++) {
-                ASPMessage.setLabel((*i).first);
-                ASPMessage.setTag((*i).second);
-                D.Out(pdTerm, "Sending synchronization message %s (type %d)"
-                      " to the new Federate.", (*i).first.c_str(), ASPMessage.getType());
-
-                ASPMessage.send(tcp_link,NM_msgBufSend);
-                federate.addSynchronizationLabel((*i).first);
-            }
-        }
-    }
-    catch (NetworkError) {
-        throw RTIinternalError("Network Error while initializing federate.");
-    }
+	try {
+		getFederate(federate_name);
+		throw FederateAlreadyExecutionMember("");
+	}
+	catch (FederateNotExecutionMember &e) {
+		// Nothing to do.
+	}
 
-    return federate_handle ;
+	FederateHandle federate_handle = federateHandles.provide();
+	_handleFederateMap.insert(HandleFederateMap::value_type(federate_handle, Federate(federate_name, federate_handle)));
+	Federate& federate = getFederate(federate_handle);
+	D.Out(pdInit, "Federate %d joined Federation %d.", federate_handle, handle);
+
+	// Send, to the newly added federate, a Null message from each regulating
+	// federate (i) with their logical time h(i). This permits to calculate
+	// its LBTS.
+	NM_Message_Null nullMessage;
+	NM_Announce_Synchronization_Point ASPMessage;
+	try {
+		std::vector<LBTS::FederateClock> v ;
+		regulators.get(v);
+
+		for (unsigned int i = 0 ; i < v.size(); ++i) {
+			nullMessage.federation = handle ;
+			nullMessage.federate = v[i].first ;
+			nullMessage.setDate(v[i].second);
+			D.Out(pdTerm,
+					"Sending NULL message(type %d) from %d to new federate.",
+					nullMessage.getType(), nullMessage.federate);
+
+			nullMessage.send(tcp_link,NM_msgBufSend);
+		}
+
+		// If federation is synchronizing, put federate in same state.
+		if (isSynchronizing()) {
+			ASPMessage.federate = federate_handle ;
+			ASPMessage.federation = handle ;
+
+			std::map<std::string, std::string>::const_iterator i ;
+			i = synchronizationLabels.begin();
+			for (; i != synchronizationLabels.end(); i++) {
+				ASPMessage.setLabel((*i).first);
+				ASPMessage.setTag((*i).second);
+				D.Out(pdTerm, "Sending synchronization message %s (type %d)"
+						" to the new Federate.", (*i).first.c_str(), ASPMessage.getType());
+
+				ASPMessage.send(tcp_link,NM_msgBufSend);
+				federate.addSynchronizationLabel((*i).first);
+			}
+		}
+	}
+	catch (NetworkError) {
+		throw RTIinternalError("Network Error while initializing federate.");
+	}
+
+	return federate_handle ;
 }
 
 // ----------------------------------------------------------------------------
@@ -510,420 +510,420 @@
  */
 void
 Federation::addConstrained(FederateHandle federate_handle)
-    throw (FederateNotExecutionMember,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember
-    Federate &federate = getFederate(federate_handle);
-
-    if (federate.isConstrained()) {
-        D.Out(pdExcept, "Federate %d already constrained.", federate_handle);
-        throw RTIinternalError("Time Constrained already enabled.");
-    }
-
-    federate.setConstrained(true);
-    D.Out(pdTerm, "Federation %d: Federate %d is now constrained.",
-          handle, federate_handle);
-}
+throw (FederateNotExecutionMember,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember
+	Federate &federate = getFederate(federate_handle);
+
+	if (federate.isConstrained()) {
+		D.Out(pdExcept, "Federate %d already constrained.", federate_handle);
+		throw RTIinternalError("Time Constrained already enabled.");
+	}
+
+	federate.setConstrained(true);
+	D.Out(pdTerm, "Federation %d: Federate %d is now constrained.",
+			handle, federate_handle);
+		}
 
 // ----------------------------------------------------------------------------
 // Set Class Relevance Advisory Switch
 void
 Federation::setClassRelevanceAdvisorySwitch(FederateHandle federate_handle)
-    throw (FederateNotExecutionMember,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember
-    Federate &federate = getFederate(federate_handle);
-
-    if (federate.isClassRelevanceAdvisorySwitch()) {
-        D.Out(pdExcept, "Federate %d already set CRA switch.", federate_handle);
-        throw RTIinternalError("CRA switch already enabled.");
-    }
-
-    federate.setClassRelevanceAdvisorySwitch(true);
-    D.Out(pdTerm, "Federation %d: Federate %d sets CRA switch.",
-              handle, federate_handle);
-}
+throw (FederateNotExecutionMember,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember
+	Federate &federate = getFederate(federate_handle);
+
+	if (federate.isClassRelevanceAdvisorySwitch()) {
+		D.Out(pdExcept, "Federate %d already set CRA switch.", federate_handle);
+		throw RTIinternalError("CRA switch already enabled.");
+	}
+
+	federate.setClassRelevanceAdvisorySwitch(true);
+	D.Out(pdTerm, "Federation %d: Federate %d sets CRA switch.",
+			handle, federate_handle);
+		}
 
 // ----------------------------------------------------------------------------
 // Set Interaction Relevance Advisory Switch
 void
 Federation::setInteractionRelevanceAdvisorySwitch(FederateHandle federate_handle)
-    throw (FederateNotExecutionMember,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember
-    Federate &federate = getFederate(federate_handle);
-
-    if (federate.isInteractionRelevanceAdvisorySwitch()) {
-        D.Out(pdExcept, "Federate %d already set IRA switch.", federate_handle);
-        throw RTIinternalError("IRA switch already enabled.");
-    }
-
-    federate.setInteractionRelevanceAdvisorySwitch(true);
-    D.Out(pdTerm, "Federation %d: Federate %d sets IRA switch.",
-              handle, federate_handle);
-}
+throw (FederateNotExecutionMember,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember
+	Federate &federate = getFederate(federate_handle);
+
+	if (federate.isInteractionRelevanceAdvisorySwitch()) {
+		D.Out(pdExcept, "Federate %d already set IRA switch.", federate_handle);
+		throw RTIinternalError("IRA switch already enabled.");
+	}
+
+	federate.setInteractionRelevanceAdvisorySwitch(true);
+	D.Out(pdTerm, "Federation %d: Federate %d sets IRA switch.",
+			handle, federate_handle);
+		}
 
 // ----------------------------------------------------------------------------
 // Set Attribute Relevance Advisory Switch
 void
 Federation::setAttributeRelevanceAdvisorySwitch(FederateHandle federate_handle)
-    throw (FederateNotExecutionMember,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember
-    Federate &federate = getFederate(federate_handle);
-
-    if (federate.isAttributeRelevanceAdvisorySwitch()) {
-        D.Out(pdExcept, "Federate %d already set ARA switch.", federate_handle);
-        throw RTIinternalError("ARA switch already enabled.");
-    }
-
-    federate.setAttributeRelevanceAdvisorySwitch(true);
-    D.Out(pdTerm, "Federation %d: Federate %d sets ARA switch.",
-              handle, federate_handle);
-}
+throw (FederateNotExecutionMember,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember
+	Federate &federate = getFederate(federate_handle);
+
+	if (federate.isAttributeRelevanceAdvisorySwitch()) {
+		D.Out(pdExcept, "Federate %d already set ARA switch.", federate_handle);
+		throw RTIinternalError("ARA switch already enabled.");
+	}
+
+	federate.setAttributeRelevanceAdvisorySwitch(true);
+	D.Out(pdTerm, "Federation %d: Federate %d sets ARA switch.",
+			handle, federate_handle);
+		}
 
 // ----------------------------------------------------------------------------
 // Set Attribute Scope Advisory Switch
 void
 Federation::setAttributeScopeAdvisorySwitch(FederateHandle federate_handle)
-    throw (FederateNotExecutionMember,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember
-    Federate &federate = getFederate(federate_handle);
-
-    if (federate.isAttributeScopeAdvisorySwitch()) {
-        D.Out(pdExcept, "Federate %d already set ASA switch.", federate_handle);
-        throw RTIinternalError("ASA switch already enabled.");
-    }
-
-    federate.setAttributeScopeAdvisorySwitch(true);
-    D.Out(pdTerm, "Federation %d: Federate %d sets ASA switch.",
-              handle, federate_handle);
-}
+throw (FederateNotExecutionMember,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember
+	Federate &federate = getFederate(federate_handle);
+
+	if (federate.isAttributeScopeAdvisorySwitch()) {
+		D.Out(pdExcept, "Federate %d already set ASA switch.", federate_handle);
+		throw RTIinternalError("ASA switch already enabled.");
+	}
+
+	federate.setAttributeScopeAdvisorySwitch(true);
+	D.Out(pdTerm, "Federation %d: Federate %d sets ASA switch.",
+			handle, federate_handle);
+		}
 
 // ----------------------------------------------------------------------------
 // Clear Class Relevance Advisory Switch
 void
 Federation::unsetClassRelevanceAdvisorySwitch(FederateHandle federate_handle)
-    throw (FederateNotExecutionMember,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember
-    Federate &federate = getFederate(federate_handle);
-
-    if (!federate.isClassRelevanceAdvisorySwitch()) {
-        D.Out(pdExcept, "Federate %d did not set CRA switch.", federate_handle);
-        throw RTIinternalError("CRA switch not enabled.");
-    }
-
-    federate.setClassRelevanceAdvisorySwitch(false);
-    D.Out(pdTerm, "Federation %d: Federate %d clears CRA switch.",
-              handle, federate_handle);
-}
+throw (FederateNotExecutionMember,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember
+	Federate &federate = getFederate(federate_handle);
+
+	if (!federate.isClassRelevanceAdvisorySwitch()) {
+		D.Out(pdExcept, "Federate %d did not set CRA switch.", federate_handle);
+		throw RTIinternalError("CRA switch not enabled.");
+	}
+
+	federate.setClassRelevanceAdvisorySwitch(false);
+	D.Out(pdTerm, "Federation %d: Federate %d clears CRA switch.",
+			handle, federate_handle);
+		}
 
 // ----------------------------------------------------------------------------
 // Clear Interaction Relevance Advisory Switch
 void
 Federation::unsetInteractionRelevanceAdvisorySwitch(FederateHandle federate_handle)
-    throw (FederateNotExecutionMember,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember
-    Federate &federate = getFederate(federate_handle);
-
-    if (!federate.isInteractionRelevanceAdvisorySwitch()) {
-        D.Out(pdExcept, "Federate %d did not set IRA switch.", federate_handle);
-        throw RTIinternalError("IRA switch not enabled.");
-    }
-
-    federate.setInteractionRelevanceAdvisorySwitch(false);
-    D.Out(pdTerm, "Federation %d: Federate %d clears IRA switch.",
-              handle, federate_handle);
-}
+throw (FederateNotExecutionMember,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember
+	Federate &federate = getFederate(federate_handle);
+
+	if (!federate.isInteractionRelevanceAdvisorySwitch()) {
+		D.Out(pdExcept, "Federate %d did not set IRA switch.", federate_handle);
+		throw RTIinternalError("IRA switch not enabled.");
+	}
+
+	federate.setInteractionRelevanceAdvisorySwitch(false);
+	D.Out(pdTerm, "Federation %d: Federate %d clears IRA switch.",
+			handle, federate_handle);
+		}
 
 // ----------------------------------------------------------------------------
 // Clear Attribute Relevance Advisory Switch
 void
 Federation::unsetAttributeRelevanceAdvisorySwitch(FederateHandle federate_handle)
-    throw (FederateNotExecutionMember,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember
-    Federate &federate = getFederate(federate_handle);
-
-    if (!federate.isAttributeRelevanceAdvisorySwitch()) {
-        D.Out(pdExcept, "Federate %d did not set ARA switch.", federate_handle);
-        throw RTIinternalError("ARA switch not enabled.");
-    }
-
-    federate.setAttributeRelevanceAdvisorySwitch(false);
-    D.Out(pdTerm, "Federation %d: Federate %d clears ARA switch.",
-              handle, federate_handle);
-}
+throw (FederateNotExecutionMember,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember
+	Federate &federate = getFederate(federate_handle);
+
+	if (!federate.isAttributeRelevanceAdvisorySwitch()) {
+		D.Out(pdExcept, "Federate %d did not set ARA switch.", federate_handle);
+		throw RTIinternalError("ARA switch not enabled.");
+	}
+
+	federate.setAttributeRelevanceAdvisorySwitch(false);
+	D.Out(pdTerm, "Federation %d: Federate %d clears ARA switch.",
+			handle, federate_handle);
+		}
 
 // ----------------------------------------------------------------------------
 //  Clear Attribute Scope Advisory Switch
 void
 Federation::unsetAttributeScopeAdvisorySwitch(FederateHandle federate_handle)
-    throw (FederateNotExecutionMember,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember
-    Federate &federate = getFederate(federate_handle);
-
-    if (!federate.isAttributeScopeAdvisorySwitch()) {
-        D.Out(pdExcept, "Federate %d did not set ASA switch.", federate_handle);
-        throw RTIinternalError("ASA switch not enabled.");
-    }
-
-    federate.setAttributeScopeAdvisorySwitch(false);
-    D.Out(pdTerm, "Federation %d: Federate %d clears ASA switch.",
-              handle, federate_handle);
-}
+throw (FederateNotExecutionMember,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember
+	Federate &federate = getFederate(federate_handle);
+
+	if (!federate.isAttributeScopeAdvisorySwitch()) {
+		D.Out(pdExcept, "Federate %d did not set ASA switch.", federate_handle);
+		throw RTIinternalError("ASA switch not enabled.");
+	}
+
+	federate.setAttributeScopeAdvisorySwitch(false);
+	D.Out(pdTerm, "Federation %d: Federate %d clears ASA switch.",
+			handle, federate_handle);
+		}
 
 // ----------------------------------------------------------------------------
 //! Add the Federate to the Regulators List.
 /*! Check if it's already present, but not if the Time 'theTime' is allowed
   or not.
-*/
+ */
 void
 Federation::addRegulator(FederateHandle federate_handle, FederationTime time)
-    throw (FederateNotExecutionMember,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember
-    Federate &federate = getFederate(federate_handle);
-
-    // It may throw RTIinternalError if Federate was not regulators.
-    regulators.insert(federate_handle, time);
-    federate.setRegulator(true);
-
-    D.Out(pdTerm, "Federation %d: Federate %d is now a regulator(Time=%f).",
-          handle, federate_handle, time.getTime());
-
-    NM_Set_Time_Regulating msg ;
-    msg.setException(e_NO_EXCEPTION);
-    msg.federation = handle ;
-    msg.federate = federate_handle ;
-    msg.regulatorOn();
-    msg.setDate(time);
+throw (FederateNotExecutionMember,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember
+	Federate &federate = getFederate(federate_handle);
+
+	// It may throw RTIinternalError if Federate was not regulators.
+	regulators.insert(federate_handle, time);
+	federate.setRegulator(true);
+
+	D.Out(pdTerm, "Federation %d: Federate %d is now a regulator(Time=%f).",
+			handle, federate_handle, time.getTime());
+
+	NM_Set_Time_Regulating msg ;
+	msg.setException(e_NO_EXCEPTION);
+	msg.federation = handle ;
+	msg.federate = federate_handle ;
+	msg.regulatorOn();
+	msg.setDate(time);
 
-    this->broadcastAnyMessage(&msg, 0);
-}
+	this->broadcastAnyMessage(&msg, 0);
+		}
 
 void
 Federation::getFOM(NM_Join_Federation_Execution& objectModelData)
 {
-    root->convertToSerializedFOM(objectModelData);
+	root->convertToSerializedFOM(objectModelData);
 }
 
 // ----------------------------------------------------------------------------
 //! Broadcast 'msg' to all Federate except the specified one
 void
 Federation::broadcastAnyMessage(NetworkMessage *msg,
-                                FederateHandle except_federate)
+		FederateHandle except_federate)
 {
-    Socket *socket = NULL ;
+	Socket *socket = NULL ;
 
-    // Broadcast the message 'msg' to all Federates in the Federation
-    // except to Federate whose Handle is 'Except_Federate'.
-    for (HandleFederateMap::iterator i = _handleFederateMap.begin(); i != _handleFederateMap.end(); ++i) {
-        if (i->first != except_federate) {
-            try {
+	// Broadcast the message 'msg' to all Federates in the Federation
+	// except to Federate whose Handle is 'Except_Federate'.
+	for (HandleFederateMap::iterator i = _handleFederateMap.begin(); i != _handleFederateMap.end(); ++i) {
+		if (i->first != except_federate) {
+			try {
 #ifdef HLA_USES_UDP
-                socket = server->getSocketLink(i->second.getHandle(), BEST_EFFORT);
+				socket = server->getSocketLink(i->second.getHandle(), BEST_EFFORT);
 #else
-                socket = server->getSocketLink(i->second.getHandle());
+				socket = server->getSocketLink(i->second.getHandle());
 #endif
-                msg->send(socket,NM_msgBufSend);
-            }
-            catch (RTIinternalError &e) {
-                Debug(D, pdExcept) << "Reference to a killed Federate while "
-                            << "broadcasting." << endl ;
-            }
-            catch (NetworkError &e) {
-                D.Out(pdExcept, "Network error while broadcasting, ignoring.");
-            }
-        }
-    }
+				msg->send(socket,NM_msgBufSend);
+			}
+			catch (RTIinternalError &e) {
+				Debug(D, pdExcept) << "Reference to a killed Federate while "
+						<< "broadcasting." << endl ;
+			}
+			catch (NetworkError &e) {
+				D.Out(pdExcept, "Network error while broadcasting, ignoring.");
+			}
+		}
+	}
 
-    // BUG: If except = 0, could use Multicast.
+	// BUG: If except = 0, could use Multicast.
 }
 
 // ----------------------------------------------------------------------------
 //! Broadcast 'msg' to some Federates except the specified one
 void
 Federation::broadcastSomeMessage(NetworkMessage *msg,
-                                FederateHandle except_federate,
-                                std::vector <FederateHandle> &fede_array,
-                                int nbfed)
-{
-    int ifed ;
-    Socket *socket = NULL ;
-
-    if ( fede_array.size() != 0 || nbfed == 0)
-        {
-        // Broadcast the message 'msg' to some Federates (done in fede_array)
-        // in the Federation
-        // except to Federate whose Handle is 'Except_Federate'.
-        for (HandleFederateMap::iterator i = _handleFederateMap.begin(); i != _handleFederateMap.end(); ++i)
-            {
-            if (i->second.getHandle() != except_federate)
-                {
-                ifed = 0 ;
-                while ( ifed < nbfed )
-                    {
-                    if ( i->second.getHandle() == fede_array[ifed] )
-                        // Federate i has to be informed because into fede_array
-                        {
-                        try
-                            {
+		FederateHandle except_federate,
+		const std::vector <FederateHandle> &fede_array,
+		uint32_t nbfed)
+{
+	uint32_t ifed ;
+	Socket *socket = NULL ;
+
+	if ( fede_array.size() != 0 || nbfed == 0)
+	{
+		// Broadcast the message 'msg' to some Federates (done in fede_array)
+		// in the Federation
+		// except to Federate whose Handle is 'Except_Federate'.
+		for (HandleFederateMap::iterator i = _handleFederateMap.begin(); i != _handleFederateMap.end(); ++i)
+		{
+			if (i->second.getHandle() != except_federate)
+			{
+				ifed = 0 ;
+				while ( ifed < nbfed )
+				{
+					if ( i->second.getHandle() == fede_array[ifed] )
+						// Federate i has to be informed because into fede_array
+						{
+						try
+						{
 #ifdef HLA_USES_UDP
-                            socket = server->getSocketLink(i->second.getHandle(), BEST_EFFORT);
+							socket = server->getSocketLink(i->second.getHandle(), BEST_EFFORT);
 #else
-                            socket = server->getSocketLink(i->second.getHandle());
+							socket = server->getSocketLink(i->second.getHandle());
 #endif
-                            msg->send(socket,NM_msgBufSend);
-                            }
-                        catch (RTIinternalError &e)
-                            {
-                            Debug(D, pdExcept) << "Reference to a killed Federate while "
-                                        << "broadcasting." << endl ;
-                            }
-                        catch (NetworkError &e)
-                            {
-                            D.Out(pdExcept, "Network error while broadcasting, ignoring.");
-                            }
-                        }
-                    ifed++;
-                    }
-                }
-            }
-        }
+							msg->send(socket,NM_msgBufSend);
+						}
+						catch (RTIinternalError &e)
+						{
+							Debug(D, pdExcept) << "Reference to a killed Federate while "
+									<< "broadcasting." << endl ;
+						}
+						catch (NetworkError &e)
+						{
+							D.Out(pdExcept, "Network error while broadcasting, ignoring.");
+						}
+						}
+					ifed++;
+				}
+			}
+		}
+	}
 
-    // BUG: If except = 0, could use Multicast.
+	// BUG: If except = 0, could use Multicast.
 }
 
 // ----------------------------------------------------------------------------
 //! broadcastInteraction with time
 void
 Federation::broadcastInteraction(FederateHandle federate_handle,
-                                 InteractionClassHandle interaction,
-                                 std::vector <ParameterHandle> &parameter_handles,
-                                 std::vector <ParameterValue_t> &parameter_values,
-                                 uint16_t list_size,
-                                 FederationTime time,
-				 RegionHandle region_handle,
-                                 const std::string& tag)
-    throw (FederateNotExecutionMember,
-           FederateNotPublishing,
-           InteractionClassNotDefined,
-           InteractionParameterNotDefined,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-
-    G.Out(pdGendoc,"enter Federation::broadcastInteraction with time");
-
-    // It may throw FederateNotExecutionMember.
-    this->check(federate_handle);
-
-    const RTIRegion *region = 0 ;
-    if (region_handle != 0)
-	region = root->getRegion(region_handle);
-
-    root->Interactions->broadcastInteraction(federate_handle,
-                                             interaction,
-                                             parameter_handles,
-                                             parameter_values,
-                                             list_size,
-                                             time,
-					     region,
-                                             tag);
-    D.Out(pdRequest, "Federation %d: Broadcasted Interaction %d from Federate "
-          "%d nb params %d.", handle, interaction, federate_handle, list_size);
-    for (int i=0 ; i < list_size ; i++)
-        D.Out(pdRequest,
-              " Param %d Value %s",
-              parameter_handles[i],
-              parameter_values[i].c_str());
+		InteractionClassHandle interaction,
+		const std::vector <ParameterHandle> &parameter_handles,
+		const std::vector <ParameterValue_t> &parameter_values,
+		uint16_t list_size,
+		FederationTime time,
+		RegionHandle region_handle,
+		const std::string& tag)
+throw (FederateNotExecutionMember,
+		FederateNotPublishing,
+		InteractionClassNotDefined,
+		InteractionParameterNotDefined,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+
+	G.Out(pdGendoc,"enter Federation::broadcastInteraction with time");
+
+	// It may throw FederateNotExecutionMember.
+	this->check(federate_handle);
+
+	const RTIRegion *region = 0 ;
+	if (region_handle != 0)
+		region = root->getRegion(region_handle);
+
+	root->Interactions->broadcastInteraction(federate_handle,
+			interaction,
+			parameter_handles,
+			parameter_values,
+			list_size,
+			time,
+			region,
+			tag);
+	D.Out(pdRequest, "Federation %d: Broadcasted Interaction %d from Federate "
+			"%d nb params %d.", handle, interaction, federate_handle, list_size);
+	for (int i=0 ; i < list_size ; i++)
+		D.Out(pdRequest,
+				" Param %d Value %s",
+				parameter_handles[i],
+				parameter_values[i].c_str());
 
-    G.Out(pdGendoc,"exit Federation::broadcastInteraction with time");
+	G.Out(pdGendoc,"exit Federation::broadcastInteraction with time");
 
-}
+		}
 
 // ----------------------------------------------------------------------------
 //! broadcastInteraction without time
 void
 Federation::broadcastInteraction(FederateHandle federate_handle,
-                                 InteractionClassHandle interaction,
-                                 std::vector <ParameterHandle> &parameter_handles,
-                                 std::vector <ParameterValue_t> &parameter_values,
-                                 uint16_t list_size,
-				 RegionHandle region_handle,
-                                 const std::string& tag)
-    throw (FederateNotExecutionMember,
-           FederateNotPublishing,
-           InteractionClassNotDefined,
-           InteractionParameterNotDefined,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-
-    G.Out(pdGendoc,"enter Federation::broadcastInteraction without time");
-
-    // It may throw FederateNotExecutionMember.
-    this->check(federate_handle);
-
-    const RTIRegion *region = 0 ;
-    if (region_handle != 0)
-	region = root->getRegion(region_handle);
-
-    root->Interactions->broadcastInteraction(federate_handle,
-                                             interaction,
-                                             parameter_handles,
-                                             parameter_values,
-                                             list_size,
-					     region,
-                                             tag);
-    D.Out(pdRequest, "Federation %d: Broadcasted Interaction %d from Federate "
-          "%d nb params %d.", handle, interaction, federate_handle, list_size);
-    for (int i=0 ; i < list_size ; i++)
-        D.Out(pdRequest,
-              " Param %d Value %s",
-              parameter_handles[i],
-              parameter_values[i].c_str());
+		InteractionClassHandle interaction,
+		const std::vector <ParameterHandle> &parameter_handles,
+		const std::vector <ParameterValue_t> &parameter_values,
+		uint16_t list_size,
+		RegionHandle region_handle,
+		const std::string& tag)
+throw (FederateNotExecutionMember,
+		FederateNotPublishing,
+		InteractionClassNotDefined,
+		InteractionParameterNotDefined,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+
+	G.Out(pdGendoc,"enter Federation::broadcastInteraction without time");
+
+	// It may throw FederateNotExecutionMember.
+	this->check(federate_handle);
+
+	const RTIRegion *region = 0 ;
+	if (region_handle != 0)
+		region = root->getRegion(region_handle);
+
+	root->Interactions->broadcastInteraction(federate_handle,
+			interaction,
+			parameter_handles,
+			parameter_values,
+			list_size,
+			region,
+			tag);
+	D.Out(pdRequest, "Federation %d: Broadcasted Interaction %d from Federate "
+			"%d nb params %d.", handle, interaction, federate_handle, list_size);
+	for (int i=0 ; i < list_size ; i++)
+		D.Out(pdRequest,
+				" Param %d Value %s",
+				parameter_handles[i],
+				parameter_values[i].c_str());
 
-    G.Out(pdGendoc,"exit Federation::broadcastInteraction without time");
+	G.Out(pdGendoc,"exit Federation::broadcastInteraction without time");
 
-}
+		}
 
 // ----------------------------------------------------------------------------
 /** Removes an object instance from federation.
@@ -934,26 +934,26 @@
  */
 void
 Federation::deleteObject(FederateHandle federate,
-                         ObjectHandle id,
-			 FederationTime theTime,
-                         const std::string& tag)
-    throw (FederateNotExecutionMember,
-           DeletePrivilegeNotHeld,
-           ObjectNotKnown,
-           SaveInProgress,
-           RestoreInProgress,
-	   InvalidFederationTime,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember.
-    this->check(federate);
-
-    D.Out(pdRegister, "Federation %d: Federate %d destroys object %d.",
-          this->handle, federate, id);
-
-    root->deleteObjectInstance(federate, id, theTime, tag);
-    objectHandles.free(id);
-}
+		ObjectHandle id,
+		FederationTime theTime,
+		const std::string& tag)
+throw (FederateNotExecutionMember,
+		DeletePrivilegeNotHeld,
+		ObjectNotKnown,
+		SaveInProgress,
+		RestoreInProgress,
+		InvalidFederationTime,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember.
+	this->check(federate);
+
+	D.Out(pdRegister, "Federation %d: Federate %d destroys object %d.",
+			this->handle, federate, id);
+
+	root->deleteObjectInstance(federate, id, theTime, tag);
+	objectHandles.free(id);
+		}
 // ----------------------------------------------------------------------------
 /** Removes an object instance from federation.
     @param federate Federate requesting removal
@@ -962,178 +962,178 @@
  */
 void
 Federation::deleteObject(FederateHandle federate,
-                         ObjectHandle id,
-                         const std::string& tag)
-    throw (FederateNotExecutionMember,
-           DeletePrivilegeNotHeld,
-           ObjectNotKnown,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember.
-    this->check(federate);
-
-    D.Out(pdRegister, "Federation %d: Federate %d destroys object %d.",
-          this->handle, federate, id);
-
-    root->deleteObjectInstance(federate, id, tag);
-    objectHandles.free(id);
-}
+		ObjectHandle id,
+		const std::string& tag)
+throw (FederateNotExecutionMember,
+		DeletePrivilegeNotHeld,
+		ObjectNotKnown,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember.
+	this->check(federate);
+
+	D.Out(pdRegister, "Federation %d: Federate %d destroys object %d.",
+			this->handle, federate, id);
+
+	root->deleteObjectInstance(federate, id, tag);
+	objectHandles.free(id);
+		}
 
 // ----------------------------------------------------------------------------
 //! Add a new synchronization point to federation.
 void
 Federation::registerSynchronization(FederateHandle federate,
-                                    const std::string& label,
-                                    const std::string& tag)
-    throw (FederateNotExecutionMember,
-           FederationAlreadyPaused,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-
-    G.Out(pdGendoc,"enter Federation::registerSynchronization for all federates");
-
-    this->check(federate); // It may throw FederateNotExecutionMember.
-
-    if (label.empty())
-        throw RTIinternalError("Bad pause label(null).");
-
-    // Verify label does not already exists
-    std::map<std::string, std::string>::const_iterator i = synchronizationLabels.find(label);
-    if (i != synchronizationLabels.end()) {
-        throw FederationAlreadyPaused(""); // Label already pending.
-    }
+		const std::string& label,
+		const std::string& tag)
+throw (FederateNotExecutionMember,
+		FederationAlreadyPaused,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+
+	G.Out(pdGendoc,"enter Federation::registerSynchronization for all federates");
+
+	this->check(federate); // It may throw FederateNotExecutionMember.
+
+	if (label.empty())
+		throw RTIinternalError("Bad pause label(null).");
+
+	// Verify label does not already exists
+	std::map<std::string, std::string>::const_iterator i = synchronizationLabels.find(label);
+	if (i != synchronizationLabels.end()) {
+		throw FederationAlreadyPaused(""); // Label already pending.
+	}
 
-    // If not already in pending labels, insert to list.
-    synchronizationLabels.insert(pair<const std::string, std::string>(label, tag));
+	// If not already in pending labels, insert to list.
+	synchronizationLabels.insert(pair<const std::string, std::string>(label, tag));
 
-    // Add label to each federate (may throw RTIinternalError).
-    for (HandleFederateMap::iterator i = _handleFederateMap.begin(); i != _handleFederateMap.end(); ++i) {
-        i->second.addSynchronizationLabel(label);
-    }
+	// Add label to each federate (may throw RTIinternalError).
+	for (HandleFederateMap::iterator i = _handleFederateMap.begin(); i != _handleFederateMap.end(); ++i) {
+		i->second.addSynchronizationLabel(label);
+	}
 
-    Debug(D, pdTerm) << "Federation " << handle << " is now synchronizing for label "
-              << label << endl ;
+	Debug(D, pdTerm) << "Federation " << handle << " is now synchronizing for label "
+			<< label << endl ;
 
-    G.Out(pdGendoc,"exit  Federation::registerSynchronization for all federates");
-} /* end of Federation::registerSynchronization */
+	G.Out(pdGendoc,"exit  Federation::registerSynchronization for all federates");
+		} /* end of Federation::registerSynchronization */
 
 // ----------------------------------------------------------------------------
 //! Add a new synchronization point (with federates set) to federation.
 void
 Federation::registerSynchronization(FederateHandle federate,
-                                    const std::string& label,
-                                    const std::string& tag,
-                                    unsigned short federate_setSize,
-                                    std::vector <FederateHandle> &federate_set)
-    throw (FederateNotExecutionMember,
-           FederationAlreadyPaused,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-
-    G.Out(pdGendoc,"enter Federation::registerSynchronization for federate set");
-
-    this->check(federate); // It may throw FederateNotExecutionMember.
-
-    if (label.empty())
-        throw RTIinternalError("Bad pause label(null).");
-
-    // Verify label does not already exists
-    std::map<std::string, std::string>::const_iterator i = synchronizationLabels.find(label);
-    if (i != synchronizationLabels.end()) {
-        throw FederationAlreadyPaused(""); // Label already pending.
-    }
-
-    // If not already in pending labels, insert to list.
-    synchronizationLabels.insert(pair<const std::string, std::string>(label, tag));
-
-    // Add label to each federate into the set only (may throw RTIinternalError).
-    for (int i=0 ; i < federate_setSize  ;i++ )
-        {
-        for (HandleFederateMap::iterator j = _handleFederateMap.begin(); j != _handleFederateMap.end(); ++j)
-            {
-            if ( (federate_set[i] == j->second.getHandle()) || (federate == j->second.getHandle()) )
-                             j->second.addSynchronizationLabel(label);
-            }
-        }
+		const std::string& label,
+		const std::string& tag,
+		unsigned short federate_setSize,
+		const std::vector <FederateHandle> &federate_set)
+throw (FederateNotExecutionMember,
+		FederationAlreadyPaused,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+
+	G.Out(pdGendoc,"enter Federation::registerSynchronization for federate set");
+
+	this->check(federate); // It may throw FederateNotExecutionMember.
+
+	if (label.empty())
+		throw RTIinternalError("Bad pause label(null).");
+
+	// Verify label does not already exists
+	std::map<std::string, std::string>::const_iterator i = synchronizationLabels.find(label);
+	if (i != synchronizationLabels.end()) {
+		throw FederationAlreadyPaused(""); // Label already pending.
+	}
 
-    Debug(D, pdTerm) << "Federation " << handle << " is now synchronizing for label "
-              << label << endl ;
+	// If not already in pending labels, insert to list.
+	synchronizationLabels.insert(pair<const std::string, std::string>(label, tag));
 
-    G.Out(pdGendoc,"exit  Federation::registerSynchronization for federate set");
+	// Add label to each federate into the set only (may throw RTIinternalError).
+	for (int i=0 ; i < federate_setSize  ;i++ )
+	{
+		for (HandleFederateMap::iterator j = _handleFederateMap.begin(); j != _handleFederateMap.end(); ++j)
+		{
+			if ( (federate_set[i] == j->second.getHandle()) || (federate == j->second.getHandle()) )
+				j->second.addSynchronizationLabel(label);
+		}
+	}
 
-}
+	Debug(D, pdTerm) << "Federation " << handle << " is now synchronizing for label "
+			<< label << endl ;
+
+	G.Out(pdGendoc,"exit  Federation::registerSynchronization for federate set");
+
+		}
 
 // ----------------------------------------------------------------------------
 /*! Broadcast an 'Announce Synchronization Point' when registering a new
   synchronization point.
-*/
+ */
 void
 Federation::broadcastSynchronization(FederateHandle federate,
-                                     const std::string& label,
-                                     const std::string& tag)
-    throw (RTIinternalError)
+		const std::string& label,
+		const std::string& tag)
+throw (RTIinternalError)
 {
 
-    G.Out(pdGendoc,"enter Federation::broadcastSynchronization");
+	G.Out(pdGendoc,"enter Federation::broadcastSynchronization");
 
-    this->check(federate); // It may throw FederateNotExecutionMember.
+	this->check(federate); // It may throw FederateNotExecutionMember.
 
-    if (label.empty())
-        throw RTIinternalError("Bad pause label(null).");
+	if (label.empty())
+		throw RTIinternalError("Bad pause label(null).");
 
-    // broadcast announceSynchronizationPoint() to all federates in federation.
-    NM_Announce_Synchronization_Point msg ;
-    msg.federate = federate ;
-    msg.federation = handle ;
-    msg.setLabel(label);
-    msg.setTag(tag);
+	// broadcast announceSynchronizationPoint() to all federates in federation.
+	NM_Announce_Synchronization_Point msg ;
+	msg.federate = federate ;
+	msg.federation = handle ;
+	msg.setLabel(label);
+	msg.setTag(tag);
 
-    G.Out(pdGendoc,"      broadcastSynchronization is calling broadcastAnyMessage for all federates");
+	G.Out(pdGendoc,"      broadcastSynchronization is calling broadcastAnyMessage for all federates");
 
-    broadcastAnyMessage(&msg, 0);
+	broadcastAnyMessage(&msg, 0);
 
-    G.Out(pdGendoc,"exit  Federation::broadcastSynchronization");
+	G.Out(pdGendoc,"exit  Federation::broadcastSynchronization");
 
 }
 
 // ----------------------------------------------------------------------------
 /*! Broadcast an 'Announce Synchronization Point' when registering a new
   synchronization point onto a set of federates
-*/
+ */
 void
 Federation::broadcastSynchronization(FederateHandle federate,
-                                     const std::string& label,
-                                     const std::string& tag,
-                                     unsigned short federate_setSize,
-                                     std::vector <FederateHandle> &federate_set)
-    throw (RTIinternalError)
+		const std::string& label,
+		const std::string& tag,
+		unsigned short federate_setSize,
+		const std::vector <FederateHandle> &federate_set)
+throw (RTIinternalError)
 {
 
-    G.Out(pdGendoc,"enter Federation::broadcastSynchronization to some federates");
+	G.Out(pdGendoc,"enter Federation::broadcastSynchronization to some federates");
 
-    this->check(federate); // It may throw FederateNotExecutionMember.
+	this->check(federate); // It may throw FederateNotExecutionMember.
 
-    if (label.empty())
-        throw RTIinternalError("Bad pause label(null or too long).");
+	if (label.empty())
+		throw RTIinternalError("Bad pause label(null or too long).");
 
-    // broadcast announceSynchronizationPoint() to all federates in federation.
-    NM_Announce_Synchronization_Point msg ;
-    msg.federate = federate ;
-    msg.federation = handle ;
-    msg.setLabel(label);
-    msg.setTag(tag);
+	// broadcast announceSynchronizationPoint() to all federates in federation.
+	NM_Announce_Synchronization_Point msg ;
+	msg.federate = federate ;
+	msg.federation = handle ;
+	msg.setLabel(label);
+	msg.setTag(tag);
 
-    G.Out(pdGendoc,"      broadcastSynchronization is calling broadcastSomeMessage");
+	G.Out(pdGendoc,"      broadcastSynchronization is calling broadcastSomeMessage");
 
-    broadcastSomeMessage(&msg, 0, federate_set, (unsigned short)federate_setSize);
+	broadcastSomeMessage(&msg, 0, federate_set, federate_setSize);
 
-    G.Out(pdGendoc,"exit  Federation::broadcastSynchronization to some federates");
+	G.Out(pdGendoc,"exit  Federation::broadcastSynchronization to some federates");
 
 }
 
@@ -1142,317 +1142,317 @@
 //! Request a federation save with time.
 /*! This service puts each federate from federation in saving state.
   !! the_time is not managed yet.
-*/
+ */
 void
 Federation::requestFederationSave(FederateHandle the_federate,
-                                  const std::string& the_label,
-                                  FederationTime time )
-    throw (FederateNotExecutionMember, SaveInProgress)
+		const std::string& the_label,
+		FederationTime time )
+throw (FederateNotExecutionMember, SaveInProgress)
 {
-    G.Out(pdGendoc,"enter Federation::requestFederationSave with time");
-
-    check(the_federate);
+	G.Out(pdGendoc,"enter Federation::requestFederationSave with time");
 
-    if (saveInProgress)
-        throw SaveInProgress("Already in saving state.");
+	check(the_federate);
 
-    for (HandleFederateMap::iterator j = _handleFederateMap.begin(); j != _handleFederateMap.end(); ++j) {
-        j->second.setSaving(true);
-    }
+	if (saveInProgress)
+		throw SaveInProgress("Already in saving state.");
 
-    saveStatus = true ;
-    saveInProgress = true ;
-    saveLabel = the_label ;
+	for (HandleFederateMap::iterator j = _handleFederateMap.begin(); j != _handleFederateMap.end(); ++j) {
+		j->second.setSaving(true);
+	}
 
-    NM_Initiate_Federate_Save msg ;
-    msg.federate = the_federate ;
-    msg.federation = handle ;
-    msg.setLabel(the_label);
-    // timed message
-    msg.setDate(time);
+	saveStatus = true ;
+	saveInProgress = true ;
+	saveLabel = the_label ;
+
+	NM_Initiate_Federate_Save msg ;
+	msg.federate = the_federate ;
+	msg.federation = handle ;
+	msg.setLabel(the_label);
+	// timed message
+	msg.setDate(time);
 
-    G.Out(pdGendoc,"      requestFederationSave====>broadcast I_F_S to all");
+	G.Out(pdGendoc,"      requestFederationSave====>broadcast I_F_S to all");
 
-    broadcastAnyMessage(&msg, 0);
+	broadcastAnyMessage(&msg, 0);
 
-    G.Out(pdGendoc,"exit  Federation::requestFederationSave with time");
+	G.Out(pdGendoc,"exit  Federation::requestFederationSave with time");
 }
 
 // ----------------------------------------------------------------------------
 //! Request a federation save without time.
 /*! This service puts each federate from federation in saving state.
   !! the_time is not managed yet.
-*/
+ */
 void
 Federation::requestFederationSave(FederateHandle the_federate,
-                                  const std::string& the_label)
-    throw (FederateNotExecutionMember, SaveInProgress)
+		const std::string& the_label)
+throw (FederateNotExecutionMember, SaveInProgress)
 {
-    G.Out(pdGendoc,"enter Federation::requestFederationSave without time");
+	G.Out(pdGendoc,"enter Federation::requestFederationSave without time");
 
-    check(the_federate);
+	check(the_federate);
 
-    if (saveInProgress)
-        throw SaveInProgress("Already in saving state.");
+	if (saveInProgress)
+		throw SaveInProgress("Already in saving state.");
 
-    for (HandleFederateMap::iterator j = _handleFederateMap.begin(); j != _handleFederateMap.end(); ++j) {
-        j->second.setSaving(true);
-    }
+	for (HandleFederateMap::iterator j = _handleFederateMap.begin(); j != _handleFederateMap.end(); ++j) {
+		j->second.setSaving(true);
+	}
 
-    saveStatus = true ;
-    saveInProgress = true ;
-    saveLabel = the_label ;
+	saveStatus = true ;
+	saveInProgress = true ;
+	saveLabel = the_label ;
 
-    NM_Initiate_Federate_Save msg ;
-    msg.federate = the_federate ;
-    msg.federation = handle ;
-    msg.setLabel(the_label);
+	NM_Initiate_Federate_Save msg ;
+	msg.federate = the_federate ;
+	msg.federation = handle ;
+	msg.setLabel(the_label);
 
-    G.Out(pdGendoc,"                  requestFederationSave====>broadcast I_F_S"
-                   " to all");
+	G.Out(pdGendoc,"                  requestFederationSave====>broadcast I_F_S"
+			" to all");
 
-    broadcastAnyMessage(&msg, 0);
+	broadcastAnyMessage(&msg, 0);
 
-    G.Out(pdGendoc,"exit  Federation::requestFederationSave without time");
+	G.Out(pdGendoc,"exit  Federation::requestFederationSave without time");
 }
 // ----------------------------------------------------------------------------
 /*! Received from a federate to inform a save has been received and is being
   processed.
   Maybe, a timeout should be set to determine if federate still alive.
-*/
+ */
 void
 Federation::federateSaveBegun(FederateHandle the_federate)
-    throw (FederateNotExecutionMember)
+throw (FederateNotExecutionMember)
 {
-    G.Out(pdGendoc,"enter Federation::federateSaveBegun");
-    check(the_federate);
-    G.Out(pdGendoc,"exit  Federation::federateSaveBegun");
+	G.Out(pdGendoc,"enter Federation::federateSaveBegun");
+	check(the_federate);
+	G.Out(pdGendoc,"exit  Federation::federateSaveBegun");
 }
 
 // ----------------------------------------------------------------------------
 //! Informs that a federate returns a save end message (with success or not!).
 void
 Federation::federateSaveStatus(FederateHandle the_federate, bool the_status)
-    throw (FederateNotExecutionMember)
+throw (FederateNotExecutionMember)
 {
-    G.Out(pdGendoc,"enter Federation::federateSaveStatus");
-
-    Federate &federate = getFederate(the_federate);
-    federate.setSaving(false);
+	G.Out(pdGendoc,"enter Federation::federateSaveStatus");
 
-    if (!the_status)
-        saveStatus = false ;
+	Federate &federate = getFederate(the_federate);
+	federate.setSaving(false);
 
-    // Verify that all federates save ended (complete or not).
-    for (HandleFederateMap::iterator j = _handleFederateMap.begin(); j != _handleFederateMap.end(); ++j) {
-        if (j->second.isSaving())
-            {
-            G.Out(pdGendoc,"exit  Federation::federateSaveStatus one federate has not save ended");
-            return ;
-            }
-    }
+	if (!the_status)
+		saveStatus = false ;
+
+	// Verify that all federates save ended (complete or not).
+	for (HandleFederateMap::iterator j = _handleFederateMap.begin(); j != _handleFederateMap.end(); ++j) {
+		if (j->second.isSaving())
+		{
+			G.Out(pdGendoc,"exit  Federation::federateSaveStatus one federate has not save ended");
+			return ;
+		}
+	}
 
-    // Save RTIG Data for future restoration.
-    if (saveStatus) {
-        saveStatus = saveXmlData();
-    }
+	// Save RTIG Data for future restoration.
+	if (saveStatus) {
+		saveStatus = saveXmlData();
+	}
 
-    // Send end save message.
-    std::auto_ptr<NetworkMessage> msg(NM_Factory::create(saveStatus ? NetworkMessage::FEDERATION_SAVED : NetworkMessage::FEDERATION_NOT_SAVED )) ;
+	// Send end save message.
+	std::auto_ptr<NetworkMessage> msg(NM_Factory::create(saveStatus ? NetworkMessage::FEDERATION_SAVED : NetworkMessage::FEDERATION_NOT_SAVED )) ;
 
-    msg->federate = the_federate ;
-    msg->federation = handle ;
+	msg->federate = the_federate ;
+	msg->federation = handle ;
 
-    broadcastAnyMessage(msg.get(), 0);
+	broadcastAnyMessage(msg.get(), 0);
 
-    G.Out(pdGendoc,"            =======> broadcast F_S or F_N_S");
+	G.Out(pdGendoc,"            =======> broadcast F_S or F_N_S");
 
-    // Reinitialize state.
-    saveStatus = true ;
-    saveInProgress = false ;
+	// Reinitialize state.
+	saveStatus = true ;
+	saveInProgress = false ;
 
-    G.Out(pdGendoc,"exit  Federation::federateSaveStatus");
+	G.Out(pdGendoc,"exit  Federation::federateSaveStatus");
 }
 
 // ----------------------------------------------------------------------------
 //! Informs that a federate is requesting a save.
 void
 Federation::requestFederationRestore(FederateHandle the_federate,
-                                     const std::string& the_label)
-    throw (FederateNotExecutionMember)
+		const std::string& the_label)
+throw (FederateNotExecutionMember)
 {
-    G.Out(pdGendoc,"enter Federation::requestFederationRestore");
+	G.Out(pdGendoc,"enter Federation::requestFederationRestore");
 
-    check(the_federate);
+	check(the_federate);
 
-    if (restoreInProgress)
-        throw RestoreInProgress("Already in restoring state.");
+	if (restoreInProgress)
+		throw RestoreInProgress("Already in restoring state.");
 
-    Socket * socket ;
-    NetworkMessage *msg;
+	Socket * socket ;
+	NetworkMessage *msg;
 
 
-    // Informs sending federate of success/failure in restoring.
-    // At this point, only verify that file is present.
-    bool success = true ;
+	// Informs sending federate of success/failure in restoring.
+	// At this point, only verify that file is present.
+	bool success = true ;
 #ifdef HAVE_XML
-    string filename = name + "_" + the_label + ".xcs" ;
-    doc = xmlParseFile(filename.c_str());
+	string filename = name + "_" + the_label + ".xcs" ;
+	doc = xmlParseFile(filename.c_str());
 
-    // Did libXML manage to parse the file ?
-    if (doc == 0) {
-        cerr << "XML restore file not parsed successfully" << endl ;
-        xmlFreeDoc(doc);
-        success = false ;
-    }
-    if (success) {
-        success = restoreXmlData();
-    }
+	// Did libXML manage to parse the file ?
+	if (doc == 0) {
+		cerr << "XML restore file not parsed successfully" << endl ;
+		xmlFreeDoc(doc);
+		success = false ;
+	}
+	if (success) {
+		success = restoreXmlData();
+	}
 #else
-    success = false ;
+	success = false ;
 #endif // HAVE_XML
 
-// JYR Note : forcing success to true to skip xmlParseFile (not compliant ?)
-    success = true ;
+	// JYR Note : forcing success to true to skip xmlParseFile (not compliant ?)
+	success = true ;
+
+	if (success) {
+		msg = NM_Factory::create(NetworkMessage::REQUEST_FEDERATION_RESTORE_SUCCEEDED);
+	} else {
+		msg = NM_Factory::create(NetworkMessage::REQUEST_FEDERATION_RESTORE_FAILED);
+	}
+
+	msg->federate = the_federate ;
+	msg->federation = handle ;
+	msg->setLabel(the_label);
+
+	socket = server->getSocketLink(msg->federate);
+
+	if (success)
+		G.Out(pdGendoc,"             =====> send message R_F_R_S to RTIA");
+	else
+		G.Out(pdGendoc,"             =====> send message R_F_R_F to RTIA");
+
+	msg->send(socket,NM_msgBufSend);
+	delete msg ;
+
+	// Reading file failed: not restoring !
+	if (!success)
+	{
+		G.Out(pdGendoc,"exit  Federation::requestFederationRestore on success false");
+		return ;
+	}
 
-    if (success) {
-    	msg = NM_Factory::create(NetworkMessage::REQUEST_FEDERATION_RESTORE_SUCCEEDED);
-    } else {
-    	msg = NM_Factory::create(NetworkMessage::REQUEST_FEDERATION_RESTORE_FAILED);
-    }
-
-    msg->federate = the_federate ;
-    msg->federation = handle ;
-    msg->setLabel(the_label);
-
-    socket = server->getSocketLink(msg->federate);
-
-    if (success)
-       G.Out(pdGendoc,"             =====> send message R_F_R_S to RTIA");
-    else
-       G.Out(pdGendoc,"             =====> send message R_F_R_F to RTIA");
-
-    msg->send(socket,NM_msgBufSend);
-    delete msg ;
-
-    // Reading file failed: not restoring !
-    if (!success)
-        {
-        G.Out(pdGendoc,"exit  Federation::requestFederationRestore on success false");
-        return ;
-        }
-
-    // Otherwise...
-    for (HandleFederateMap::iterator i = _handleFederateMap.begin(); i != _handleFederateMap.end(); ++i) {
-        i->second.setRestoring(true);
-    }
-    restoreStatus = true ;
-    restoreInProgress = true ;
-
-    // Informs federates a new restore is being done.
-    msg = NM_Factory::create(NetworkMessage::FEDERATION_RESTORE_BEGUN);
-    msg->federate = the_federate ;
-    msg->federation = handle ;
-
-    G.Out(pdGendoc,"             =====> broadcast message F_R_B");
-
-    broadcastAnyMessage(msg, 0);
-    delete msg ;
-
-    // For each federate, send an initiateFederateRestore with correct handle.
-    msg = NM_Factory::create(NetworkMessage::INITIATE_FEDERATE_RESTORE);
-    msg->federation = handle ;
-    msg->setLabel(the_label);
-
-    for (HandleFederateMap::iterator i = _handleFederateMap.begin(); i != _handleFederateMap.end(); ++i) {
-        msg->federate = i->second.getHandle();
-
-        // send message.
-        socket = server->getSocketLink(msg->federate);
-        G.Out(pdGendoc,"             =====> send message I_F_R to federate %d",msg->federate);
-        msg->send(socket,NM_msgBufSend);
-    }
-    delete msg;
-    G.Out(pdGendoc,"exit  Federation::requestFederationRestore");
+	// Otherwise...
+	for (HandleFederateMap::iterator i = _handleFederateMap.begin(); i != _handleFederateMap.end(); ++i) {
+		i->second.setRestoring(true);
+	}
+	restoreStatus = true ;
+	restoreInProgress = true ;
+
+	// Informs federates a new restore is being done.
+	msg = NM_Factory::create(NetworkMessage::FEDERATION_RESTORE_BEGUN);
+	msg->federate = the_federate ;
+	msg->federation = handle ;
+
+	G.Out(pdGendoc,"             =====> broadcast message F_R_B");
+
+	broadcastAnyMessage(msg, 0);
+	delete msg ;
+
+	// For each federate, send an initiateFederateRestore with correct handle.
+	msg = NM_Factory::create(NetworkMessage::INITIATE_FEDERATE_RESTORE);
+	msg->federation = handle ;
+	msg->setLabel(the_label);
+
+	for (HandleFederateMap::iterator i = _handleFederateMap.begin(); i != _handleFederateMap.end(); ++i) {
+		msg->federate = i->second.getHandle();
+
+		// send message.
+		socket = server->getSocketLink(msg->federate);
+		G.Out(pdGendoc,"             =====> send message I_F_R to federate %d",msg->federate);
+		msg->send(socket,NM_msgBufSend);
+	}
+	delete msg;
+	G.Out(pdGendoc,"exit  Federation::requestFederationRestore");
 }
 
 // ----------------------------------------------------------------------------
 //! Informs that a federate has ended a restore.
 /*! If each federate in federation has ended restoring, this service send a
   federation restore status.
-*/
+ */
 void
 Federation::federateRestoreStatus(FederateHandle the_federate,
-                                  bool the_status)
-    throw (FederateNotExecutionMember)
+		bool the_status)
+throw (FederateNotExecutionMember)
 {
-    G.Out(pdGendoc,"enter Federation::federateRestoreStatus");
-    Federate &federate = getFederate(the_federate);
-    federate.setRestoring(false);
-
-    if (!the_status)
-        restoreStatus = false ;
-
-    // Verify that all federates save ended (complete or not).
-    for (HandleFederateMap::iterator i = _handleFederateMap.begin(); i != _handleFederateMap.end(); ++i) {
-        if (i->second.isRestoring())
-            return ;
-    }
-
-    // Send end restore message.
-    std::auto_ptr<NetworkMessage> msg(NM_Factory::create(restoreStatus ? NetworkMessage::FEDERATION_RESTORED : NetworkMessage::FEDERATION_NOT_RESTORED)) ;
-
-    msg->federate = the_federate ;
-    msg->federation = handle ;
-
-    broadcastAnyMessage(msg.get(), 0);
-
-    // Reinitialize state.
-    restoreStatus = true ;
-    restoreInProgress = false ;
-    G.Out(pdGendoc,"exit  Federation::federateRestoreStatus");
+	G.Out(pdGendoc,"enter Federation::federateRestoreStatus");
+	Federate &federate = getFederate(the_federate);
+	federate.setRestoring(false);
+
+	if (!the_status)
+		restoreStatus = false ;
+
+	// Verify that all federates save ended (complete or not).
+	for (HandleFederateMap::iterator i = _handleFederateMap.begin(); i != _handleFederateMap.end(); ++i) {
+		if (i->second.isRestoring())
+			return ;
+	}
+
+	// Send end restore message.
+	std::auto_ptr<NetworkMessage> msg(NM_Factory::create(restoreStatus ? NetworkMessage::FEDERATION_RESTORED : NetworkMessage::FEDERATION_NOT_RESTORED)) ;
+
+	msg->federate = the_federate ;
+	msg->federation = handle ;
+
+	broadcastAnyMessage(msg.get(), 0);
+
+	// Reinitialize state.
+	restoreStatus = true ;
+	restoreInProgress = false ;
+	G.Out(pdGendoc,"exit  Federation::federateRestoreStatus");
 }
 
 // ----------------------------------------------------------------------------
 //! Return the Federate whose Handle is theHandle, if found.
 Federate &
 Federation::getFederate(FederateHandle federate_handle)
-    throw (FederateNotExecutionMember)
+throw (FederateNotExecutionMember)
 {
-    HandleFederateMap::iterator i = _handleFederateMap.find(federate_handle);
-    if (i == _handleFederateMap.end())
-        throw FederateNotExecutionMember("Federate Handle not found.");
-    return i->second;
+	HandleFederateMap::iterator i = _handleFederateMap.find(federate_handle);
+	if (i == _handleFederateMap.end())
+		throw FederateNotExecutionMember("Federate Handle not found.");
+	return i->second;
 }
 
 // ----------------------------------------------------------------------------
 //! Return the Federate whose Name is theName, if found.
 Federate &
 Federation::getFederate(const std::string& federate_name)
-    throw (FederateNotExecutionMember)
+throw (FederateNotExecutionMember)
 {
-    for (HandleFederateMap::iterator i = _handleFederateMap.begin(); i != _handleFederateMap.end(); ++i) {
-        if (i->second.getName() == federate_name)
-            return i->second;
-    }
+	for (HandleFederateMap::iterator i = _handleFederateMap.begin(); i != _handleFederateMap.end(); ++i) {
+		if (i->second.getName() == federate_name)
+			return i->second;
+	}
 
-    throw FederateNotExecutionMember(stringize() <<
-        "Federate <"<<federate_name<<"> not [yet] member of Federation <" << getName() <<">.");
+	throw FederateNotExecutionMember(stringize() <<
+			"Federate <"<<federate_name<<"> not [yet] member of Federation <" << getName() <<">.");
 }
 
 // ----------------------------------------------------------------------------
 //! Return true if no federates are in federation.
 /*! Return true if there are no Federates left in the Federation, else throw
   FederatesCurrentlyJoined.
-*/
+ */
 bool
 Federation::empty() const
-    throw (FederatesCurrentlyJoined)
+throw (FederatesCurrentlyJoined)
 {
-    if (_handleFederateMap.empty())
-        return true ;
-    else
-        throw FederatesCurrentlyJoined("");
+	if (_handleFederateMap.empty())
+		return true ;
+	else
+		throw FederatesCurrentlyJoined("");
 }
 
 // ----------------------------------------------------------------------------
@@ -1460,12 +1460,12 @@
 
 bool
 Federation::check(FederateHandle federate_handle) const
-    throw (FederateNotExecutionMember)
+throw (FederateNotExecutionMember)
 {
-    HandleFederateMap::const_iterator i = _handleFederateMap.find(federate_handle);
-    if (i == _handleFederateMap.end())
-        throw FederateNotExecutionMember("Federate Handle not found.");
-    return true;
+	HandleFederateMap::const_iterator i = _handleFederateMap.find(federate_handle);
+	if (i == _handleFederateMap.end())
+		throw FederateNotExecutionMember("Federate Handle not found.");
+	return true;
 }
 
 // ----------------------------------------------------------------------------
@@ -1473,36 +1473,36 @@
     remove all references to this federate in the federation. To be used
     when a Federate is supposed to have crashed.
     @param federate Handle of the federate to kill
-*/
+ */
 void
 Federation::kill(FederateHandle federate)
-    throw ()
+throw ()
 {
-    // NOTE: Connection to the federate is already closed.
-    D.Out(pdInit, "Killing Federate %d.", federate);
+	// NOTE: Connection to the federate is already closed.
+	D.Out(pdInit, "Killing Federate %d.", federate);
 
-    // is regulator ?
-    try {
-        removeRegulator(federate);
-        D.Out(pdInit, "Regulator Federate %d removed...", federate);
-    } catch (Exception &e) {}
-
-    // is constrained ?
-    try {
-        removeConstrained(federate);
-        D.Out(pdInit, "Constrained Federate %d removed...", federate);
-    } catch (Exception &e) {}
-
-    // Remove references to this federate in root object
-    root->killFederate(federate);
-    Debug(D, pdTrace) << "Federate " << federate << " removed from the Root Object "
-               << endl ;
-
-    // delete from federations list
-    try {
-        remove(federate);
-        D.Out(pdInit, "Federate %d removed...", federate);
-    } catch (Exception &e) {}
+	// is regulator ?
+	try {
+		removeRegulator(federate);
+		D.Out(pdInit, "Regulator Federate %d removed...", federate);
+	} catch (Exception &e) {}
+
+	// is constrained ?
+	try {
+		removeConstrained(federate);
+		D.Out(pdInit, "Constrained Federate %d removed...", federate);
+	} catch (Exception &e) {}
+
+	// Remove references to this federate in root object
+	root->killFederate(federate);
+	Debug(D, pdTrace) << "Federate " << federate << " removed from the Root Object "
+			<< endl ;
+
+	// delete from federations list
+	try {
+		remove(federate);
+		D.Out(pdInit, "Federate %d removed...", federate);
+	} catch (Exception &e) {}
 }
 
 // ----------------------------------------------------------------------------
@@ -1510,976 +1510,976 @@
 
 void
 Federation::publishInteraction(FederateHandle federate,
-                               InteractionClassHandle interaction,
-                               bool pub)
-    throw (InteractionClassNotDefined,
-           FederateNotExecutionMember,
-           SaveInProgress,
-           SecurityError,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember.
-    this->check(federate);
-
-    // It may throw InteractionClassNotDefined
-    root->Interactions->publish(federate, interaction, pub);
-    D.Out(pdRequest,
-          "Federation %d: Federate %d has(un)published Interaction %d.",
-          handle, federate, interaction);
-}
+		InteractionClassHandle interaction,
+		bool pub)
+throw (InteractionClassNotDefined,
+		FederateNotExecutionMember,
+		SaveInProgress,
+		SecurityError,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember.
+	this->check(federate);
+
+	// It may throw InteractionClassNotDefined
+	root->Interactions->publish(federate, interaction, pub);
+	D.Out(pdRequest,
+			"Federation %d: Federate %d has(un)published Interaction %d.",
+			handle, federate, interaction);
+		}
 
 // ----------------------------------------------------------------------------
 // publishObject
 
 void
 Federation::publishObject(FederateHandle federate,
-                          ObjectClassHandle object,
-                          std::vector <AttributeHandle> &attributes,
-                          uint16_t list_size,
-                          bool pub)
-    throw (ObjectClassNotDefined,
-           AttributeNotDefined,
-           FederateNotExecutionMember,
-           SaveInProgress,
-           SecurityError,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    G.Out(pdGendoc,"enter Federation::publishObject");
-    // It may throw FederateNotExecutionMember.
-    this->check(federate);
-
-    // It may throw *NotDefined
-    root->ObjectClasses->publish(federate, object, attributes, list_size, pub);
-
-    D.Out(pdRegister,
-          "Federation %d: Federate %d(un)publishes %d attrib. of ObjClass %d.",
-          handle, federate, list_size, object);
-    G.Out(pdGendoc,"exit  Federation::publishObject");
-}
+		ObjectClassHandle object,
+		const std::vector <AttributeHandle> &attributes,
+		uint16_t list_size,
+		bool pub)
+throw (ObjectClassNotDefined,
+		AttributeNotDefined,
+		FederateNotExecutionMember,
+		SaveInProgress,
+		SecurityError,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	G.Out(pdGendoc,"enter Federation::publishObject");
+	// It may throw FederateNotExecutionMember.
+	this->check(federate);
+
+	// It may throw *NotDefined
+	root->ObjectClasses->publish(federate, object, attributes, list_size, pub);
+
+	D.Out(pdRegister,
+			"Federation %d: Federate %d(un)publishes %d attrib. of ObjClass %d.",
+			handle, federate, list_size, object);
+	G.Out(pdGendoc,"exit  Federation::publishObject");
+		}
 
 // ----------------------------------------------------------------------------
 //! Adds a new object instance to federation.
 ObjectHandle
 Federation::registerObject(FederateHandle federate,
-                           ObjectClassHandle class_handle,
-                           const std::string& object_name)
-    throw (FederateNotExecutionMember,
-           FederateNotPublishing,
-           ObjectAlreadyRegistered,
-           ObjectClassNotDefined,
-           ObjectClassNotPublished,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-
-    ObjectHandle new_id = objectHandles.provide();
-
-    G.Out(pdGendoc,"enter Federation::registerObject");
-    D.Out(pdRegister,
-          "Federation %d: Federate %d registering Object %d of Class %d.",
-          handle, federate, new_id, class_handle);
-
-    string strname;
-    if (!object_name.empty()) {
-        strname = object_name;
-    } else {
-        // create a name if necessary
-        strname = stringize() << "HLAObject_" << new_id;
-    }
-
-    // Register Object.
-    try
-    {
-        root->registerObjectInstance(federate, class_handle, new_id, strname);
-    }
-    catch(...)
-    {   //If an exception was thrown, the object instance was not added
-        //and we can free the object handle id for future use and rethrow
-        //the exception
-        objectHandles.free(new_id);
-        throw;
-    }
-    G.Out(pdGendoc,"exit Federation::registerObject");
-    return new_id ;
-}
+		ObjectClassHandle class_handle,
+		const std::string& object_name)
+throw (FederateNotExecutionMember,
+		FederateNotPublishing,
+		ObjectAlreadyRegistered,
+		ObjectClassNotDefined,
+		ObjectClassNotPublished,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+
+	ObjectHandle new_id = objectHandles.provide();
+
+	G.Out(pdGendoc,"enter Federation::registerObject");
+	D.Out(pdRegister,
+			"Federation %d: Federate %d registering Object %d of Class %d.",
+			handle, federate, new_id, class_handle);
+
+	string strname;
+	if (!object_name.empty()) {
+		strname = object_name;
+	} else {
+		// create a name if necessary
+		strname = stringize() << "HLAObject_" << new_id;
+	}
+
+	// Register Object.
+	try
+	{
+		root->registerObjectInstance(federate, class_handle, new_id, strname);
+	}
+	catch(...)
+	{   //If an exception was thrown, the object instance was not added
+		//and we can free the object handle id for future use and rethrow
+		//the exception
+		objectHandles.free(new_id);
+		throw;
+	}
+	G.Out(pdGendoc,"exit Federation::registerObject");
+	return new_id ;
+		}
 
 // ----------------------------------------------------------------------------
 /** Remove a federate.
     @param federate_handle Handle of the federate to remove.
     @bug Currently does not check if Federate owns attributes. The
     Federate Object is deleted.
-*/
+ */
 void
 Federation::remove(FederateHandle federate_handle)
-    throw (FederateOwnsAttributes, FederateNotExecutionMember)
+throw (FederateOwnsAttributes, FederateNotExecutionMember)
 {
-    HandleFederateMap::iterator i = _handleFederateMap.find(federate_handle);
-    if (i != _handleFederateMap.end()) {
-        // BUG: RemoveFederate: Should see if Federate owns attributes
-        federateHandles.free(federate_handle);
-        _handleFederateMap.erase(i);
-
-        D.Out(pdInit, "Federation %d: Removed Federate %d.", handle,
-              federate_handle);
-        return;
-    }
-
-    D.Out(pdExcept, "Federation %d could not remove unknown federate %d.",
-          handle, federate_handle);
-    throw FederateNotExecutionMember("");
+	HandleFederateMap::iterator i = _handleFederateMap.find(federate_handle);
+	if (i != _handleFederateMap.end()) {
+		// BUG: RemoveFederate: Should see if Federate owns attributes
+		federateHandles.free(federate_handle);
+		_handleFederateMap.erase(i);
+
+		D.Out(pdInit, "Federation %d: Removed Federate %d.", handle,
+				federate_handle);
+		return;
+	}
+
+	D.Out(pdExcept, "Federation %d could not remove unknown federate %d.",
+			handle, federate_handle);
+	throw FederateNotExecutionMember("");
 }
 
 // ----------------------------------------------------------------------------
 //! Set Federate's IsConstrained to false.
 void
 Federation::removeConstrained(FederateHandle federate_handle)
-    throw (FederateNotExecutionMember,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember
-    Federate &federate = getFederate(federate_handle);
-
-    if (!federate.isConstrained()) {
-        D.Out(pdExcept, "Federate %d was not constrained.", federate_handle);
-        throw RTIinternalError("Time constrained not enabled.");
-    }
-
-    federate.setConstrained(false);
-    D.Out(pdTerm, "Federation %d: Federate %d is not constrained anymore.",
-          handle, federate_handle);
-}
+throw (FederateNotExecutionMember,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember
+	Federate &federate = getFederate(federate_handle);
+
+	if (!federate.isConstrained()) {
+		D.Out(pdExcept, "Federate %d was not constrained.", federate_handle);
+		throw RTIinternalError("Time constrained not enabled.");
+	}
+
+	federate.setConstrained(false);
+	D.Out(pdTerm, "Federation %d: Federate %d is not constrained anymore.",
+			handle, federate_handle);
+		}
 
 // ----------------------------------------------------------------------------
 //! Remove the Federate from the Regulators' list.
 void
 Federation::removeRegulator(FederateHandle federate_handle)
-    throw (FederateNotExecutionMember,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember
-    Federate &federate = getFederate(federate_handle);
+throw (FederateNotExecutionMember,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember
+	Federate &federate = getFederate(federate_handle);
+
+	// It may throw RTIinternalError if Federate was not regulators.
+	regulators.remove(federate_handle);
+
+	federate.setRegulator(false);
+
+	D.Out(pdTerm, "Federation %d: Federate %d is not a regulator anymore.",
+			handle, federate_handle);
+
+	NM_Set_Time_Regulating msg ;
+	msg.federation = handle ;
+	msg.federate = federate_handle ;
+	msg.regulatorOff();
 
-    // It may throw RTIinternalError if Federate was not regulators.
-    regulators.remove(federate_handle);
-
-    federate.setRegulator(false);
-
-    D.Out(pdTerm, "Federation %d: Federate %d is not a regulator anymore.",
-          handle, federate_handle);
-
-    NM_Set_Time_Regulating msg ;
-    msg.federation = handle ;
-    msg.federate = federate_handle ;
-    msg.regulatorOff();
-
-    broadcastAnyMessage(&msg, 0);
-}
+	broadcastAnyMessage(&msg, 0);
+		}
 
 // ----------------------------------------------------------------------------
 //! unregisterSynchronization.
 void
 Federation::unregisterSynchronization(FederateHandle federate_handle,
-                                      const std::string& label)
-    throw (FederateNotExecutionMember,
-           FederationNotPaused,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-
-    G.Out(pdGendoc,"enter Federation::unregisterSynchronization");
-
-    this->check(federate_handle); // It may throw FederateNotExecutionMember.
-
-    if (label.empty())
-        throw RTIinternalError("Bad pause label(null).");
-
-    // Set federate synchronized on this label.
-    Federate &federate = getFederate(federate_handle);
-    federate.removeSynchronizationLabel(label);
-
-    // Test in every federate is synchronized. Otherwise, quit method.
-    for (HandleFederateMap::iterator i = _handleFederateMap.begin(); i != _handleFederateMap.end(); ++i) {
-        if (i->second.isSynchronizationLabel(label))
-            return;
-    }
+		const std::string& label)
+throw (FederateNotExecutionMember,
+		FederationNotPaused,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+
+	G.Out(pdGendoc,"enter Federation::unregisterSynchronization");
+
+	this->check(federate_handle); // It may throw FederateNotExecutionMember.
+
+	if (label.empty())
+		throw RTIinternalError("Bad pause label(null).");
+
+	// Set federate synchronized on this label.
+	Federate &federate = getFederate(federate_handle);
+	federate.removeSynchronizationLabel(label);
+
+	// Test in every federate is synchronized. Otherwise, quit method.
+	for (HandleFederateMap::iterator i = _handleFederateMap.begin(); i != _handleFederateMap.end(); ++i) {
+		if (i->second.isSynchronizationLabel(label))
+			return;
+	}
 
-    // All federates from federation has called synchronizationPointAchieved.
+	// All federates from federation has called synchronizationPointAchieved.
 
-    D.Out(pdTerm, "Federation %d is not Paused anymore.", handle);
-    // Remove label from federation list.
-    std::map<std::string, std::string>::iterator i = synchronizationLabels.find(label);
-    if (i != synchronizationLabels.end()) {
-        synchronizationLabels.erase(i);
-    }
+	D.Out(pdTerm, "Federation %d is not Paused anymore.", handle);
+	// Remove label from federation list.
+	std::map<std::string, std::string>::iterator i = synchronizationLabels.find(label);
+	if (i != synchronizationLabels.end()) {
+		synchronizationLabels.erase(i);
+	}
 
-    // send a federationSynchronized().
-    NM_Federation_Synchronized msg ;
-    msg.federation = handle ;
-    msg.federate = federate_handle ;
-    msg.setLabel(label);
+	// send a federationSynchronized().
+	NM_Federation_Synchronized msg ;
+	msg.federation = handle ;
+	msg.federate = federate_handle ;
+	msg.setLabel(label);
 
-    broadcastAnyMessage(&msg, 0);
+	broadcastAnyMessage(&msg, 0);
 
-    D.Out(pdTerm, "Federation %d is synchronized on %s.", handle, label.c_str());
+	D.Out(pdTerm, "Federation %d is synchronized on %s.", handle, label.c_str());
 
-    G.Out(pdGendoc,"exit  Federation::unregisterSynchronization");
+	G.Out(pdGendoc,"exit  Federation::unregisterSynchronization");
 
-}
+		}
 
 // ----------------------------------------------------------------------------
 // subscribeInteraction
 
 void
 Federation::subscribeInteraction(FederateHandle federate,
-                                 InteractionClassHandle interaction,
-                                 bool sub)
-    throw (InteractionClassNotDefined,
-           FederateNotExecutionMember,
-           SaveInProgress,
-           SecurityError,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember.
-    this->check(federate);
-
-    // It may throw *NotDefined
-    root->Interactions->subscribe(federate, interaction, 0, sub);
-    D.Out(pdRegister,
-          "Federation %d: Federate %d(un)subscribes to Interaction %d.",
-          handle, federate, interaction);
-}
+		InteractionClassHandle interaction,
+		bool sub)
+throw (InteractionClassNotDefined,
+		FederateNotExecutionMember,
+		SaveInProgress,
+		SecurityError,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember.
+	this->check(federate);
+
+	// It may throw *NotDefined
+	root->Interactions->subscribe(federate, interaction, 0, sub);
+	D.Out(pdRegister,
+			"Federation %d: Federate %d(un)subscribes to Interaction %d.",
+			handle, federate, interaction);
+		}
 
 // ----------------------------------------------------------------------------
 // subscribeObject
 
 void
 Federation::subscribeObject(FederateHandle federate,
-                            ObjectClassHandle object,
-                            std::vector <AttributeHandle> &attributes,
-                            uint16_t list_size)
-    throw (ObjectClassNotDefined,
-           AttributeNotDefined,
-           FederateNotExecutionMember,
-           SaveInProgress,
-           SecurityError,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    G.Out(pdGendoc,"enter Federation::subscribeObject");
-    // It may throw FederateNotExecutionMember.
-    this->check(federate);
-
-    // It may throw *NotDefined
-    root->ObjectClasses->subscribe(federate, object, attributes, list_size);
-
-    /*
-     * The subscription process in CERTI:
-     * In RTIG.cc the network messages SUBSCRIBE_OBJECT_CLASS and UNSUBSCRIBE_
-     * OBJECT_CLASS are both mapped to the method processSubscribeObject within
-     * RTIG_processing.cc. RTIG_proccessing invokes this method 
-     * (subscribeObject). 
-     * The above code line (root->ObjectClasses->subscribe(...) calls the 
-     * subscription within the CERTI library in ObjectClassSet.cc. Further on,
-     * ObjectClassSet::subscribe invokes ObjectClass::subscribe. That method 
-     * first unsubscribes all attributes, afterwards the subscription is 
-     * done in a for loop til list_size.  
-     * This means: Unsubscription and subscription are realized by the same
-     * method. Only the list_size parameter controls the
-     * unsubscription/subscription process.
-     *
-     * Do we need a cleaner solution, e.g. separate methods for subscription/
-     * unsubscription?
-     */
-
-    if (list_size!=0) {  // do only for subscription
-        // get object class from object class handle	
-        ObjectClass *objectClass = root->ObjectClasses->getObjectFromHandle(object);
-
-        // get attributes of object class
-        ObjectClassAttribute::PublishersList_t publishers;
-
-        // get publishers of attributes	
-        // first for: iterate through the attribute list and get publishers of 
-        //            each attribtue
-        // second for: iterate through the temporal publishers list and store 
-        //             non-duplicate entries in publishers
-        ObjectClassAttribute::PublishersList_t tmp_publishers;
-
-        const ObjectClass::HandleClassAttributeMap& attributeMap = objectClass->getHandleClassAttributeMap();
-        for (ObjectClass::HandleClassAttributeMap::const_iterator i = attributeMap.begin();
-             i != attributeMap.end(); ++i) {
-    	    tmp_publishers = i->second->getPublishers();
-            for (ObjectClassAttribute::PublishersList_t::const_iterator
-                j=tmp_publishers.begin(); 
-	        j!=tmp_publishers.end(); 
-	        j++) {
-	            // insert only non-duplicate entries ->
-	            // pair<iterator, bool> set::insert(const TYPE& val);
-	            publishers.insert(*j);
-            }
-	    tmp_publishers.clear();
-        }
-
-        // notify all publishers
-        std::set<FederateHandle> federate_set;
-
-        for (ObjectClassAttribute::PublishersList_t::const_iterator
-            k=publishers.begin(); 
-	    k!=publishers.end(); 
-	    k++) {
-
-	    if (getFederate(*k).isClassRelevanceAdvisorySwitch()) {
-	        federate_set.insert(*k);
-	    }
-        }
-
-        // broadcastSomeMessage needs a vector, no set -> conversion
-        vector<FederateHandle> federate_vector(federate_set.size());
-        std::copy(federate_set.begin(), federate_set.end(), federate_vector.begin());
-
-        NM_Start_Registration_For_Object_Class msg ;
-        msg.federate = federate ;
-        msg.federation = handle ;
-        msg.setObjectClass(object);
-
-        this->broadcastSomeMessage(&msg, 0, federate_vector, (unsigned short)federate_vector.size());
-
-        publishers.clear();
-        federate_set.clear();
-        federate_vector.clear();	
-    } 
-    else {	// unsubscribe branch
-	/* test if objectclass is subscribed by anyone else
-         * -> yes : do nothing
-         * -> no : test if publisher sets its CRA switch
-         *  	-> no : do nothing
-         *  	-> yes : inform publisher with federate service stopRegistrationForObjectClass
-         */
-
-    }
-
-    D.Out(pdRegister,
-          "Federation %d: Federate %d(un)sub. to %d attrib. of ObjClass %d.",
-          handle, federate, list_size, object);
-    G.Out(pdGendoc,"exit  Federation::subscribeObject");
-}
+		ObjectClassHandle object,
+		const std::vector <AttributeHandle> &attributes,
+		uint16_t list_size)
+throw (ObjectClassNotDefined,
+		AttributeNotDefined,
+		FederateNotExecutionMember,
+		SaveInProgress,
+		SecurityError,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	G.Out(pdGendoc,"enter Federation::subscribeObject");
+	// It may throw FederateNotExecutionMember.
+	this->check(federate);
+
+	// It may throw *NotDefined
+	root->ObjectClasses->subscribe(federate, object, attributes, list_size);
+
+	/*
+	 * The subscription process in CERTI:
+	 * In RTIG.cc the network messages SUBSCRIBE_OBJECT_CLASS and UNSUBSCRIBE_
+	 * OBJECT_CLASS are both mapped to the method processSubscribeObject within
+	 * RTIG_processing.cc. RTIG_proccessing invokes this method
+	 * (subscribeObject).
+	 * The above code line (root->ObjectClasses->subscribe(...) calls the
+	 * subscription within the CERTI library in ObjectClassSet.cc. Further on,
+	 * ObjectClassSet::subscribe invokes ObjectClass::subscribe. That method
+	 * first unsubscribes all attributes, afterwards the subscription is
+	 * done in a for loop til list_size.
+	 * This means: Unsubscription and subscription are realized by the same
+	 * method. Only the list_size parameter controls the
+	 * unsubscription/subscription process.
+	 *
+	 * Do we need a cleaner solution, e.g. separate methods for subscription/
+	 * unsubscription?
+	 */
+
+	if (list_size!=0) {  // do only for subscription
+		// get object class from object class handle
+		ObjectClass *objectClass = root->ObjectClasses->getObjectFromHandle(object);
+
+		// get attributes of object class
+		ObjectClassAttribute::PublishersList_t publishers;
+
+		// get publishers of attributes
+		// first for: iterate through the attribute list and get publishers of
+		//            each attribtue
+		// second for: iterate through the temporal publishers list and store
+		//             non-duplicate entries in publishers
+		ObjectClassAttribute::PublishersList_t tmp_publishers;
+
+		const ObjectClass::HandleClassAttributeMap& attributeMap = objectClass->getHandleClassAttributeMap();
+		for (ObjectClass::HandleClassAttributeMap::const_iterator i = attributeMap.begin();
+				i != attributeMap.end(); ++i) {
+			tmp_publishers = i->second->getPublishers();
+			for (ObjectClassAttribute::PublishersList_t::const_iterator
+					j=tmp_publishers.begin();
+					j!=tmp_publishers.end();
+					j++) {
+				// insert only non-duplicate entries ->
+				// pair<iterator, bool> set::insert(const TYPE& val);
+				publishers.insert(*j);
+			}
+			tmp_publishers.clear();
+		}
+
+		// notify all publishers
+		std::set<FederateHandle> federate_set;
+
+		for (ObjectClassAttribute::PublishersList_t::const_iterator
+				k=publishers.begin();
+				k!=publishers.end();
+				k++) {
+
+			if (getFederate(*k).isClassRelevanceAdvisorySwitch()) {
+				federate_set.insert(*k);
+			}
+		}
+
+		// broadcastSomeMessage needs a vector, no set -> conversion
+		vector<FederateHandle> federate_vector(federate_set.size());
+		std::copy(federate_set.begin(), federate_set.end(), federate_vector.begin());
+
+		NM_Start_Registration_For_Object_Class msg ;
+		msg.federate = federate ;
+		msg.federation = handle ;
+		msg.setObjectClass(object);
+
+		this->broadcastSomeMessage(&msg, 0, federate_vector, (unsigned short)federate_vector.size());
+
+		publishers.clear();
+		federate_set.clear();
+		federate_vector.clear();
+	}
+	else {	// unsubscribe branch
+		/* test if objectclass is subscribed by anyone else
+		 * -> yes : do nothing
+		 * -> no : test if publisher sets its CRA switch
+		 *  	-> no : do nothing
+		 *  	-> yes : inform publisher with federate service stopRegistrationForObjectClass
+		 */
+
+	}
+
+	D.Out(pdRegister,
+			"Federation %d: Federate %d(un)sub. to %d attrib. of ObjClass %d.",
+			handle, federate, list_size, object);
+	G.Out(pdGendoc,"exit  Federation::subscribeObject");
+		}
 
 // ----------------------------------------------------------------------------
 // updateAttributeValues with time
 
 void
 Federation::updateAttributeValues(FederateHandle federate,
-                                  ObjectHandle objectHandle,
-                                  std::vector <AttributeHandle> &attributes,
-                                  std::vector <AttributeValue_t> &values,
-                                  uint16_t list_size,
-                                  FederationTime time,
-                                  const std::string& tag)
-    throw (FederateNotExecutionMember,
-           ObjectNotKnown,
-           AttributeNotDefined,
-           AttributeNotOwned,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    G.Out(pdGendoc,"enter Federation::updateAttributeValues with time");
-    // It may throw FederateNotExecutionMember.
-    this->check(federate);
-
-    // Get the object pointer by id from the root object
-    Object *object = root->objects->getObject(objectHandle);
-
-    // It may throw *NotDefined
-    root->ObjectClasses->updateAttributeValues(federate, object, attributes, values, time, tag);
-
-    D.Out(pdRegister,
-          "Federation %d: Federate %d updated attributes of Object %d.",
-          handle, federate, objectHandle);
-    G.Out(pdGendoc,"exit  Federation::updateAttributeValues with time");
-}
+		ObjectHandle objectHandle,
+		const std::vector <AttributeHandle> &attributes,
+		const std::vector <AttributeValue_t> &values,
+		uint16_t list_size,
+		FederationTime time,
+		const std::string& tag)
+throw (FederateNotExecutionMember,
+		ObjectNotKnown,
+		AttributeNotDefined,
+		AttributeNotOwned,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	G.Out(pdGendoc,"enter Federation::updateAttributeValues with time");
+	// It may throw FederateNotExecutionMember.
+	this->check(federate);
+
+	// Get the object pointer by id from the root object
+	Object *object = root->objects->getObject(objectHandle);
+
+	// It may throw *NotDefined
+	root->ObjectClasses->updateAttributeValues(federate, object, attributes, values, time, tag);
+
+	D.Out(pdRegister,
+			"Federation %d: Federate %d updated attributes of Object %d.",
+			handle, federate, objectHandle);
+	G.Out(pdGendoc,"exit  Federation::updateAttributeValues with time");
+		}
 
 // ----------------------------------------------------------------------------
 // updateAttributeValues without time
 
 void
 Federation::updateAttributeValues(FederateHandle federate,
-                                  ObjectHandle objectHandle,
-                                  std::vector <AttributeHandle> &attributes,
-                                  std::vector <AttributeValue_t> &values,
-                                  uint16_t list_size,
-                                  const std::string& tag)
-    throw (FederateNotExecutionMember,
-           ObjectNotKnown,
-           AttributeNotDefined,
-           AttributeNotOwned,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    G.Out(pdGendoc,"enter Federation::updateAttributeValues without time");
-    // It may throw FederateNotExecutionMember.
-    this->check(federate);
-
-    // Get the object pointer by id from the root object
-    Object *object = root->objects->getObject(objectHandle);
-
-    // It may throw *NotDefined
-    root->ObjectClasses->updateAttributeValues(federate, object, attributes, values, tag);
-
-    D.Out(pdRegister,
-          "Federation %d: Federate %d updated attributes of Object %d.",
-          handle, federate, objectHandle);
-    G.Out(pdGendoc,"exit  Federation::updateAttributeValues without time");
-}
+		ObjectHandle objectHandle,
+		const std::vector <AttributeHandle> &attributes,
+		const std::vector <AttributeValue_t> &values,
+		uint16_t list_size,
+		const std::string& tag)
+throw (FederateNotExecutionMember,
+		ObjectNotKnown,
+		AttributeNotDefined,
+		AttributeNotOwned,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	G.Out(pdGendoc,"enter Federation::updateAttributeValues without time");
+	// It may throw FederateNotExecutionMember.
+	this->check(federate);
+
+	// Get the object pointer by id from the root object
+	Object *object = root->objects->getObject(objectHandle);
+
+	// It may throw *NotDefined
+	root->ObjectClasses->updateAttributeValues(federate, object, attributes, values, tag);
+
+	D.Out(pdRegister,
+			"Federation %d: Federate %d updated attributes of Object %d.",
+			handle, federate, objectHandle);
+	G.Out(pdGendoc,"exit  Federation::updateAttributeValues without time");
+		}
 // ----------------------------------------------------------------------------
 //! Update the current time of a regulator federate.
 void
 Federation::updateRegulator(FederateHandle federate_handle,
-                            FederationTime time)
-    throw (FederateNotExecutionMember,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember
-    Federate &federate = getFederate(federate_handle);
-
-    if (!federate.isRegulator()) {
-        D.Out(pdExcept, "Federate %d is not a regulator.", federate_handle);
-        throw RTIinternalError("Time regulation not enabled.");
-    }
+		FederationTime time)
+throw (FederateNotExecutionMember,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember
+	Federate &federate = getFederate(federate_handle);
+
+	if (!federate.isRegulator()) {
+		D.Out(pdExcept, "Federate %d is not a regulator.", federate_handle);
+		throw RTIinternalError("Time regulation not enabled.");
+	}
 
-    D.Out(pdTerm, "Federation %d: Federate %d's new time is %f.",
-          handle, federate_handle, time.getTime());
+	D.Out(pdTerm, "Federation %d: Federate %d's new time is %f.",
+			handle, federate_handle, time.getTime());
 
-    regulators.update(federate_handle, time);
+	regulators.update(federate_handle, time);
 
-    NM_Message_Null msg ;
-    msg.federation = handle ;
-    msg.federate = federate_handle ;
-    msg.setDate(time);
+	NM_Message_Null msg ;
+	msg.federation = handle ;
+	msg.federate = federate_handle ;
+	msg.setDate(time);
 
-    broadcastAnyMessage(&msg, federate_handle);
-}
+	broadcastAnyMessage(&msg, federate_handle);
+		}
 
 // ----------------------------------------------------------------------------
 // isOwner (isAttributeOwnedByFederate)
 bool
 Federation::isOwner(FederateHandle federate,
-                    ObjectHandle id,
-                    AttributeHandle attribute)
-    throw (FederateNotExecutionMember,
-           ObjectNotKnown,
-           AttributeNotDefined,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember.
-    this->check(federate);
-
-    D.Out(pdDebug, "Owner of Object %u Atrribute %u", id, attribute);
-
-    // It may throw *NotDefined
-    return root->objects->isAttributeOwnedByFederate(id, attribute, federate);
-}
+		ObjectHandle id,
+		AttributeHandle attribute)
+throw (FederateNotExecutionMember,
+		ObjectNotKnown,
+		AttributeNotDefined,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember.
+	this->check(federate);
+
+	D.Out(pdDebug, "Owner of Object %u Atrribute %u", id, attribute);
+
+	// It may throw *NotDefined
+	return root->objects->isAttributeOwnedByFederate(id, attribute, federate);
+		}
 
 // ----------------------------------------------------------------------------
 // queryAttributeOwnership
 
 void
 Federation::queryAttributeOwnership(FederateHandle federate,
-                                    ObjectHandle id,
-                                    AttributeHandle attribute)
-    throw (FederateNotExecutionMember,
-           ObjectNotKnown,
-           AttributeNotDefined,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember.
-    this->check(federate);
-
-    D.Out(pdDebug, "Owner of Object %u Atrribute %u", id, attribute);
-
-    // It may throw *NotDefined
-    root->objects->queryAttributeOwnership(id, attribute, federate);
-}
+		ObjectHandle id,
+		AttributeHandle attribute)
+throw (FederateNotExecutionMember,
+		ObjectNotKnown,
+		AttributeNotDefined,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember.
+	this->check(federate);
+
+	D.Out(pdDebug, "Owner of Object %u Atrribute %u", id, attribute);
+
+	// It may throw *NotDefined
+	root->objects->queryAttributeOwnership(id, attribute, federate);
+		}
 
 // ----------------------------------------------------------------------------
 // negotiateDivestiture (negotiatedAttributeOwnershipDivestiture)
 
 void
 Federation::negotiateDivestiture(FederateHandle federate,
-                                 ObjectHandle objectHandle,
-                                 std::vector <AttributeHandle> &attribs,
-                                 uint16_t list_size,
-                                 const std::string& tag)
-    throw (FederateNotExecutionMember,
-           ObjectNotKnown,
-           AttributeNotDefined,
-           AttributeNotOwned,
-           AttributeAlreadyBeingDivested,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember.
-    this->check(federate);
-
-    // Get the object pointer by id from the root object
-    Object *object = root->objects->getObject(objectHandle);
-
-    // It may throw *NotDefined
-    root->ObjectClasses->negotiatedAttributeOwnershipDivestiture(federate, object, attribs, tag);
-}
+		ObjectHandle objectHandle,
+		const std::vector <AttributeHandle> &attribs,
+		uint16_t list_size,
+		const std::string& tag)
+throw (FederateNotExecutionMember,
+		ObjectNotKnown,
+		AttributeNotDefined,
+		AttributeNotOwned,
+		AttributeAlreadyBeingDivested,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember.
+	this->check(federate);
+
+	// Get the object pointer by id from the root object
+	Object *object = root->objects->getObject(objectHandle);
+
+	// It may throw *NotDefined
+	root->ObjectClasses->negotiatedAttributeOwnershipDivestiture(federate, object, attribs, tag);
+		}
 
 // ----------------------------------------------------------------------------
 // acquireIfAvailable (attributeOwnershipAcquisitionIfAvailable)
 
 void
 Federation::acquireIfAvailable(FederateHandle federate,
-                               ObjectHandle objectHandle,
-                               std::vector <AttributeHandle> &attribs,
-                               uint16_t list_size)
-    throw (ObjectNotKnown,
-           ObjectClassNotPublished,
-           AttributeNotDefined,
-           AttributeNotPublished,
-           FederateOwnsAttributes,
-           AttributeAlreadyBeingAcquired,
-           FederateNotExecutionMember,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember.
-    this->check(federate);
-
-    // Get the object pointer by id from the root object
-    Object *object = root->objects->getObject(objectHandle);
-
-    // It may throw *NotDefined
-    root->ObjectClasses->attributeOwnershipAcquisitionIfAvailable(federate, object, attribs);
-}
+		ObjectHandle objectHandle,
+		const std::vector <AttributeHandle> &attribs,
+		uint16_t list_size)
+throw (ObjectNotKnown,
+		ObjectClassNotPublished,
+		AttributeNotDefined,
+		AttributeNotPublished,
+		FederateOwnsAttributes,
+		AttributeAlreadyBeingAcquired,
+		FederateNotExecutionMember,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember.
+	this->check(federate);
+
+	// Get the object pointer by id from the root object
+	Object *object = root->objects->getObject(objectHandle);
+
+	// It may throw *NotDefined
+	root->ObjectClasses->attributeOwnershipAcquisitionIfAvailable(federate, object, attribs);
+		}
 
 // ----------------------------------------------------------------------------
 // divest (unconditionalAttributeOwnershipDivestiture)
 
 void
 Federation::divest(FederateHandle federate,
-                   ObjectHandle objectHandle,
-                   std::vector <AttributeHandle> &attrs,
-                   uint16_t list_size)
-    throw (ObjectNotKnown,
-           AttributeNotDefined,
-           AttributeNotOwned,
-           FederateNotExecutionMember,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember.
-    this->check(federate);
-
-    // Get the object pointer by id from the root object
-    Object *object = root->objects->getObject(objectHandle);
-
-    // It may throw *NotDefined
-    root->ObjectClasses->unconditionalAttributeOwnershipDivestiture(federate, object, attrs);
-}
+		ObjectHandle objectHandle,
+		const std::vector <AttributeHandle> &attrs,
+		uint16_t list_size)
+throw (ObjectNotKnown,
+		AttributeNotDefined,
+		AttributeNotOwned,
+		FederateNotExecutionMember,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember.
+	this->check(federate);
+
+	// Get the object pointer by id from the root object
+	Object *object = root->objects->getObject(objectHandle);
+
+	// It may throw *NotDefined
+	root->ObjectClasses->unconditionalAttributeOwnershipDivestiture(federate, object, attrs);
+		}
 
 // ----------------------------------------------------------------------------
 // attributeOwnershipAcquisition
 
 void
 Federation::acquire(FederateHandle federate,
-                    ObjectHandle objectHandle,
-                    std::vector <AttributeHandle> &attributes,
-                    uint16_t list_size,
-                    const std::string& tag)
-    throw (ObjectNotKnown,
-           ObjectClassNotPublished,
-           AttributeNotDefined,
-           AttributeNotPublished,
-           FederateOwnsAttributes,
-           FederateNotExecutionMember,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember.
-    this->check(federate);
+		ObjectHandle objectHandle,
+		const std::vector <AttributeHandle> &attributes,
+		uint16_t list_size,
+		const std::string& tag)
+throw (ObjectNotKnown,
+		ObjectClassNotPublished,
+		AttributeNotDefined,
+		AttributeNotPublished,
+		FederateOwnsAttributes,
+		FederateNotExecutionMember,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember.
+	this->check(federate);
 
-    // Get the object pointer by id from the root object
-    Object *object = root->objects->getObject(objectHandle);
+	// Get the object pointer by id from the root object
+	Object *object = root->objects->getObject(objectHandle);
 
-    // It may throw *NotDefined
-    root->ObjectClasses->attributeOwnershipAcquisition(federate, object, attributes, tag);
+	// It may throw *NotDefined
+	root->ObjectClasses->attributeOwnershipAcquisition(federate, object, attributes, tag);
 
-    D.Out(pdDebug, "Acquisition on Object %u ", objectHandle);
-}
+	D.Out(pdDebug, "Acquisition on Object %u ", objectHandle);
+		}
 
 // ----------------------------------------------------------------------------
 // cancelDivestiture (cancelNegotiatedAttributeOwnershipDivestiture)
 
 void
 Federation::cancelDivestiture(FederateHandle federate,
-                              ObjectHandle id,
-                              std::vector <AttributeHandle> &attributes,
-                              uint16_t list_size)
-    throw (ObjectNotKnown,
-           AttributeNotDefined,
-           AttributeNotOwned,
-           AttributeDivestitureWasNotRequested,
-           FederateNotExecutionMember,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember.
-    this->check(federate);
-
-    // It may throw *NotDefined
-    root->objects->cancelNegotiatedAttributeOwnershipDivestiture(federate,
-                                                                 id,
-                                                                 attributes,
-                                                                 list_size);
+		ObjectHandle id,
+		const std::vector <AttributeHandle> &attributes,
+		uint16_t list_size)
+throw (ObjectNotKnown,
+		AttributeNotDefined,
+		AttributeNotOwned,
+		AttributeDivestitureWasNotRequested,
+		FederateNotExecutionMember,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember.
+	this->check(federate);
+
+	// It may throw *NotDefined
+	root->objects->cancelNegotiatedAttributeOwnershipDivestiture(federate,
+			id,
+			attributes,
+			list_size);
 
-    D.Out(pdDebug, "CancelDivestiture sur Objet %u ", id);
-}
+	D.Out(pdDebug, "CancelDivestiture sur Objet %u ", id);
+		}
 
 // ----------------------------------------------------------------------------
 // respondRelease (attributeOwnershipRealeaseResponse)
 
 AttributeHandleSet*
 Federation::respondRelease(FederateHandle federate,
-                           ObjectHandle objectHandle,
-                           std::vector <AttributeHandle> &attributes,
-                           uint16_t list_size)
-    throw (ObjectNotKnown,
-           AttributeNotDefined,
-           AttributeNotOwned,
-           FederateWasNotAskedToReleaseAttribute,
-           FederateNotExecutionMember,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember.
-    this->check(federate);
-
-    D.Out(pdDebug, "RespondRelease on Object %u.", objectHandle);
-
-    // Get the object pointer by id from the root object
-    Object *object = root->objects->getObject(objectHandle);
-
-    // It may throw *NotDefined
-    return root->ObjectClasses->attributeOwnershipReleaseResponse(federate, object, attributes);
-}
+		ObjectHandle objectHandle,
+		const std::vector <AttributeHandle> &attributes,
+		uint16_t list_size)
+throw (ObjectNotKnown,
+		AttributeNotDefined,
+		AttributeNotOwned,
+		FederateWasNotAskedToReleaseAttribute,
+		FederateNotExecutionMember,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember.
+	this->check(federate);
+
+	D.Out(pdDebug, "RespondRelease on Object %u.", objectHandle);
+
+	// Get the object pointer by id from the root object
+	Object *object = root->objects->getObject(objectHandle);
+
+	// It may throw *NotDefined
+	return root->ObjectClasses->attributeOwnershipReleaseResponse(federate, object, attributes);
+		}
 
 // ----------------------------------------------------------------------------
 // cancelAttributeOwnershipAcquisition
 
 void
 Federation::cancelAcquisition(FederateHandle federate,
-                              ObjectHandle objectHandle,
-                              std::vector <AttributeHandle> &attributes,
-                              uint16_t list_size)
-    throw (ObjectNotKnown,
-           AttributeNotDefined,
-           AttributeAlreadyOwned,
-           AttributeAcquisitionWasNotRequested,
-           FederateNotExecutionMember,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
-{
-    // It may throw FederateNotExecutionMember.
-    this->check(federate);
-
-    D.Out(pdDebug, "CancelAcquisition sur Objet %u ", objectHandle);
-
-    // Get the object pointer by id from the root object
-    Object *object = root->objects->getObject(objectHandle);
-
-    // It may throw *NotDefined
-    root->ObjectClasses->cancelAttributeOwnershipAcquisition(federate, object, attributes);
-}
+		ObjectHandle objectHandle,
+		const std::vector <AttributeHandle> &attributes,
+		uint16_t list_size)
+throw (ObjectNotKnown,
+		AttributeNotDefined,
+		AttributeAlreadyOwned,
+		AttributeAcquisitionWasNotRequested,
+		FederateNotExecutionMember,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	// It may throw FederateNotExecutionMember.
+	this->check(federate);
+
+	D.Out(pdDebug, "CancelAcquisition sur Objet %u ", objectHandle);
+
+	// Get the object pointer by id from the root object
+	Object *object = root->objects->getObject(objectHandle);
+
+	// It may throw *NotDefined
+	root->ObjectClasses->cancelAttributeOwnershipAcquisition(federate, object, attributes);
+		}
 
 // ----------------------------------------------------------------------------
 long
 Federation::createRegion(FederateHandle federate,
-                         SpaceHandle space,
-                         long nb_extents)
-    throw (SpaceNotDefined, InvalidExtents, SaveInProgress, RestoreInProgress,
-           RTIinternalError)
-{
-    this->check(federate);
+		SpaceHandle space,
+		long nb_extents)
+throw (SpaceNotDefined, InvalidExtents, SaveInProgress, RestoreInProgress,
+		RTIinternalError)
+		{
+	this->check(federate);
 
-    return root->createRegion(space, nb_extents);
-}
+	return root->createRegion(space, nb_extents);
+		}
 
 // ----------------------------------------------------------------------------
 // modifyRegion
 void
 Federation::modifyRegion(FederateHandle federate, RegionHandle region,
-			 const std::vector<Extent> &extents)
-    throw (RegionNotKnown, InvalidExtents, SaveInProgress, RestoreInProgress,
-	   RTIinternalError)
-{
-    check(federate);
-    root->modifyRegion(region, extents);
-}
+		const std::vector<Extent> &extents)
+throw (RegionNotKnown, InvalidExtents, SaveInProgress, RestoreInProgress,
+		RTIinternalError)
+		{
+	check(federate);
+	root->modifyRegion(region, extents);
+		}
 
 // ----------------------------------------------------------------------------
 //! deleteRegion
 void
 Federation::deleteRegion(FederateHandle federate,
-                         long region)
-    throw (RegionNotKnown, RegionInUse, SaveInProgress, RestoreInProgress,
-           RTIinternalError)
-{
-    this->check(federate);
-
-    if (saveInProgress) {
-        throw SaveInProgress("");
-    }
-    if (restoreInProgress) {
-        throw RestoreInProgress("");
-    }
+		long region)
+throw (RegionNotKnown, RegionInUse, SaveInProgress, RestoreInProgress,
+		RTIinternalError)
+		{
+	this->check(federate);
 
-    // TODO: check RegionInUse
-    root->deleteRegion(region);
-}
+	if (saveInProgress) {
+		throw SaveInProgress("");
+	}
+	if (restoreInProgress) {
+		throw RestoreInProgress("");
+	}
+
+	// TODO: check RegionInUse
+	root->deleteRegion(region);
+		}
 
 // ----------------------------------------------------------------------------
 //! associateRegion
 void
 Federation::associateRegion(FederateHandle federate,
-			    ObjectHandle object,
-			    RegionHandle the_handle,
-			    unsigned short nb,
-			    std::vector <AttributeHandle> &attributes)
-    throw (RegionNotKnown, SaveInProgress, RestoreInProgress, RTIinternalError)
+		ObjectHandle object,
+		RegionHandle the_handle,
+		unsigned short nb,
+		const std::vector <AttributeHandle> &attributes)
+throw (RegionNotKnown, SaveInProgress, RestoreInProgress, RTIinternalError)
 {
-    check(federate);
+	check(federate);
 
-    RTIRegion *region = root->getRegion(the_handle);
+	RTIRegion *region = root->getRegion(the_handle);
 
-    root->getObject(object)->unassociate(region);
+	root->getObject(object)->unassociate(region);
 
-    for (int i = 0 ; i < nb ; ++i) {
-	root->getObjectAttribute(object, attributes[i])->associate(region);
-    }
+	for (int i = 0 ; i < nb ; ++i) {
+		root->getObjectAttribute(object, attributes[i])->associate(region);
+	}
 }
 
 // ----------------------------------------------------------------------------
 //! unassociateRegion
 void
 Federation::unassociateRegion(FederateHandle federate, ObjectHandle object,
-			      RegionHandle the_handle)
-    throw (RegionNotKnown, SaveInProgress, RestoreInProgress,
-	   RTIinternalError)
-{
-    check(federate);
-
-    RTIRegion *region = root->getRegion(the_handle);
-    root->getObject(object)->unassociate(region);
-}
+		RegionHandle the_handle)
+throw (RegionNotKnown, SaveInProgress, RestoreInProgress,
+		RTIinternalError)
+		{
+	check(federate);
+
+	RTIRegion *region = root->getRegion(the_handle);
+	root->getObject(object)->unassociate(region);
+		}
 
 // ----------------------------------------------------------------------------
 //! subscribeAttributesWR
 void
 Federation::subscribeAttributesWR(FederateHandle federate,
-				  ObjectClassHandle c,
-				  RegionHandle region_handle,
-				  unsigned short nb,
-				  std::vector <AttributeHandle> &attributes)
-    throw (RegionNotKnown,
-	   SaveInProgress,
-	   RestoreInProgress,
-	   RTIinternalError)
-{
-    check(federate);
-    root->ObjectClasses->subscribe(federate, c, attributes, nb,
-				   root->getRegion(region_handle));
-}
+		ObjectClassHandle c,
+		RegionHandle region_handle,
+		unsigned short nb,
+		const std::vector <AttributeHandle> &attributes)
+throw (RegionNotKnown,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	check(federate);
+	root->ObjectClasses->subscribe(federate, c, attributes, nb,
+			root->getRegion(region_handle));
+		}
 
 // ----------------------------------------------------------------------------
 //! unsubscribeAttributesWR
 void
 Federation::unsubscribeAttributesWR(FederateHandle federate,
-				    ObjectClassHandle object_class,
-				    RegionHandle region_handle)
-	throw (RegionNotKnown,
-	       SaveInProgress,
-	       RestoreInProgress,
-	       RTIinternalError)
-{
-    check(federate);
+		ObjectClassHandle object_class,
+		RegionHandle region_handle)
+throw (RegionNotKnown,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	check(federate);
 
-    RTIRegion *region = root->getRegion(region_handle);
+	RTIRegion *region = root->getRegion(region_handle);
 
-    root->getObjectClass(object_class)->unsubscribe(federate, region);
-}
+	root->getObjectClass(object_class)->unsubscribe(federate, region);
+		}
 
 // ----------------------------------------------------------------------------
 void
 Federation::subscribeInteractionWR(FederateHandle federate,
-				   InteractionClassHandle interaction,
-				   RegionHandle region_handle)
-	throw (RegionNotKnown,
-	       SaveInProgress,
-	       RestoreInProgress,
-	       RTIinternalError)
-{
-    check(federate);
+		InteractionClassHandle interaction,
+		RegionHandle region_handle)
+throw (RegionNotKnown,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	check(federate);
 
-    RTIRegion *region = root->getRegion(region_handle);
+	RTIRegion *region = root->getRegion(region_handle);
 
-    root->getInteractionClass(interaction)->subscribe(federate, region);
-}
+	root->getInteractionClass(interaction)->subscribe(federate, region);
+		}
 
 // ----------------------------------------------------------------------------
 void
 Federation::unsubscribeInteractionWR(FederateHandle federate,
-				     InteractionClassHandle interaction,
-				     RegionHandle region_handle)
-	throw (RegionNotKnown,
-	       SaveInProgress,
-	       RestoreInProgress,
-	       RTIinternalError)
-{
-    check(federate);
+		InteractionClassHandle interaction,
+		RegionHandle region_handle)
+throw (RegionNotKnown,
+		SaveInProgress,
+		RestoreInProgress,
+		RTIinternalError)
+		{
+	check(federate);
 
-    RTIRegion *region = root->getRegion(region_handle);
+	RTIRegion *region = root->getRegion(region_handle);
 
-    root->getInteractionClass(interaction)->unsubscribe(federate, region);
-}
+	root->getInteractionClass(interaction)->unsubscribe(federate, region);
+		}
 
 // ----------------------------------------------------------------------------
 ObjectHandle
 Federation::registerObjectWithRegion(FederateHandle federate,
-				     ObjectClassHandle class_handle,
-				     const std::string& object_name,
-				     RegionHandle region_handle,
-				     int nb,
-				     std::vector <AttributeHandle> &attributes)
-    throw (ObjectClassNotDefined, ObjectClassNotPublished,
-	   AttributeNotDefined, AttributeNotPublished, RegionNotKnown,
-	   InvalidRegionContext, ObjectAlreadyRegistered,
-	   SaveInProgress, RestoreInProgress,
-	   RTIinternalError)
-{
-    G.Out(pdGendoc,"enter Federation::registerObjectWithRegion");
-    check(federate);
-
-    // Register object
-    ObjectHandle object = objectHandles.provide();
-    Debug(D, pdDebug) << "Register object with region : Object " << object
-	       << ", class " << class_handle << ", region " << region_handle
-	       << std::endl ;
-    string strname;
-    if (!object_name.empty()) {
-        strname = object_name;
-    } else {
-        // create a name if necessary
-        strname = stringize() << "HLAObject_" << object;
-    }
-
-    root->registerObjectInstance(federate, class_handle, object, strname);
-
-    Debug(D, pdDebug) << "- object \"" << strname
-	       << "\" registered" << std::endl ;
-
-    // Associate region
-    RTIRegion *region = root->getRegion(region_handle);
-    root->getObject(object)->unassociate(region);
-
-    for (int i = 0 ; i < nb ; ++i) {
-	root->getObjectAttribute(object, attributes[i])->associate(region);
-    }
-
-    Debug(D, pdDebug) << "- " << nb << " attribute(s) associated with region "
-	       << region_handle << std::endl ;
-    G.Out(pdGendoc,"exit  Federation::registerObjectWithRegion");
-    return object ;
-}
+		ObjectClassHandle class_handle,
+		const std::string& object_name,
+		RegionHandle region_handle,
+		int nb,
+		const std::vector <AttributeHandle> &attributes)
+throw (ObjectClassNotDefined, ObjectClassNotPublished,
+		AttributeNotDefined, AttributeNotPublished, RegionNotKnown,
+		InvalidRegionContext, ObjectAlreadyRegistered,
+		SaveInProgress, RestoreInProgress,
+		RTIinternalError)
+		{
+	G.Out(pdGendoc,"enter Federation::registerObjectWithRegion");
+	check(federate);
+
+	// Register object
+	ObjectHandle object = objectHandles.provide();
+	Debug(D, pdDebug) << "Register object with region : Object " << object
+			<< ", class " << class_handle << ", region " << region_handle
+			<< std::endl ;
+	string strname;
+	if (!object_name.empty()) {
+		strname = object_name;
+	} else {
+		// create a name if necessary
+		strname = stringize() << "HLAObject_" << object;
+	}
+
+	root->registerObjectInstance(federate, class_handle, object, strname);
+
+	Debug(D, pdDebug) << "- object \"" << strname
+			<< "\" registered" << std::endl ;
+
+	// Associate region
+	RTIRegion *region = root->getRegion(region_handle);
+	root->getObject(object)->unassociate(region);
+
+	for (int i = 0 ; i < nb ; ++i) {
+		root->getObjectAttribute(object, attributes[i])->associate(region);
+	}
+
+	Debug(D, pdDebug) << "- " << nb << " attribute(s) associated with region "
+			<< region_handle << std::endl ;
+	G.Out(pdGendoc,"exit  Federation::registerObjectWithRegion");
+	return object ;
+		}
 
 // ----------------------------------------------------------------------------
 bool
 Federation::restoreXmlData()
 {
 #ifndef HAVE_XML
-    return false ;
+	return false ;
 #else
-    xmlNodePtr cur ;
+	xmlNodePtr cur ;
 
-    cur = xmlDocGetRootElement(doc);
-    if (cur == 0) {
-        cerr << "XML file is empty" << endl ;
-        xmlFreeDoc(doc);
-        return false ;
-    }
-
-    // Is this root element an ROOT_NODE ?
-    if (xmlStrcmp(cur->name, ROOT_NODE)) {
-        cerr << "Wrong XML file: not the expected root node" << endl ;
-        return false ;
-    }
-
-    cur = cur->xmlChildrenNode ;
-    if (xmlStrcmp(cur->name, NODE_FEDERATION)) {
-        cerr << "Wrong XML file structure" << endl ;
-        return false ;
-    }
-
-    if (strcmp(name.c_str(), XmlParser::CleanXmlGetProp(cur,(const xmlChar*)"name")) != 0) {
-        cerr << "Wrong federation name" << endl ;
-    }
-
-
-    cur = cur->xmlChildrenNode ;
-
-    bool status = false;
-    while (cur != NULL) {
-        if ((!xmlStrcmp(cur->name, NODE_FEDERATE))) {
-            for (HandleFederateMap::iterator i = _handleFederateMap.begin(); i != _handleFederateMap.end(); ++i) {
-                if (!strcmp(i->second.getName().c_str(),XmlParser::CleanXmlGetProp(cur, (const xmlChar*) "name"))) {
-                    // Set federate constrained status
-                    if (!strcmp("true", XmlParser::CleanXmlGetProp(cur, (const xmlChar*) "constrained"))) {
-                        status = true ;
-                    }
-                    else {
-                        status = false ;
-                    }
-
-                    i->second.setConstrained(status);
-
-                    // Set federate regulating status
-                    status = !strcmp("true", XmlParser::CleanXmlGetProp(cur, (const xmlChar *) "regulator"));
-
-                    i->second.setRegulator(status);
-
-                    i->second.setHandle(strtol(XmlParser::CleanXmlGetProp(cur, (const xmlChar *) "handle"), 0, 10));
-                    break ;
-                }
-            }
-        }
-        cur = cur->next ;
-    }
+	cur = xmlDocGetRootElement(doc);
+	if (cur == 0) {
+		cerr << "XML file is empty" << endl ;
+		xmlFreeDoc(doc);
+		return false ;
+	}
+
+	// Is this root element an ROOT_NODE ?
+	if (xmlStrcmp(cur->name, ROOT_NODE)) {
+		cerr << "Wrong XML file: not the expected root node" << endl ;
+		return false ;
+	}
 
-    return status ;
+	cur = cur->xmlChildrenNode ;
+	if (xmlStrcmp(cur->name, NODE_FEDERATION)) {
+		cerr << "Wrong XML file structure" << endl ;
+		return false ;
+	}
+
+	if (strcmp(name.c_str(), XmlParser::CleanXmlGetProp(cur,(const xmlChar*)"name")) != 0) {
+		cerr << "Wrong federation name" << endl ;
+	}
+
+
+	cur = cur->xmlChildrenNode ;
+
+	bool status = false;
+	while (cur != NULL) {
+		if ((!xmlStrcmp(cur->name, NODE_FEDERATE))) {
+			for (HandleFederateMap::iterator i = _handleFederateMap.begin(); i != _handleFederateMap.end(); ++i) {
+				if (!strcmp(i->second.getName().c_str(),XmlParser::CleanXmlGetProp(cur, (const xmlChar*) "name"))) {
+					// Set federate constrained status
+					if (!strcmp("true", XmlParser::CleanXmlGetProp(cur, (const xmlChar*) "constrained"))) {
+						status = true ;
+					}
+					else {
+						status = false ;
+					}
+
+					i->second.setConstrained(status);
+
+					// Set federate regulating status
+					status = !strcmp("true", XmlParser::CleanXmlGetProp(cur, (const xmlChar *) "regulator"));
+
+					i->second.setRegulator(status);
+
+					i->second.setHandle(strtol(XmlParser::CleanXmlGetProp(cur, (const xmlChar *) "handle"), 0, 10));
+					break ;
+				}
+			}
+		}
+		cur = cur->next ;
+	}
+
+	return status ;
 #endif // HAVE_XML
 }
 
@@ -2488,89 +2488,88 @@
 Federation::saveXmlData()
 {
 #ifndef HAVE_XML
-    return false ;
+	return false ;
 #else
-    doc = xmlNewDoc((const xmlChar *) "1.0");
-    doc->children = xmlNewDocNode(doc, NULL, ROOT_NODE, NULL);
+	doc = xmlNewDoc((const xmlChar *) "1.0");
+	doc->children = xmlNewDocNode(doc, NULL, ROOT_NODE, NULL);
 
-    xmlNodePtr federation ;
-    federation = xmlNewChild(doc->children, NULL, NODE_FEDERATION, NULL);
+	xmlNodePtr federation ;
+	federation = xmlNewChild(doc->children, NULL, NODE_FEDERATION, NULL);
 
-    xmlSetProp(federation, (const xmlChar *) "name", (const xmlChar *) name.c_str());
+	xmlSetProp(federation, (const xmlChar *) "name", (const xmlChar *) name.c_str());
 
-    char t[10] ;
-    sprintf(t, "%u", handle);
-    xmlSetProp(federation, (const xmlChar *) "handle", (const xmlChar *) t);
+	char t[10] ;
+	sprintf(t, "%u", handle);
+	xmlSetProp(federation, (const xmlChar *) "handle", (const xmlChar *) t);
 
-    xmlNodePtr federate ;
+	xmlNodePtr federate ;
 
-    for (HandleFederateMap::iterator i = _handleFederateMap.begin(); i != _handleFederateMap.end(); ++i) {
-        federate = xmlNewChild(federation, NULL, NODE_FEDERATE, NULL);
+	for (HandleFederateMap::iterator i = _handleFederateMap.begin(); i != _handleFederateMap.end(); ++i) {
+		federate = xmlNewChild(federation, NULL, NODE_FEDERATE, NULL);
 
-        xmlSetProp(federate,
-                   (const xmlChar *) "name",
-                   (const xmlChar *) i->second.getName().c_str());
+		xmlSetProp(federate,
+				(const xmlChar *) "name",
+				(const xmlChar *) i->second.getName().c_str());
 
-        sprintf(t, "%u", i->second.getHandle());
-        xmlSetProp(federate, (const xmlChar *) "handle", (const xmlChar *) t);
+		sprintf(t, "%u", i->second.getHandle());
+		xmlSetProp(federate, (const xmlChar *) "handle", (const xmlChar *) t);
 
-        xmlSetProp(federate,
-                   (const xmlChar *)"constrained", (const xmlChar *)
-                   ((i->second.isConstrained()) ? "true" : "false"));
-        xmlSetProp(federate, (const xmlChar *) "regulator",
-                   (const xmlChar *)((i->second.isRegulator()) ? "true" : "false"));
-    }
+		xmlSetProp(federate,
+				(const xmlChar *)"constrained", (const xmlChar *)
+				((i->second.isConstrained()) ? "true" : "false"));
+		xmlSetProp(federate, (const xmlChar *) "regulator",
+				(const xmlChar *)((i->second.isRegulator()) ? "true" : "false"));
+	}
 
-    xmlSetDocCompressMode(doc, 9);
+	xmlSetDocCompressMode(doc, 9);
 
-    string filename = name + "_" + saveLabel + ".xcs" ;
-    xmlSaveFile(filename.c_str(), doc);
+	string filename = name + "_" + saveLabel + ".xcs" ;
+	xmlSaveFile(filename.c_str(), doc);
 
-    // TODO: tests
+	// TODO: tests
 
-    return true ;
+	return true ;
 #endif // HAVE_XML
 }
 // ----------------------------------------------------------------------------
 FederateHandle
 Federation::requestObjectOwner(FederateHandle theFederateHandle,
-                             ObjectHandle theObject,
-                             std::vector <AttributeHandle> &theAttributeList,
-                             uint16_t theListSize)
-        throw (ObjectNotKnown)
-{
-FederateHandle theOwnerHandle ;
-NM_Provide_Attribute_Value_Update mess ;
-
-    G.Out(pdGendoc,"enter Federation::requestObjectOwner");
-
-    // Request Object.
-    theOwnerHandle = root->requestObjectOwner(theFederateHandle,theObject) ;
-
-    // Send a PROVIDE_ATTRIBUTE_VALUE_UPDATE to the owner
-    mess.federate = theFederateHandle ;
-    mess.object = theObject ;
-    mess.handleArraySize = theListSize ;
-    mess.handleArray.resize(theListSize) ;
-    for (int i = 0 ; i < theListSize ; i++)
-        {
-        mess.handleArray[i] = theAttributeList[i] ;
-        }
-
-     // JYR : BUG if getSocketLink return NULL means
-     // owner federate has been killed and so rtig don't crash
-     // better development needed
-     if ( server->getSocketLink(theOwnerHandle) == NULL )
-        {
-        throw ObjectNotKnown ( "Owner federate killed") ;
-        }
-
-     mess.send(server->getSocketLink(theOwnerHandle),NM_msgBufSend);
-
-   G.Out(pdGendoc,"            requestObjectOwner ===> write PAVU to RTIA %d"
-                   ,theOwnerHandle);
-    G.Out(pdGendoc,"exit  Federation::requestObjectOwner");
-    return(theOwnerHandle);
+		ObjectHandle theObject,
+		const std::vector <AttributeHandle> &theAttributeList,
+		uint16_t theListSize)
+throw (ObjectNotKnown)
+{
+	FederateHandle theOwnerHandle ;
+	NM_Provide_Attribute_Value_Update mess ;
+
+	G.Out(pdGendoc,"enter Federation::requestObjectOwner");
+
+	// Request Object.
+	theOwnerHandle = root->requestObjectOwner(theFederateHandle,theObject) ;
+
+	// Send a PROVIDE_ATTRIBUTE_VALUE_UPDATE to the owner
+	mess.federate = theFederateHandle ;
+	mess.setObject(theObject);
+	mess.setAttributesSize(theListSize) ;
+	for (int i = 0 ; i < theListSize ; i++)
+	{
+		mess.setAttributes(theAttributeList[i],i) ;
+	}
+
+	// JYR : BUG if getSocketLink return NULL means
+	// owner federate has been killed and so rtig don't crash
+	// better development needed
+	if ( server->getSocketLink(theOwnerHandle) == NULL )
+	{
+		throw ObjectNotKnown ( "Owner federate killed") ;
+	}
+
+	mess.send(server->getSocketLink(theOwnerHandle),NM_msgBufSend);
+
+	G.Out(pdGendoc,"            requestObjectOwner ===> write PAVU to RTIA %d"
+			,theOwnerHandle);
+	G.Out(pdGendoc,"exit  Federation::requestObjectOwner");
+	return(theOwnerHandle);
 
 }
 
Index: RTIG/Federation.hh
===================================================================
RCS file: /sources/certi/certi/RTIG/Federation.hh,v
retrieving revision 3.64
diff -u -r3.64 Federation.hh
--- RTIG/Federation.hh	7 Mar 2010 21:30:30 -0000	3.64
+++ RTIG/Federation.hh	18 Mar 2010 18:31:08 -0000
@@ -192,7 +192,7 @@
                                  const std::string& the_label,
                                  const std::string& the_tag,
                                  unsigned short federate_setSize,
-                                 std::vector <FederateHandle> &federate_set)
+                                 const std::vector <FederateHandle> &federate_set)
         throw (FederateNotExecutionMember,
                FederationAlreadyPaused,
                SaveInProgress,
@@ -216,7 +216,7 @@
                                   const std::string& label,
                                   const std::string& tag,
                                   unsigned short federate_setSize,
-                                  std::vector <FederateHandle> &federate_set)
+                                  const std::vector <FederateHandle> &federate_set)
         throw (RTIinternalError);
 
 
@@ -269,7 +269,7 @@
 
     void publishObject(FederateHandle theFederateHandle,
                        ObjectClassHandle theObjectHandle,
-                       std::vector <AttributeHandle> &theAttributeList,
+                       const std::vector <AttributeHandle> &theAttributeList,
                        uint16_t theListSize,
                        bool PubOrUnpub)
         throw (ObjectClassNotDefined,
@@ -294,7 +294,7 @@
 
     FederateHandle requestObjectOwner(FederateHandle theFederateHandle,
                                 ObjectHandle theObject,
-                                std::vector <AttributeHandle> &theAttributeList,
+                                const std::vector <AttributeHandle> &theAttributeList,
                                 uint16_t theListSize)
         throw (ObjectNotKnown);
 
@@ -309,7 +309,7 @@
     */
     void subscribeObject(FederateHandle theFederateHandle,
                          ObjectClassHandle theObjectHandle,
-                         std::vector <AttributeHandle> &theAttributeList,
+                         const std::vector <AttributeHandle> &theAttributeList,
                          uint16_t theListSize)
         throw (ObjectClassNotDefined,
                AttributeNotDefined,
@@ -321,8 +321,8 @@
 
     void updateAttributeValues(FederateHandle theFederateHandle,
                                ObjectHandle theObjectHandle,
-                               std::vector <AttributeHandle> &theAttributeList,
-                               std::vector <AttributeValue_t> &theValueList,
+                               const std::vector <AttributeHandle> &theAttributeList,
+                               const std::vector <AttributeValue_t> &theValueList,
                                uint16_t theListSize,
                                FederationTime theTime,
                                const std::string& theTag)
@@ -336,8 +336,8 @@
 
     void updateAttributeValues(FederateHandle theFederateHandle,
                                ObjectHandle theObjectHandle,
-                               std::vector <AttributeHandle> &theAttributeList,
-                               std::vector <AttributeValue_t> &theValueList,
+                               const std::vector <AttributeHandle> &theAttributeList,
+                               const std::vector <AttributeValue_t> &theValueList,
                                uint16_t theListSize,
                                const std::string& theTag)
         throw (FederateNotExecutionMember,
@@ -354,8 +354,8 @@
 
     void broadcastInteraction(FederateHandle theFederateHandle,
                               InteractionClassHandle theInteractionHandle,
-                              std::vector <ParameterHandle> &theParameterList,
-                              std::vector <ParameterValue_t> &theValueList,
+                              const std::vector <ParameterHandle> &theParameterList,
+                              const std::vector <ParameterValue_t> &theValueList,
                               uint16_t theListSize,
                               FederationTime theTime,
 			      RegionHandle,
@@ -370,8 +370,8 @@
 
    void broadcastInteraction(FederateHandle theFederateHandle,
                               InteractionClassHandle theInteractionHandle,
-                              std::vector <ParameterHandle> &theParameterList,
-                              std::vector <ParameterValue_t> &theValueList,
+                              const std::vector <ParameterHandle> &theParameterList,
+                              const std::vector <ParameterValue_t> &theValueList,
                               uint16_t theListSize,
 			      RegionHandle,
                               const std::string& theTag)
@@ -430,7 +430,7 @@
 
     void negotiateDivestiture(FederateHandle theFederateHandle,
                               ObjectHandle theObjectHandle,
-                              std::vector <AttributeHandle> &theAttributeList,
+                              const std::vector <AttributeHandle> &theAttributeList,
                               uint16_t theListSize,
                               const std::string& theTag)
         throw (FederateNotExecutionMember,
@@ -444,7 +444,7 @@
 
     void acquireIfAvailable(FederateHandle theFederateHandle,
                             ObjectHandle theObjectHandle,
-                            std::vector <AttributeHandle> &theAttributeList,
+                            const std::vector <AttributeHandle> &theAttributeList,
                             uint16_t theListSize)
         throw (ObjectNotKnown,
                ObjectClassNotPublished,
@@ -459,7 +459,7 @@
 
     void divest(FederateHandle theFederateHandle,
                 ObjectHandle theObjectHandle,
-                std::vector <AttributeHandle> &theAttributeList,
+                const std::vector <AttributeHandle> &theAttributeList,
                 uint16_t theListSize)
         throw (ObjectNotKnown,
                AttributeNotDefined,
@@ -471,7 +471,7 @@
 
     void acquire(FederateHandle theFederateHandle,
                  ObjectHandle theObjectHandle,
-                 std::vector <AttributeHandle> &theAttributeList,
+                 const std::vector <AttributeHandle> &theAttributeList,
                  uint16_t theListSize,
                  const std::string& theTag)
         throw (ObjectNotKnown,
@@ -486,7 +486,7 @@
 
     void cancelDivestiture(FederateHandle theFederateHandle,
                            ObjectHandle theObjectHandle,
-                           std::vector <AttributeHandle> &theAttributeList,
+                           const std::vector <AttributeHandle> &theAttributeList,
                            uint16_t theListSize)
         throw (ObjectNotKnown,
                AttributeNotDefined,
@@ -499,7 +499,7 @@
 
     AttributeHandleSet* respondRelease(FederateHandle theFederateHandle,
                                        ObjectHandle theObjectHandle,
-                                       std::vector <AttributeHandle> &theAttributeList,
+                                       const std::vector <AttributeHandle> &theAttributeList,
                                        uint16_t theListSize)
         throw (ObjectNotKnown,
                AttributeNotDefined,
@@ -512,7 +512,7 @@
 
     void cancelAcquisition(FederateHandle theFederateHandle,
                            ObjectHandle theObjectHandle,
-                           std::vector <AttributeHandle> &theAttributeList,
+                           const std::vector <AttributeHandle> &theAttributeList,
                            uint16_t theListSize)
         throw (ObjectNotKnown,
                AttributeNotDefined,
@@ -547,7 +547,7 @@
                RTIinternalError);
 
     void associateRegion(FederateHandle, ObjectHandle, RegionHandle,
-			 unsigned short, std::vector <AttributeHandle> &)
+			 unsigned short, const std::vector <AttributeHandle> &)
 	throw (RegionNotKnown,
 	       SaveInProgress,
 	       RestoreInProgress,
@@ -560,7 +560,7 @@
 	       RTIinternalError);
 
     void subscribeAttributesWR(FederateHandle, ObjectClassHandle, RegionHandle,
-				unsigned short, std::vector <AttributeHandle> &)
+				unsigned short,const std::vector <AttributeHandle> &)
 	throw (RegionNotKnown,
 	       SaveInProgress,
 	       RestoreInProgress,
@@ -589,7 +589,7 @@
 
     ObjectHandle registerObjectWithRegion(FederateHandle,ObjectClassHandle,
 					  const std::string&, RegionHandle, int,
-					  std::vector <AttributeHandle> &)
+					  const std::vector <AttributeHandle> &)
 	throw (ObjectClassNotDefined, ObjectClassNotPublished,
 	       AttributeNotDefined, AttributeNotPublished, RegionNotKnown,
 	       InvalidRegionContext, ObjectAlreadyRegistered,
@@ -653,7 +653,7 @@
     void broadcastAnyMessage(NetworkMessage *msg, FederateHandle Except);
 
     void broadcastSomeMessage(NetworkMessage *msg, FederateHandle Except,
-                       std::vector <FederateHandle> &fede_array, int nbfed);
+                       const std::vector <FederateHandle> &fede_array, uint32_t nbfed);
 
     Federate &getFederate(const std::string& theName)
         throw (FederateNotExecutionMember);
Index: RTIG/RTIG.cc
===================================================================
RCS file: /sources/certi/certi/RTIG/RTIG.cc,v
retrieving revision 3.61
diff -u -r3.61 RTIG.cc
--- RTIG/RTIG.cc	24 Nov 2009 19:11:38 -0000	3.61
+++ RTIG/RTIG.cc	18 Mar 2010 18:31:09 -0000
@@ -89,7 +89,7 @@
 Socket*
 RTIG::chooseProcessingMethod(Socket *link, NetworkMessage *msg)
 {
-    G.Out(pdGendoc,"enter RTIG::chooseProcessingMethod type (%s)",msg->getName());
+    G.Out(pdGendoc,"enter RTIG::chooseProcessingMethod type (%s)",msg->getMessageName());
     // This may throw a security error.
     if ( msg->getType() != NetworkMessage::DESTROY_FEDERATION_EXECUTION)
        socketServer.checkMessage(link->returnSocket(), msg);
@@ -104,13 +104,13 @@
       case NetworkMessage::UPDATE_ATTRIBUTE_VALUES:
         D.Out(pdDebug, "UpdateAttributeValue.");
         auditServer.setLevel(1);
-        processUpdateAttributeValues(link, msg);
+        processUpdateAttributeValues(link, static_cast<NM_Update_Attribute_Values*>(msg));
         break ;
 
       case NetworkMessage::SEND_INTERACTION:
         D.Out(pdTrace, "send interaction.");
         auditServer.setLevel(2);
-        processSendInteraction(link, msg);
+        processSendInteraction(link, static_cast<NM_Send_Interaction*>(msg));
         break ;
 
       case NetworkMessage::CLOSE_CONNEXION:
@@ -197,7 +197,7 @@
       case NetworkMessage::REQUEST_OBJECT_ATTRIBUTE_VALUE_UPDATE:
 	Debug(D, pdTrace) << "requestAttributeValueUpdate" << endl ;
         auditServer.setLevel(6);
-        processRequestObjectAttributeValueUpdate(link, msg);
+        processRequestObjectAttributeValueUpdate(link, static_cast<NM_Request_Object_Attribute_Value_Update*>(msg));
         break ;
 
       case NetworkMessage::SET_TIME_REGULATING:
@@ -218,28 +218,28 @@
       case NetworkMessage::UNPUBLISH_OBJECT_CLASS:
         D.Out(pdTrace, "un/publishObjectClass.");
         auditServer.setLevel(7);
-        processPublishObjectClass(link, msg);
+        processPublishObjectClass(link,  static_cast<NM_Publish_Object_Class*>(msg));
         break ;
 
       case NetworkMessage::PUBLISH_INTERACTION_CLASS:
       case NetworkMessage::UNPUBLISH_INTERACTION_CLASS:
         D.Out(pdTrace, "un/publishInteractionClass.");
         auditServer.setLevel(7);
-        processPublishInteractionClass(link, msg);
+        processPublishInteractionClass(link, static_cast<NM_Publish_Interaction_Class*>(msg));
         break ;
 
       case NetworkMessage::SUBSCRIBE_OBJECT_CLASS:
       case NetworkMessage::UNSUBSCRIBE_OBJECT_CLASS:
         D.Out(pdTrace, "un/subscribeObjectClass.");
         auditServer.setLevel(7);
-        processSubscribeObjectClass(link, msg);
+        processSubscribeObjectClass(link, static_cast<NM_Subscribe_Object_Class*>(msg));
         break ;
 
       case NetworkMessage::SUBSCRIBE_INTERACTION_CLASS:
       case NetworkMessage::UNSUBSCRIBE_INTERACTION_CLASS:
         D.Out(pdTrace, "un/subscribeInteractionClass.");
         auditServer.setLevel(7);
-        processSubscribeInteractionClass(link, msg);
+        processSubscribeInteractionClass(link, static_cast<NM_Subscribe_Interaction_Class*>(msg));
         break ;
 
       case NetworkMessage::SET_CLASS_RELEVANCE_ADVISORY_SWITCH:
@@ -273,127 +273,127 @@
       case NetworkMessage::REGISTER_OBJECT:
         D.Out(pdTrace, "registerObject.");
         auditServer.setLevel(6);
-        processRegisterObject(link, msg);
+        processRegisterObject(link,static_cast<NM_Register_Object*>(msg));
         break ;
 
       case NetworkMessage::DELETE_OBJECT:
         D.Out(pdTrace, "DeleteObject..");
         auditServer.setLevel(6);
-        processDeleteObject(link, msg);
+        processDeleteObject(link, static_cast<NM_Delete_Object*>(msg));
         break ;
 
       case NetworkMessage::IS_ATTRIBUTE_OWNED_BY_FEDERATE:
         D.Out(pdTrace, "isAttributeOwnedByFederate..");
         auditServer.setLevel(2);
-        processAttributeOwnedByFederate(link, msg);
+        processAttributeOwnedByFederate(link, static_cast<NM_Is_Attribute_Owned_By_Federate*>(msg));
         break ;
 
       case NetworkMessage::QUERY_ATTRIBUTE_OWNERSHIP:
         D.Out(pdTrace, "queryAttributeOwnership..");
         auditServer.setLevel(2);
-        processQueryAttributeOwnership(link, msg);
+        processQueryAttributeOwnership(link, static_cast<NM_Query_Attribute_Ownership*>(msg));
         break ;
 
       case NetworkMessage::NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE:
         D.Out(pdTrace, "negotiatedAttributeOwnershipDivestiture..");
         auditServer.setLevel(6);
-        processNegotiatedOwnershipDivestiture(link, msg);
+        processNegotiatedOwnershipDivestiture(link, static_cast<NM_Negotiated_Attribute_Ownership_Divestiture*>(msg));
         break ;
 
       case NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION_IF_AVAILABLE:
         D.Out(pdTrace, "attributeOwnershipAcquisitionIfAvailable..");
         auditServer.setLevel(6);
-        processAcquisitionIfAvailable(link, msg);
+        processAcquisitionIfAvailable(link, static_cast<NM_Attribute_Ownership_Acquisition_If_Available*>(msg));
         break ;
 
       case NetworkMessage::UNCONDITIONAL_ATTRIBUTE_OWNERSHIP_DIVESTITURE:
         D.Out(pdTrace, "unconditionalAttributeOwnershipDivestiture..");
         auditServer.setLevel(6);
-        processUnconditionalDivestiture(link, msg);
+        processUnconditionalDivestiture(link, static_cast<NM_Unconditional_Attribute_Ownership_Divestiture*>(msg));
         break ;
 
       case NetworkMessage::ATTRIBUTE_OWNERSHIP_ACQUISITION:
         D.Out(pdTrace, "attributeOwnershipAcquisition..");
         auditServer.setLevel(6);
-        processOwnershipAcquisition(link, msg);
+        processOwnershipAcquisition(link, static_cast<NM_Attribute_Ownership_Acquisition*>(msg));
         break ;
 
       case NetworkMessage::CANCEL_NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE:
         D.Out(pdTrace, "cancelNegociatedAttributeOwnershipDivestiture..");
         auditServer.setLevel(6);
-        processCancelNegotiatedDivestiture(link, msg);
+        processCancelNegotiatedDivestiture(link, static_cast<NM_Cancel_Negotiated_Attribute_Ownership_Divestiture*>(msg));
         break ;
 
       case NetworkMessage::ATTRIBUTE_OWNERSHIP_RELEASE_RESPONSE:
         D.Out(pdTrace, "attributeOwnershipReleaseResponse..");
         auditServer.setLevel(6);
-        processReleaseResponse(link, msg);
+        processReleaseResponse(link, static_cast<NM_Attribute_Ownership_Release_Response*>(msg));
         break ;
 
       case NetworkMessage::CANCEL_ATTRIBUTE_OWNERSHIP_ACQUISITION:
         D.Out(pdTrace, "cancelAttributeOwnershipAcquisition..");
         auditServer.setLevel(6);
-        processCancelAcquisition(link, msg);
+        processCancelAcquisition(link, static_cast<NM_Cancel_Attribute_Ownership_Acquisition*>(msg));
         break ;
 
       case NetworkMessage::DDM_CREATE_REGION:
         Debug(D, pdTrace) << "createRegion" << endl ;
         auditServer.setLevel(6);
-        processCreateRegion(link, msg);
+        processCreateRegion(link, static_cast<NM_DDM_Create_Region*>(msg));
         break ;
 
       case NetworkMessage::DDM_MODIFY_REGION:
 		Debug(D, pdTrace) << "modifyRegion" << endl ;
 		auditServer.setLevel(6);
-        processModifyRegion(link, msg);
+        processModifyRegion(link, static_cast<NM_DDM_Modify_Region*>(msg));
         break ;
 
       case NetworkMessage::DDM_DELETE_REGION:
         Debug(D, pdTrace) << "deleteRegion" << endl ;
         auditServer.setLevel(6);
-        processDeleteRegion(link, msg);
+        processDeleteRegion(link, static_cast<NM_DDM_Delete_Region*>(msg));
         break ;
 
       case NetworkMessage::DDM_REGISTER_OBJECT:
         Debug(D, pdTrace) << "registerObjectWithRegion" << endl ;
         auditServer.setLevel(6);
-        processRegisterObjectWithRegion(link, msg);
+        processRegisterObjectWithRegion(link, static_cast<NM_DDM_Register_Object*>(msg));
         break ;
 
       case NetworkMessage::DDM_ASSOCIATE_REGION:
 	Debug(D, pdTrace) << "associateRegionForUpdates" << endl ;
         auditServer.setLevel(6);
-        processAssociateRegion(link, msg);
+        processAssociateRegion(link, static_cast<NM_DDM_Associate_Region*>(msg));
         break ;
 
       case NetworkMessage::DDM_UNASSOCIATE_REGION:
 	Debug(D, pdTrace) << "unassociateRegionForUpdates" << endl ;
         auditServer.setLevel(6);
-        processUnassociateRegion(link, msg);
+        processUnassociateRegion(link, static_cast<NM_DDM_Unassociate_Region*>(msg));
         break ;
 
       case NetworkMessage::DDM_SUBSCRIBE_ATTRIBUTES:
 	Debug(D, pdTrace) << "subscribeObjectClassAttributes (DDM)" << endl ;
         auditServer.setLevel(6);
-        processSubscribeAttributesWR(link, msg);
+        processSubscribeAttributesWR(link, static_cast<NM_DDM_Subscribe_Attributes*>(msg));
         break ;
 
       case NetworkMessage::DDM_UNSUBSCRIBE_ATTRIBUTES:
 	Debug(D, pdTrace) << "unsubscribeObjectClassAttributes (DDM)" << endl ;
         auditServer.setLevel(6);
-        processUnsubscribeAttributesWR(link, msg);
+        processUnsubscribeAttributesWR(link, static_cast<NM_DDM_Unsubscribe_Attributes*>(msg));
         break ;
 
       case NetworkMessage::DDM_SUBSCRIBE_INTERACTION:
 	Debug(D, pdTrace) << "subscribeInteraction (DDM)" << endl ;
         auditServer.setLevel(6);
-        processSubscribeInteractionWR(link, msg);
+        processSubscribeInteractionWR(link, static_cast<NM_DDM_Subscribe_Interaction*>(msg));
         break ;
 
       case NetworkMessage::DDM_UNSUBSCRIBE_INTERACTION:
 	Debug(D, pdTrace) << "unsubscribeInteraction (DDM)" << endl ;
         auditServer.setLevel(6);
-        processUnsubscribeInteractionWR(link, msg);
+        processUnsubscribeInteractionWR(link, static_cast<NM_DDM_Unsubscribe_Interaction*>(msg));
         break ;
 
       default:
Index: RTIG/RTIG_processing.cc
===================================================================
RCS file: /sources/certi/certi/RTIG/RTIG_processing.cc,v
retrieving revision 3.94
diff -u -r3.94 RTIG_processing.cc
--- RTIG/RTIG_processing.cc	1 Mar 2010 16:44:27 -0000	3.94
+++ RTIG/RTIG_processing.cc	18 Mar 2010 18:31:09 -0000
@@ -44,84 +44,84 @@
 void
 RTIG::processCreateFederation(Socket *link, NM_Create_Federation_Execution *req)
 {
-    std::string federation = req->getFederationName();
-    std::string FEDid      = req->getFEDid();
-    NM_Create_Federation_Execution  rep;   // rep for answer to RTIA
-
-    G.Out(pdGendoc,"enter RTIG::processCreateFederation");
-    G.Out(pdGendoc,"BEGIN ** CREATE FEDERATION SERVICE **");
-
-    if (federation.length() == 0)
-        {
-        G.Out(pdGendoc,"exit  RTIG::processCreateFederation on exception RTIinternalError");
-        throw RTIinternalError("Invalid Federation Name.");
-        }
+	std::string federation = req->getFederationName();
+	std::string FEDid      = req->getFEDid();
+	NM_Create_Federation_Execution  rep;   // rep for answer to RTIA
+
+	G.Out(pdGendoc,"enter RTIG::processCreateFederation");
+	G.Out(pdGendoc,"BEGIN ** CREATE FEDERATION SERVICE **");
+
+	if (federation.length() == 0)
+	{
+		G.Out(pdGendoc,"exit  RTIG::processCreateFederation on exception RTIinternalError");
+		throw RTIinternalError("Invalid Federation Name.");
+	}
 
-    auditServer << "Federation Name : " << federation;
-    Handle h = federationHandles.provide();
+	auditServer << "Federation Name : " << federation;
+	Handle h = federationHandles.provide();
 
 #ifdef FEDERATION_USES_MULTICAST
-    // multicast base address
-    unsigned long base_adr_mc = inet_addr(ADRESSE_MULTICAST);
-    SocketMC *com_mc = NULL ;
-
-    // creer la communication multicast
-    com_mc = new SocketMC();
-    if (com_mc == NULL) {
-        D.Out(pdExcept, "Unable to allocate Multicast socket.");
-        G.Out(pdGendoc,"exit  RTIG::processCreateFederation on exception RTIinternalError")
-        throw RTIinternalError("Unable to allocate Multicast socket.");
-    }
+	// multicast base address
+	unsigned long base_adr_mc = inet_addr(ADRESSE_MULTICAST);
+	SocketMC *com_mc = NULL ;
+
+	// creer la communication multicast
+	com_mc = new SocketMC();
+	if (com_mc == NULL) {
+		D.Out(pdExcept, "Unable to allocate Multicast socket.");
+		G.Out(pdGendoc,"exit  RTIG::processCreateFederation on exception RTIinternalError")
+        				throw RTIinternalError("Unable to allocate Multicast socket.");
+	}
 
-    com_mc->CreerSocketMC(base_adr_mc + h, MC_PORT);
+	com_mc->CreerSocketMC(base_adr_mc + h, MC_PORT);
 
-    // inserer la nouvelle federation dans la liste des federations
-    federations->createFederation(federation, h, com_mc);
+	// inserer la nouvelle federation dans la liste des federations
+	federations->createFederation(federation, h, com_mc);
 
-    // inserer descripteur fichier pour le prochain appel a un select
-    ClientSockets.push_front(com_mc);
+	// inserer descripteur fichier pour le prochain appel a un select
+	ClientSockets.push_front(com_mc);
 
 #else
-    // We catch createFederation because it is useful to send
-    // exception reason to RTIA
-    try {
-        federations.createFederation(federation, h, FEDid);
-        }
-    catch (CouldNotOpenFED e)
-        {
-        rep.setException(e_CouldNotOpenFED);
-        rep.exceptionReason=e._reason;
-        }
-    catch (ErrorReadingFED e)
-        {
-        rep.setException(e_ErrorReadingFED);
-        rep.exceptionReason = e._reason ;
-        }
-    catch (FederationExecutionAlreadyExists e)
-        {
-        rep.setException(e_FederationExecutionAlreadyExists);
-        rep.exceptionReason =e._reason ;
-        }
+	// We catch createFederation because it is useful to send
+	// exception reason to RTIA
+	try {
+		federations.createFederation(federation, h, FEDid);
+	}
+	catch (CouldNotOpenFED e)
+	{
+		rep.setException(e_CouldNotOpenFED);
+		rep.exceptionReason=e._reason;
+	}
+	catch (ErrorReadingFED e)
+	{
+		rep.setException(e_ErrorReadingFED);
+		rep.exceptionReason = e._reason ;
+	}
+	catch (FederationExecutionAlreadyExists e)
+	{
+		rep.setException(e_FederationExecutionAlreadyExists);
+		rep.exceptionReason =e._reason ;
+	}
 #endif
-    // Prepare answer for RTIA : store NetworkMessage rep
-    if ( rep.getException() == e_NO_EXCEPTION )
-        {
-        rep.federation = h ;
-        rep.setFEDid(FEDid);
-        rep.setFederationName(federation);
-        auditServer <<" created.";
+	// Prepare answer for RTIA : store NetworkMessage rep
+	if ( rep.getException() == e_NO_EXCEPTION )
+	{
+		rep.federation = h ;
+		rep.setFEDid(FEDid);
+		rep.setFederationName(federation);
+		auditServer <<" created.";
 
-        }
+	}
 
-    G.Out(pdGendoc,"processCreateFederation===>write answer to RTIA");
+	G.Out(pdGendoc,"processCreateFederation===>write answer to RTIA");
 
-    rep.send(link,NM_msgBufSend); // Send answer to RTIA
+	rep.send(link,NM_msgBufSend); // Send answer to RTIA
 
-    D.Out(pdInit, "Federation \"%s\" created with Handle %d.",
-          federation.c_str(), rep.federation);
+	D.Out(pdInit, "Federation \"%s\" created with Handle %d.",
+			federation.c_str(), rep.federation);
 
-    G.Out(pdGendoc,"END ** CREATE FEDERATION SERVICE **");
-    G.Out(pdGendoc,"exit RTIG::processCreateFederation");
+	G.Out(pdGendoc,"END ** CREATE FEDERATION SERVICE **");
+	G.Out(pdGendoc,"exit RTIG::processCreateFederation");
 }
 
 // ----------------------------------------------------------------------------
@@ -129,95 +129,95 @@
 void
 RTIG::processJoinFederation(Socket *link, NM_Join_Federation_Execution *req)
 {
-    std::string federation = req->getFederationName();
-    std::string federate   = req->getFederateName();
+	std::string federation = req->getFederationName();
+	std::string federate   = req->getFederateName();
 
-    unsigned int peer     = req->bestEffortPeer ;
-    unsigned long address = req->bestEffortAddress ;
+	unsigned int peer     = req->getBestEffortPeer();
+	unsigned long address = req->getBestEffortAddress();
 
-    FederateHandle num_federe ;
+	FederateHandle num_federe ;
 
-    int nb_regulateurs ;
-    int nb_federes ;
-    bool pause ;
-
-    G.Out(pdGendoc,"BEGIN ** JOIN FEDERATION SERVICE **");
-    G.Out(pdGendoc,"enter RTIG::processJoinFederation");
-
-    if (federation.empty() || federate.empty())
-        throw RTIinternalError("Invalid Federation/Federate Name.");
-
-    auditServer << "Federate \"" << federate << "\" joins Federation \""
-		<< federation << "\"" ;
-
-    Handle num_federation = federations.getFederationHandle(federation);
-
-    // Need to dump the fom into that
-    NM_Join_Federation_Execution rep ;
-    try
-       {
-        num_federe = federations.addFederate(num_federation,
-                                          federate,
-                                          static_cast<SocketTCP*>(link),
-                                          rep);
-        }
-    catch (FederateAlreadyExecutionMember &e)
-        {
-       G.Out(pdGendoc,"exit RTIG::processJoinFederation on Error");
-       G.Out(pdGendoc,"END ** JOIN FEDERATION (BAD) SERVICE **");
-       // Prepare answer about JoinFederationExecution
-       NM_Join_Federation_Execution rep ;
-       rep.setException(e_FederateAlreadyExecutionMember);
-       rep.exceptionReason = "Federate with same name has yet joined the federation";
-
-       G.Out(pdGendoc,"processJoinFederation==>Answer to RTIA JFE ERROR %s",rep.exceptionReason.c_str());
-
-       rep.send(link,NM_msgBufSend);
-       return ;
-       }
+	int nb_regulateurs ;
+	int nb_federes ;
+	bool pause ;
+
+	G.Out(pdGendoc,"BEGIN ** JOIN FEDERATION SERVICE **");
+	G.Out(pdGendoc,"enter RTIG::processJoinFederation");
+
+	if (federation.empty() || federate.empty())
+		throw RTIinternalError("Invalid Federation/Federate Name.");
+
+	auditServer << "Federate \"" << federate << "\" joins Federation \""
+			<< federation << "\"" ;
+
+	Handle num_federation = federations.getFederationHandle(federation);
+
+	// Need to dump the fom into that
+	NM_Join_Federation_Execution rep ;
+	try
+	{
+		num_federe = federations.addFederate(num_federation,
+				federate,
+				static_cast<SocketTCP*>(link),
+				rep);
+	}
+	catch (FederateAlreadyExecutionMember &e)
+	{
+		G.Out(pdGendoc,"exit RTIG::processJoinFederation on Error");
+		G.Out(pdGendoc,"END ** JOIN FEDERATION (BAD) SERVICE **");
+		// Prepare answer about JoinFederationExecution
+		NM_Join_Federation_Execution rep ;
+		rep.setException(e_FederateAlreadyExecutionMember);
+		rep.exceptionReason = "Federate with same name has yet joined the federation";
+
+		G.Out(pdGendoc,"processJoinFederation==>Answer to RTIA JFE ERROR %s",rep.exceptionReason.c_str());
+
+		rep.send(link,NM_msgBufSend);
+		return ;
+	}
 
 #ifdef FEDERATION_USES_MULTICAST
-     SocketMC *com_mc = NULL ;
+	SocketMC *com_mc = NULL ;
 
-     federations.info(num_federation, nb_federes, nb_regulateurs,
-                      pause, com_mc);
-     assert(com_mc != NULL);
+	federations.info(num_federation, nb_federes, nb_regulateurs,
+			pause, com_mc);
+	assert(com_mc != NULL);
 #else
-     federations.info(num_federation, nb_federes, nb_regulateurs, pause);
+	federations.info(num_federation, nb_federes, nb_regulateurs, pause);
 #endif
 
-    // Store Federate <->Socket reference.
-    socketServer.setReferences(link->returnSocket(),
-                                num_federation,
-                                num_federe,
-                                address,
-                                peer);
-
-    auditServer << "(" << num_federation << ")with handle " << num_federe
-		<< ". Socket " << int(link->returnSocket());
-
-    // Prepare answer about JoinFederationExecution
-    rep.setFederationName(federation);
-    rep.federate = num_federe ;
-    rep.federation = num_federation ;
-    rep.numberOfRegulators = nb_regulateurs ;
-    rep.bestEffortPeer = peer ;
-    rep.bestEffortAddress = address ;
+	// Store Federate <->Socket reference.
+	socketServer.setReferences(link->returnSocket(),
+			num_federation,
+			num_federe,
+			address,
+			peer);
+
+	auditServer << "(" << num_federation << ")with handle " << num_federe
+			<< ". Socket " << int(link->returnSocket());
+
+	// Prepare answer about JoinFederationExecution
+	rep.setFederationName(federation);
+	rep.federate = num_federe ;
+	rep.federation = num_federation ;
+	rep.setNumberOfRegulators(nb_regulateurs);
+	rep.setBestEffortPeer(peer);
+	rep.setBestEffortAddress(address);
 
-    // Now we have to answer about JoinFederationExecution
+	// Now we have to answer about JoinFederationExecution
 #ifdef FEDERATION_USES_MULTICAST
-    rep.AdresseMulticast = com_mc->returnAdress();
+	rep.AdresseMulticast = com_mc->returnAdress();
 #endif
 
-    D.Out(pdInit, "Federate \"%s\" has joined Federation %u under handle %u.",
-          federate.c_str(), num_federation, num_federe);
+	D.Out(pdInit, "Federate \"%s\" has joined Federation %u under handle %u.",
+			federate.c_str(), num_federation, num_federe);
 
-    // Send answer
+	// Send answer
 
-    rep.send(link,NM_msgBufSend);
+	rep.send(link,NM_msgBufSend);
 
-    G.Out(pdGendoc,"exit RTIG::processJoinFederation");
-    G.Out(pdGendoc,"END ** JOIN FEDERATION SERVICE **");
+	G.Out(pdGendoc,"exit RTIG::processJoinFederation");
+	G.Out(pdGendoc,"END ** JOIN FEDERATION SERVICE **");
 
 }
 
@@ -225,26 +225,26 @@
 //! Removes a federate from federation.
 void
 RTIG::processResignFederation(Socket *link,Handle federation,
-                              FederateHandle federe)
+		FederateHandle federe)
 {
-    NM_Resign_Federation_Execution reponse ;
+	NM_Resign_Federation_Execution reponse ;
 
-    G.Out(pdGendoc,"BEGIN ** RESIGN FEDERATION SERVICE **");
-    G.Out(pdGendoc,"enter RTIG::processResignFederation");
+	G.Out(pdGendoc,"BEGIN ** RESIGN FEDERATION SERVICE **");
+	G.Out(pdGendoc,"enter RTIG::processResignFederation");
 
-    federations.remove(federation, federe);
-    D.Out(pdInit, "Federate %u is resigning from federation %u.",
-          federe, federation);
+	federations.remove(federation, federe);
+	D.Out(pdInit, "Federate %u is resigning from federation %u.",
+			federe, federation);
 
-    auditServer << "Federate " << federe << " resign federation("<<federation<<")" ;
+	auditServer << "Federate " << federe << " resign federation("<<federation<<")" ;
 
-    // Send answer to RTIA
-    reponse.federate = federe ;
-    reponse.federation = federation ;
-    reponse.send(link,NM_msgBufSend);
+	// Send answer to RTIA
+	reponse.federate = federe ;
+	reponse.federation = federation ;
+	reponse.send(link,NM_msgBufSend);
 
-    G.Out(pdGendoc,"exit RTIG::processResignFederation");
-    G.Out(pdGendoc,"END ** RESIGN FEDERATION SERVICE **");
+	G.Out(pdGendoc,"exit RTIG::processResignFederation");
+	G.Out(pdGendoc,"END ** RESIGN FEDERATION SERVICE **");
 
 }
 
@@ -253,176 +253,176 @@
 void
 RTIG::processDestroyFederation(Socket *link, NM_Destroy_Federation_Execution *req)
 {
-    NM_Destroy_Federation_Execution rep ;
+	NM_Destroy_Federation_Execution rep ;
 
-    std::string federation = req->getFederationName();
+	std::string federation = req->getFederationName();
 
-    G.Out(pdGendoc,"enter RTIG::processDestroyFederation");
-    G.Out(pdGendoc,"BEGIN ** DESTROY FEDERATION SERVICE **");
+	G.Out(pdGendoc,"enter RTIG::processDestroyFederation");
+	G.Out(pdGendoc,"BEGIN ** DESTROY FEDERATION SERVICE **");
 
-    if (federation.length() == 0) throw RTIinternalError("Invalid Federation Name.");
+	if (federation.length() == 0) throw RTIinternalError("Invalid Federation Name.");
 
-    Handle num_federation = federations.getFederationHandle(federation);
-    // May throw RTIinternalError
-    //           FederatesCurrentlyJoined
-    //           FederationExecutionDoesNotExist
-    try {
-      federations.destroyFederation(num_federation);
-      // Here delete federation (num_federation) has been done
-      federationHandles.free(num_federation);
-      D.Out(pdInit, "Federation \"%s\" has been destroyed.", federation.c_str());
-    }
-    catch (Exception &e)
-      { printf("ERROR : %s  reason : %s\n",e._name,e._reason.c_str());
-        if (strcmp(e._name,"RTIinternalError")==0 )
-          {
-          rep.setException(e_RTIinternalError);
-          rep.exceptionReason = e._reason;
-          }
-        else if (strcmp(e._name,"FederationExecutionDoesNotExist")==0 )
-          {
-          rep.setException(e_FederationExecutionDoesNotExist);
-          rep.exceptionReason =e._reason;
-          }
-        else if (strcmp(e._name,"FederatesCurrentlyJoined")==0 )
-          {
-          rep.setException(e_FederatesCurrentlyJoined);
-          rep.exceptionReason = "at least one federate joined";
-          }
-      }
-
-    rep.federate = req->federate ;
-    rep.setFederationName(req->getFederationName());
-    if ( rep.getException() == e_NO_EXCEPTION )
-       {
-       auditServer << "Federation Name \"" << federation << "\"("<<num_federation<<") destroyed." ;
-       }
-    G.Out(pdGendoc,"processDestroyFederation===>write DFE to RTIA");
+	Handle num_federation = federations.getFederationHandle(federation);
+	// May throw RTIinternalError
+	//           FederatesCurrentlyJoined
+	//           FederationExecutionDoesNotExist
+	try {
+		federations.destroyFederation(num_federation);
+		// Here delete federation (num_federation) has been done
+		federationHandles.free(num_federation);
+		D.Out(pdInit, "Federation \"%s\" has been destroyed.", federation.c_str());
+	}
+	catch (Exception &e)
+	{ printf("ERROR : %s  reason : %s\n",e._name,e._reason.c_str());
+	if (strcmp(e._name,"RTIinternalError")==0 )
+	{
+		rep.setException(e_RTIinternalError);
+		rep.exceptionReason = e._reason;
+	}
+	else if (strcmp(e._name,"FederationExecutionDoesNotExist")==0 )
+	{
+		rep.setException(e_FederationExecutionDoesNotExist);
+		rep.exceptionReason =e._reason;
+	}
+	else if (strcmp(e._name,"FederatesCurrentlyJoined")==0 )
+	{
+		rep.setException(e_FederatesCurrentlyJoined);
+		rep.exceptionReason = "at least one federate joined";
+	}
+	}
+
+	rep.federate = req->federate ;
+	rep.setFederationName(req->getFederationName());
+	if ( rep.getException() == e_NO_EXCEPTION )
+	{
+		auditServer << "Federation Name \"" << federation << "\"("<<num_federation<<") destroyed." ;
+	}
+	G.Out(pdGendoc,"processDestroyFederation===>write DFE to RTIA");
 
-    rep.send(link,NM_msgBufSend);
+	rep.send(link,NM_msgBufSend);
 
-    G.Out(pdGendoc,"END ** DESTROY FEDERATION SERVICE **");
-    G.Out(pdGendoc,"exit RTIG::processDestroyFederation");
+	G.Out(pdGendoc,"END ** DESTROY FEDERATION SERVICE **");
+	G.Out(pdGendoc,"exit RTIG::processDestroyFederation");
 }
 
 // ----------------------------------------------------------------------------
 //! Set federate's class relevance advisroy switch
 void
 RTIG::processSetClassRelevanceAdvisorySwitch(Socket *link,
-			     NM_Set_Class_Relevance_Advisory_Switch *msg)
+		NM_Set_Class_Relevance_Advisory_Switch *msg)
 {
-  NM_Set_Class_Relevance_Advisory_Switch rep;
+	NM_Set_Class_Relevance_Advisory_Switch rep;
 
-  G.Out(pdGendoc,"enter RTIG::processSetClassRelevanceAdvisorySwitch");
-  G.Out(pdGendoc,"BEGIN ** SET CLASS RELEVANCE ADVISORY SWITCH **");
+	G.Out(pdGendoc,"enter RTIG::processSetClassRelevanceAdvisorySwitch");
+	G.Out(pdGendoc,"BEGIN ** SET CLASS RELEVANCE ADVISORY SWITCH **");
 
-  if (msg->getClassRelevanceAdvisorySwitch()) {
-        auditServer << "ON";
-	federations.setClassRelevanceAdvisorySwitch(msg->federation, msg->federate);
-        D.Out(pdTerm, "Federate %u of Federation %u sets AttributeRelevanceAdvisorySwitch.",
-              msg->federate, msg->federation);
-  }
-  else {
-        auditServer << "OFF";
-	federations.unsetClassRelevanceAdvisorySwitch(msg->federation, msg->federate);
-        D.Out(pdTerm, "Federate %u of Federation %u clears AttributeRelevanceAdvisorySwitch.",
-              msg->federate, msg->federation);
-  }
+	if (msg->isClassRelevanceAdvisorySwitchOn()) {
+		auditServer << "ON";
+		federations.setClassRelevanceAdvisorySwitch(msg->federation, msg->federate);
+		D.Out(pdTerm, "Federate %u of Federation %u sets AttributeRelevanceAdvisorySwitch.",
+				msg->federate, msg->federation);
+	}
+	else {
+		auditServer << "OFF";
+		federations.unsetClassRelevanceAdvisorySwitch(msg->federation, msg->federate);
+		D.Out(pdTerm, "Federate %u of Federation %u clears AttributeRelevanceAdvisorySwitch.",
+				msg->federate, msg->federation);
+	}
 
-  rep.send(link,NM_msgBufSend);
+	rep.send(link,NM_msgBufSend);
 
-  G.Out(pdGendoc,"END ** SET CLASS RELEVANCE ADVISORY SWITCH **");
-  G.Out(pdGendoc,"exit RTIG::processSetClassRelevanceAdvisorySwitch");
+	G.Out(pdGendoc,"END ** SET CLASS RELEVANCE ADVISORY SWITCH **");
+	G.Out(pdGendoc,"exit RTIG::processSetClassRelevanceAdvisorySwitch");
 }
 
 // ----------------------------------------------------------------------------
 //! Set federate's interaction relevance advisroy switch
 void
 RTIG::processSetInteractionRelevanceAdvisorySwitch(Socket *link,
-			     NM_Set_Interaction_Relevance_Advisory_Switch *msg)
+		NM_Set_Interaction_Relevance_Advisory_Switch *msg)
 {
-  NM_Set_Interaction_Relevance_Advisory_Switch rep;
+	NM_Set_Interaction_Relevance_Advisory_Switch rep;
 
-  G.Out(pdGendoc,"enter RTIG::processSetInteractionRelevanceAdvisorySwitch");
-  G.Out(pdGendoc,"BEGIN ** SET INTERACTION RELEVANCE ADVISORY SWITCH **");
+	G.Out(pdGendoc,"enter RTIG::processSetInteractionRelevanceAdvisorySwitch");
+	G.Out(pdGendoc,"BEGIN ** SET INTERACTION RELEVANCE ADVISORY SWITCH **");
 
-  if (msg->getInteractionRelevanceAdvisorySwitch()) {
-        auditServer << "ON";
-	federations.setInteractionRelevanceAdvisorySwitch(msg->federation, msg->federate);
-        D.Out(pdTerm, "Federate %u of Federation %u sets InteractionRelevanceAdvisorySwitch.",
-              msg->federate, msg->federation);
-  }
-  else {
-        auditServer << "OFF";
-	federations.unsetInteractionRelevanceAdvisorySwitch(msg->federation, msg->federate);
-        D.Out(pdTerm, "Federate %u of Federation %u clears InteractionRelevanceAdvisorySwitch.",
-              msg->federate, msg->federation);
-  }
+	if (msg->isInteractionRelevanceAdvisorySwitchOn()) {
+		auditServer << "ON";
+		federations.setInteractionRelevanceAdvisorySwitch(msg->federation, msg->federate);
+		D.Out(pdTerm, "Federate %u of Federation %u sets InteractionRelevanceAdvisorySwitch.",
+				msg->federate, msg->federation);
+	}
+	else {
+		auditServer << "OFF";
+		federations.unsetInteractionRelevanceAdvisorySwitch(msg->federation, msg->federate);
+		D.Out(pdTerm, "Federate %u of Federation %u clears InteractionRelevanceAdvisorySwitch.",
+				msg->federate, msg->federation);
+	}
 
-  rep.send(link,NM_msgBufSend);
+	rep.send(link,NM_msgBufSend);
 
-  G.Out(pdGendoc,"END ** SET INTERACTION RELEVANCE ADVISORY SWITCH **");
-  G.Out(pdGendoc,"exit RTIG::processSetInteractionRelevanceAdvisorySwitch");
+	G.Out(pdGendoc,"END ** SET INTERACTION RELEVANCE ADVISORY SWITCH **");
+	G.Out(pdGendoc,"exit RTIG::processSetInteractionRelevanceAdvisorySwitch");
 }
 
 // ----------------------------------------------------------------------------
 //! Set federate's attribute relevance advisroy switch
 void
 RTIG::processSetAttributeRelevanceAdvisorySwitch(Socket *link,
-			     NM_Set_Attribute_Relevance_Advisory_Switch *msg)
+		NM_Set_Attribute_Relevance_Advisory_Switch *msg)
 {
-  NM_Set_Attribute_Relevance_Advisory_Switch rep;
+	NM_Set_Attribute_Relevance_Advisory_Switch rep;
 
-  G.Out(pdGendoc,"enter RTIG::processSetAttributeRelevanceAdvisorySwitch");
-  G.Out(pdGendoc,"BEGIN ** SET ATTRIBUTE RELEVANCE ADVISORY SWITCH **");
+	G.Out(pdGendoc,"enter RTIG::processSetAttributeRelevanceAdvisorySwitch");
+	G.Out(pdGendoc,"BEGIN ** SET ATTRIBUTE RELEVANCE ADVISORY SWITCH **");
 
-  if (msg->getAttributeRelevanceAdvisorySwitch()) {
-        auditServer << "ON";
-	federations.setAttributeRelevanceAdvisorySwitch(msg->federation, msg->federate);
-        D.Out(pdTerm, "Federate %u of Federation %u sets AttributeRelevanceAdvisorySwitch.",
-              msg->federate, msg->federation);
-  }
-  else {
-        auditServer << "OFF";
-	federations.unsetAttributeRelevanceAdvisorySwitch(msg->federation, msg->federate);
-        D.Out(pdTerm, "Federate %u of Federation %u clears AttributeRelevanceAdvisorySwitch.",
-              msg->federate, msg->federation);
-  }
+	if (msg->isAttributeRelevanceAdvisorySwitchOn()) {
+		auditServer << "ON";
+		federations.setAttributeRelevanceAdvisorySwitch(msg->federation, msg->federate);
+		D.Out(pdTerm, "Federate %u of Federation %u sets AttributeRelevanceAdvisorySwitch.",
+				msg->federate, msg->federation);
+	}
+	else {
+		auditServer << "OFF";
+		federations.unsetAttributeRelevanceAdvisorySwitch(msg->federation, msg->federate);
+		D.Out(pdTerm, "Federate %u of Federation %u clears AttributeRelevanceAdvisorySwitch.",
+				msg->federate, msg->federation);
+	}
 
-  rep.send(link,NM_msgBufSend);
+	rep.send(link,NM_msgBufSend);
 
-  G.Out(pdGendoc,"END ** SET ATTRIBUTE RELEVANCE ADVISORY SWITCH **");
-  G.Out(pdGendoc,"exit RTIG::processSetAttributeRelevanceAdvisorySwitch");
+	G.Out(pdGendoc,"END ** SET ATTRIBUTE RELEVANCE ADVISORY SWITCH **");
+	G.Out(pdGendoc,"exit RTIG::processSetAttributeRelevanceAdvisorySwitch");
 }
 
 // ----------------------------------------------------------------------------
 //! Set federate's attribute scope advisroy switch
 void
 RTIG::processSetAttributeScopeAdvisorySwitch(Socket *link,
-			     NM_Set_Attribute_Scope_Advisory_Switch *msg)
+		NM_Set_Attribute_Scope_Advisory_Switch *msg)
 {
-  NM_Set_Attribute_Scope_Advisory_Switch rep;
+	NM_Set_Attribute_Scope_Advisory_Switch rep;
 
-  G.Out(pdGendoc,"enter RTIG::processSetAttributeScopeAdvisorySwitch");
-  G.Out(pdGendoc,"BEGIN ** SET ATTRIBUTE SCOPE ADVISORY SWITCH **");
+	G.Out(pdGendoc,"enter RTIG::processSetAttributeScopeAdvisorySwitch");
+	G.Out(pdGendoc,"BEGIN ** SET ATTRIBUTE SCOPE ADVISORY SWITCH **");
 
-  if (msg->getAttributeScopeAdvisorySwitch()) {
-        auditServer << "ON";
-	federations.setAttributeScopeAdvisorySwitch(msg->federation, msg->federate);
-        D.Out(pdTerm, "Federate %u of Federation %u sets AttributeScopeAdvisorySwitch.",
-              msg->federate, msg->federation);
-  }
-  else {
-        auditServer << "OFF";
-	federations.unsetAttributeScopeAdvisorySwitch(msg->federation, msg->federate);
-        D.Out(pdTerm, "Federate %u of Federation %u clears AttributeScopeAdvisorySwitch.",
-              msg->federate, msg->federation);
-  }
+	if (msg->isAttributeScopeAdvisorySwitchOn()) {
+		auditServer << "ON";
+		federations.setAttributeScopeAdvisorySwitch(msg->federation, msg->federate);
+		D.Out(pdTerm, "Federate %u of Federation %u sets AttributeScopeAdvisorySwitch.",
+				msg->federate, msg->federation);
+	}
+	else {
+		auditServer << "OFF";
+		federations.unsetAttributeScopeAdvisorySwitch(msg->federation, msg->federate);
+		D.Out(pdTerm, "Federate %u of Federation %u clears AttributeScopeAdvisorySwitch.",
+				msg->federate, msg->federation);
+	}
 
-  rep.send(link,NM_msgBufSend);
+	rep.send(link,NM_msgBufSend);
 
-  G.Out(pdGendoc,"END ** SET ATTRIBUTE SCOPE ADVISORY SWITCH **");
-  G.Out(pdGendoc,"exit RTIG::processSetAttributeScopeAdvisorySwitch");
+	G.Out(pdGendoc,"END ** SET ATTRIBUTE SCOPE ADVISORY SWITCH **");
+	G.Out(pdGendoc,"exit RTIG::processSetAttributeScopeAdvisorySwitch");
 }
 
 // ----------------------------------------------------------------------------
@@ -430,40 +430,40 @@
 void
 RTIG::processSetTimeRegulating(Socket *link, NM_Set_Time_Regulating *msg)
 {
-  G.Out(pdGendoc,"enter RTIG::processSetTimeRegulating");
-  G.Out(pdGendoc,"BEGIN ** SET TIME REGULATING **");
+	G.Out(pdGendoc,"enter RTIG::processSetTimeRegulating");
+	G.Out(pdGendoc,"BEGIN ** SET TIME REGULATING **");
 
-  if (msg->isRegulator()) {
-        auditServer << "ON at time " << msg->getDate().getTime();
+	if (msg->isRegulatorOn()) {
+		auditServer << "ON at time " << msg->getDate().getTime();
 
-        federations.createRegulator(msg->federation,
-                                     msg->federate,
-                                     msg->getDate());
-
-        // send timeRegulationEnabled() to federate.
-        NM_Time_Regulation_Enabled rep ;
-        rep.federate = msg->federate ;
-        rep.federation = msg->federation ;
-	rep.setDate(msg->getDate());
-
-        G.Out(pdGendoc,"      processSetTimeRegulating====> write TRE to RTIA");
-
-        rep.send(link,NM_msgBufSend);
-
-        D.Out(pdTerm, "Federate %u of Federation %u sets TimeRegulation ON.",
-              msg->federate, msg->federation);
-    }
-    else {
-        auditServer << "OFF" ;
-
-        federations.removeRegulator(msg->federation,
-				    msg->federate);
-        D.Out(pdTerm, "Federate %u of Federation %u sets TimeRegulation OFF.",
-              msg->federate, msg->federation);
-    }
+		federations.createRegulator(msg->federation,
+				msg->federate,
+				msg->getDate());
+
+		// send timeRegulationEnabled() to federate.
+		NM_Time_Regulation_Enabled rep ;
+		rep.federate = msg->federate ;
+		rep.federation = msg->federation ;
+		rep.setDate(msg->getDate());
+
+		G.Out(pdGendoc,"      processSetTimeRegulating====> write TRE to RTIA");
+
+		rep.send(link,NM_msgBufSend);
+
+		D.Out(pdTerm, "Federate %u of Federation %u sets TimeRegulation ON.",
+				msg->federate, msg->federation);
+	}
+	else {
+		auditServer << "OFF" ;
+
+		federations.removeRegulator(msg->federation,
+				msg->federate);
+		D.Out(pdTerm, "Federate %u of Federation %u sets TimeRegulation OFF.",
+				msg->federate, msg->federation);
+	}
 
-    G.Out(pdGendoc,"END ** SET TIME REGULATING **");
-    G.Out(pdGendoc,"exit RTIG::processSetTimeRegulating");
+	G.Out(pdGendoc,"END ** SET TIME REGULATING **");
+	G.Out(pdGendoc,"exit RTIG::processSetTimeRegulating");
 }
 
 // ----------------------------------------------------------------------------
@@ -471,39 +471,39 @@
 void
 RTIG::processSetTimeConstrained(Socket *link, NM_Set_Time_Constrained *msg)
 {
-  G.Out(pdGendoc,"enter RTIG::processSetTimeConstrained");
-  G.Out(pdGendoc,"BEGIN ** SET TIME CONSTRAINED **");
+	G.Out(pdGendoc,"enter RTIG::processSetTimeConstrained");
+	G.Out(pdGendoc,"BEGIN ** SET TIME CONSTRAINED **");
 
-  if (msg->isConstrained()) {
-        auditServer << "ON at time " << msg->getDate().getTime();
+	if (msg->isConstrainedOn()) {
+		auditServer << "ON at time " << msg->getDate().getTime();
 
-        federations.addConstrained(msg->federation,
-                                    msg->federate);
+		federations.addConstrained(msg->federation,
+				msg->federate);
 
-        // send timeConstrainedEnabled() to federate.
-        NM_Time_Constrained_Enabled rep ;
-        rep.federate = msg->federate ;
-        rep.federation = msg->federation ;
-	rep.setDate(msg->getDate());
-
-        G.Out(pdGendoc,"      processSetTimeConstrained====> write TCE to RTIA");
-
-        rep.send(link,NM_msgBufSend);
-
-        D.Out(pdTerm, "Federate %u of Federation %u is now constrained.",
-              msg->federate, msg->federation);
-    }
-    else {
-        auditServer << "OFF" ;
-
-        federations.removeConstrained(msg->federation,
-                                       msg->federate);
-        D.Out(pdTerm, "Federate %u of Federation %u is no more constrained.",
-              msg->federate, msg->federation);
-    }
+		// send timeConstrainedEnabled() to federate.
+		NM_Time_Constrained_Enabled rep ;
+		rep.federate = msg->federate ;
+		rep.federation = msg->federation ;
+		rep.setDate(msg->getDate());
+
+		G.Out(pdGendoc,"      processSetTimeConstrained====> write TCE to RTIA");
+
+		rep.send(link,NM_msgBufSend);
+
+		D.Out(pdTerm, "Federate %u of Federation %u is now constrained.",
+				msg->federate, msg->federation);
+	}
+	else {
+		auditServer << "OFF" ;
+
+		federations.removeConstrained(msg->federation,
+				msg->federate);
+		D.Out(pdTerm, "Federate %u of Federation %u is no more constrained.",
+				msg->federate, msg->federation);
+	}
 
-    G.Out(pdGendoc,"END ** SET TIME CONSTRAINED **");
-    G.Out(pdGendoc,"exit RTIG::processSetTimeConstrained");
+	G.Out(pdGendoc,"END ** SET TIME CONSTRAINED **");
+	G.Out(pdGendoc,"exit RTIG::processSetTimeConstrained");
 }
 
 // ----------------------------------------------------------------------------
@@ -511,14 +511,14 @@
 void
 RTIG::processMessageNull(NetworkMessage *msg)
 {
-    auditServer << "Date " << msg->getDate().getTime();
+	auditServer << "Date " << msg->getDate().getTime();
 
-    // Catch all exceptions because RTIA does not expect an answer anyway.
-    try {
-        federations.updateRegulator(msg->federation,
-                                     msg->federate,
-                                     msg->getDate());
-    } catch (Exception &e) {}
+	// Catch all exceptions because RTIA does not expect an answer anyway.
+	try {
+		federations.updateRegulator(msg->federation,
+				msg->federate,
+				msg->getDate());
+	} catch (Exception &e) {}
 }
 
 // ----------------------------------------------------------------------------
@@ -527,57 +527,57 @@
 RTIG::processRegisterSynchronization(Socket *link, NM_Register_Federation_Synchronization_Point *req)
 {
 
-    G.Out(pdGendoc,"BEGIN ** REGISTER FEDERATION SYNCHRONIZATION POINT Service **");
-    G.Out(pdGendoc,"enter RTIG::processRegisterSynchronization");
+	G.Out(pdGendoc,"BEGIN ** REGISTER FEDERATION SYNCHRONIZATION POINT Service **");
+	G.Out(pdGendoc,"enter RTIG::processRegisterSynchronization");
 
-    auditServer << "Label \"" << req->getLabel() << "\" registered. Tag is \""
-		<< req->getTag() << "\"" ;
+	auditServer << "Label \"" << req->getLabel() << "\" registered. Tag is \""
+			<< req->getTag() << "\"" ;
 
-    // boolean true means a federates set exists
-    if ( req->doesSetExist() ) {
-        federations.manageSynchronization(req->federation,
-                                          req->federate,
-                                          true,
-                                          req->getLabel(),
-                                          req->getTag(),
-                                          req->handleArraySize,
-                                          req->handleArray);
-    }
-    else {
-        federations.manageSynchronization(req->federation,
-                                          req->federate,
-                                          true,
-                                          req->getLabel(),
-                                          req->getTag());
-    }
-    D.Out(pdTerm, "Federation %u is now synchronizing.", req->federation);
-
-    // send synchronizationPointRegistrationSucceeded() to federate.
-    NM_Synchronization_Point_Registration_Succeeded rep ;
-    rep.federate = req->federate ;
-    rep.federation = req->federation ;
-    rep.setLabel(req->getLabel());
-
-    G.Out(pdGendoc,"      processRegisterSynchronization====> write SPRS to RTIA");
-
-    rep.send(link,NM_msgBufSend);
-
-    // boolean true means a federates set exists
-    if ( req->doesSetExist() )
-        federations.broadcastSynchronization(req->federation,
-                                          req->federate,
-                                          req->getLabel(),
-                                          req->getTag(),
-                                          req->handleArraySize,
-                                          req->handleArray);
-    else
-        federations.broadcastSynchronization(req->federation,
-                                          req->federate,
-                                          req->getLabel(),
-                                          req->getTag());
+	// boolean true means a federates set exists
+	if ( req->getExists() ) {
+		federations.manageSynchronization(req->federation,
+				req->federate,
+				true,
+				req->getLabel(),
+				req->getTag(),
+				req->getFederatesSize(),
+				req->getFederates());
+	}
+	else {
+		federations.manageSynchronization(req->federation,
+				req->federate,
+				true,
+				req->getLabel(),
+				req->getTag());
+	}
+	D.Out(pdTerm, "Federation %u is now synchronizing.", req->federation);
+
+	// send synchronizationPointRegistrationSucceeded() to federate.
+	NM_Synchronization_Point_Registration_Succeeded rep ;
+	rep.federate = req->federate ;
+	rep.federation = req->federation ;
+	rep.setLabel(req->getLabel());
+
+	G.Out(pdGendoc,"      processRegisterSynchronization====> write SPRS to RTIA");
+
+	rep.send(link,NM_msgBufSend);
+
+	// boolean true means a federates set exists
+	if ( req->getExists() )
+		federations.broadcastSynchronization(req->federation,
+				req->federate,
+				req->getLabel(),
+				req->getTag(),
+				req->getFederatesSize(),
+				req->getFederates());
+	else
+		federations.broadcastSynchronization(req->federation,
+				req->federate,
+				req->getLabel(),
+				req->getTag());
 
-    G.Out(pdGendoc,"exit  RTIG::processRegisterSynchronization");
-    G.Out(pdGendoc,"END   ** REGISTER FEDERATION SYNCHRONIZATION POINT Service **");
+	G.Out(pdGendoc,"exit  RTIG::processRegisterSynchronization");
+	G.Out(pdGendoc,"END   ** REGISTER FEDERATION SYNCHRONIZATION POINT Service **");
 
 }
 
@@ -586,875 +586,881 @@
 void
 RTIG::processSynchronizationAchieved(Socket *, NetworkMessage *req)
 {
-    auditServer << "Label \"" << req->getLabel() << "\" ended." ;
+	auditServer << "Label \"" << req->getLabel() << "\" ended." ;
 
-    federations.manageSynchronization(req->federation,
-                                       req->federate,
-                                       false,
-                                       req->getLabel(),
-                                       "");
-    D.Out(pdTerm, "Federate %u has synchronized.", req->federate);
+	federations.manageSynchronization(req->federation,
+			req->federate,
+			false,
+			req->getLabel(),
+			"");
+	D.Out(pdTerm, "Federate %u has synchronized.", req->federate);
 }
 
 // ----------------------------------------------------------------------------
 void
 RTIG::processRequestFederationSave(Socket *, NetworkMessage *req)
 {
-    G.Out(pdGendoc,"BEGIN ** REQUEST FEDERATION SAVE SERVICE **");
-    G.Out(pdGendoc,"enter RTIG::processRequestFederationSave");
+	G.Out(pdGendoc,"BEGIN ** REQUEST FEDERATION SAVE SERVICE **");
+	G.Out(pdGendoc,"enter RTIG::processRequestFederationSave");
 
-    auditServer << "Federation save request." ;
+	auditServer << "Federation save request." ;
 
-    if ( req->isDated() )
-        // With time
-        federations.requestFederationSave(req->federation, req->federate,
-                                          req->getLabel(), req->getDate());
-    else
-        // Without time
-        federations.requestFederationSave(req->federation, req->federate,
-                                          req->getLabel());
+	if ( req->isDated() )
+		// With time
+		federations.requestFederationSave(req->federation, req->federate,
+				req->getLabel(), req->getDate());
+	else
+		// Without time
+		federations.requestFederationSave(req->federation, req->federate,
+				req->getLabel());
 
-    G.Out(pdGendoc,"exit  RTIG::processRequestFederationSave");
-    G.Out(pdGendoc,"END   ** REQUEST FEDERATION SAVE SERVICE **");
+	G.Out(pdGendoc,"exit  RTIG::processRequestFederationSave");
+	G.Out(pdGendoc,"END   ** REQUEST FEDERATION SAVE SERVICE **");
 }
 // ----------------------------------------------------------------------------
 void
 RTIG::processFederateSaveBegun(Socket *, NetworkMessage *req)
 {
-    G.Out(pdGendoc,"enter RTIG::processFederateSaveBegun");
-    G.Out(pdGendoc,"BEGIN ** FEDERATE SAVE BEGUN SERVICE **");
-    G.Out(pdGendoc,"processFederateSaveBegun federation = %d",req->federation);
+	G.Out(pdGendoc,"enter RTIG::processFederateSaveBegun");
+	G.Out(pdGendoc,"BEGIN ** FEDERATE SAVE BEGUN SERVICE **");
+	G.Out(pdGendoc,"processFederateSaveBegun federation = %d",req->federation);
 
-    auditServer << "Federate " << req->federate << " save begun." ;
+	auditServer << "Federate " << req->federate << " save begun." ;
 
-    federations.federateSaveBegun(req->federation, req->federate);
+	federations.federateSaveBegun(req->federation, req->federate);
 
-    G.Out(pdGendoc,"END   ** FEDERATE SAVE BEGUN SERVICE **");
-    G.Out(pdGendoc,"exit  RTIG::processFederateSaveBegun");
+	G.Out(pdGendoc,"END   ** FEDERATE SAVE BEGUN SERVICE **");
+	G.Out(pdGendoc,"exit  RTIG::processFederateSaveBegun");
 }
 
 // ----------------------------------------------------------------------------
 void
 RTIG::processFederateSaveStatus(Socket *, NetworkMessage *req)
 {
-    G.Out(pdGendoc,"enter RTIG::processFederateSaveStatus");
-    if (req->getType() == NetworkMessage::FEDERATE_SAVE_COMPLETE)
-        G.Out(pdGendoc,"BEGIN ** FEDERATE SAVE COMPLETE SERVICE **");
-    else
-        G.Out(pdGendoc,"BEGIN ** FEDERATE SAVE NOT COMPLETE SERVICE **");
+	G.Out(pdGendoc,"enter RTIG::processFederateSaveStatus");
+	if (req->getType() == NetworkMessage::FEDERATE_SAVE_COMPLETE)
+		G.Out(pdGendoc,"BEGIN ** FEDERATE SAVE COMPLETE SERVICE **");
+	else
+		G.Out(pdGendoc,"BEGIN ** FEDERATE SAVE NOT COMPLETE SERVICE **");
 
-    auditServer << "Federate " << req->federate << " save ended." ;
+	auditServer << "Federate " << req->federate << " save ended." ;
 
-    bool status = req->getType() == NetworkMessage::FEDERATE_SAVE_COMPLETE ;
-    federations.federateSaveStatus(req->federation, req->federate, status);
+	bool status = req->getType() == NetworkMessage::FEDERATE_SAVE_COMPLETE ;
+	federations.federateSaveStatus(req->federation, req->federate, status);
 
-    G.Out(pdGendoc,"exit  END   ** FEDERATE SAVE (NOT) COMPLETE SERVICE **");
-    G.Out(pdGendoc,"exit  RTIG::processFederateSaveStatus");
+	G.Out(pdGendoc,"exit  END   ** FEDERATE SAVE (NOT) COMPLETE SERVICE **");
+	G.Out(pdGendoc,"exit  RTIG::processFederateSaveStatus");
 }
 
 // ----------------------------------------------------------------------------
 void
 RTIG::processRequestFederationRestore(Socket *, NetworkMessage *req)
 {
-    G.Out(pdGendoc,"BEGIN ** REQUEST FEDERATION RESTORE SERVICE **");
-    G.Out(pdGendoc,"enter RTIG::processRequestFederationRestore");
-    auditServer << "Federate " << req->federate << " request restore." ;
-
-    federations.requestFederationRestore(req->federation, req->federate,
-                                          req->getLabel());
-    G.Out(pdGendoc,"exit  RTIG::processRequestFederationRestore");
-    G.Out(pdGendoc,"END   ** REQUEST FEDERATION RESTORE SERVICE **");
+	G.Out(pdGendoc,"BEGIN ** REQUEST FEDERATION RESTORE SERVICE **");
+	G.Out(pdGendoc,"enter RTIG::processRequestFederationRestore");
+	auditServer << "Federate " << req->federate << " request restore." ;
+
+	federations.requestFederationRestore(req->federation, req->federate,
+			req->getLabel());
+	G.Out(pdGendoc,"exit  RTIG::processRequestFederationRestore");
+	G.Out(pdGendoc,"END   ** REQUEST FEDERATION RESTORE SERVICE **");
 }
 
 // ----------------------------------------------------------------------------
 void
 RTIG::processFederateRestoreStatus(Socket *, NetworkMessage *req)
 {
-    G.Out(pdGendoc,"BEGIN ** FEDERATE RESTORE (NOT)COMPLETE **");
-    G.Out(pdGendoc,"enter RTIG::processRequestFederateRestoreStatus");
-    auditServer << "Federate " << req->federate << " restore ended." ;
+	G.Out(pdGendoc,"BEGIN ** FEDERATE RESTORE (NOT)COMPLETE **");
+	G.Out(pdGendoc,"enter RTIG::processRequestFederateRestoreStatus");
+	auditServer << "Federate " << req->federate << " restore ended." ;
 
-    bool status = req->getType() == NetworkMessage::FEDERATE_RESTORE_COMPLETE ;
+	bool status = req->getType() == NetworkMessage::FEDERATE_RESTORE_COMPLETE ;
 
-    federations.federateRestoreStatus(req->federation, req->federate, status);
+	federations.federateRestoreStatus(req->federation, req->federate, status);
 
-    G.Out(pdGendoc,"exit  RTIG::processRequestFederateRestoreStatus");
-    G.Out(pdGendoc,"END   ** FEDERATE RESTORE (NOT)COMPLETE **");
+	G.Out(pdGendoc,"exit  RTIG::processRequestFederateRestoreStatus");
+	G.Out(pdGendoc,"END   ** FEDERATE RESTORE (NOT)COMPLETE **");
 }
 
 // ----------------------------------------------------------------------------
 // processPublishObjectClass
 void
-RTIG::processPublishObjectClass(Socket *link, NetworkMessage *req)
+RTIG::processPublishObjectClass(Socket *link, NM_Publish_Object_Class *req)
 {
-    bool pub = (req->getType() == NetworkMessage::PUBLISH_OBJECT_CLASS);
-
-    auditServer << "Publish Object Class = " << req->objectClass << ", # of att. = "
-		<< req->handleArraySize ;
+	bool pub = (req->getType() == NetworkMessage::PUBLISH_OBJECT_CLASS);
 
-    federations.publishObject(req->federation,
-                              req->federate,
-                              req->objectClass,
-                              req->handleArray,
-                              req->handleArraySize,
-                              pub);
+	auditServer << "Publish Object Class = " << req->getObjectClass() << ", # of att. = "
+			<< req->getAttributesSize() ;
 
-    D.Out(pdRegister, "Federate %u of Federation %u published object class %d.",
-          req->federate, req->federation, req->objectClass);
+	federations.publishObject(req->federation,
+			req->federate,
+			req->getObjectClass(),
+			req->getAttributes(),
+			req->getAttributesSize(),
+			pub);
+
+	D.Out(pdRegister, "Federate %u of Federation %u published object class %d.",
+			req->federate, req->federation, req->getObjectClass());
+
+
+	if (pub) {
+		NM_Publish_Object_Class POC;
+		POC.federate = req->federate;
+		POC.setObjectClass(req->getObjectClass());
+		POC.send(link,NM_msgBufSend); // send answer to RTIA
+	} else {
+		NM_Unpublish_Object_Class UOC;
+		UOC.federate = req->federate;
+		UOC.setObjectClass(req->getObjectClass());
+		UOC.send(link,NM_msgBufSend); // send answer to RTIA
 
-    std::auto_ptr<NetworkMessage> rep(NM_Factory::create(req->getType()));
-    rep->federate    = req->federate ;
-    rep->objectClass = req->objectClass ;
-
-    rep->send(link,NM_msgBufSend); // send answer to RTIA
+	}
 }
 
 // ----------------------------------------------------------------------------
 // processSubscribeObjectClass
 void
-RTIG::processSubscribeObjectClass(Socket *link, NetworkMessage *req)
+RTIG::processSubscribeObjectClass(Socket *link, NM_Subscribe_Object_Class *req)
 {
-    G.Out(pdGendoc,"enter RTIG::processSubscribeObjectClass");
-    G.Out(pdGendoc,"BEGIN **  SUBSCRIBE OBJECT CLASS SERVICE **");
+	G.Out(pdGendoc,"enter RTIG::processSubscribeObjectClass");
+	G.Out(pdGendoc,"BEGIN **  SUBSCRIBE OBJECT CLASS SERVICE **");
 
-    std::vector <AttributeHandle> arrayVide ;
-    bool sub = (req->getType() == NetworkMessage::SUBSCRIBE_OBJECT_CLASS);
+	std::vector <AttributeHandle> arrayVide ;
+	bool sub = (req->getType() == NetworkMessage::SUBSCRIBE_OBJECT_CLASS);
 
-    auditServer << "Subscribe Object Class = " << req->objectClass
-		<< ", # of att. = " << req->handleArraySize ;
+	auditServer << "Subscribe Object Class = " << req->getObjectClass()
+						<< ", # of att. = " << req->getAttributesSize() ;
+
+	federations.subscribeObject(req->federation,
+			req->federate,
+			req->getObjectClass(),
+			sub ? req->getAttributes() : arrayVide,
+					sub ? req->getAttributesSize() : 0);
+
+	D.Out(pdRegister,
+			"Federate %u of Federation %u subscribed to object class %d.",
+			req->federate, req->federation, req->getObjectClass());
+
+	if (sub) {
+		NM_Subscribe_Object_Class rep;
+		rep.federate = req->federate ;
+		rep.setObjectClass(req->getObjectClass());
+
+		rep.send(link,NM_msgBufSend); // send answer to RTIA
+	} else {
+		NM_Unsubscribe_Object_Class rep;
+		rep.federate = req->federate ;
+		rep.setObjectClass(req->getObjectClass());
 
-    federations.subscribeObject(req->federation,
-				req->federate,
-				req->objectClass,
-				sub ? req->handleArray : arrayVide,
-				sub ? req->handleArraySize : 0);
-
-    D.Out(pdRegister,
-          "Federate %u of Federation %u subscribed to object class %d.",
-          req->federate, req->federation, req->objectClass);
-
-    std::auto_ptr<NetworkMessage> rep(NM_Factory::create(req->getType()));
-    rep->federate = req->federate ;
-    rep->objectClass = req->objectClass ;
-    rep->handleArraySize = 0 ;
+		rep.send(link,NM_msgBufSend); // send answer to RTIA
+	}
 
-    rep->send(link,NM_msgBufSend); // send answer to RTIA
-
-    G.Out(pdGendoc,"END   **  SUBSCRIBE OBJECT CLASS SERVICE **");
-    G.Out(pdGendoc,"exit  RTIG::processSubscribeObjectClass");
+	G.Out(pdGendoc,"END   **  SUBSCRIBE OBJECT CLASS SERVICE **");
+	G.Out(pdGendoc,"exit  RTIG::processSubscribeObjectClass");
 }
 
 // ----------------------------------------------------------------------------
 // processPublishInteractionClass
 void
-RTIG::processPublishInteractionClass(Socket *link, NetworkMessage *req)
+RTIG::processPublishInteractionClass(Socket *link, NM_Publish_Interaction_Class *req)
 {
-    assert(link != NULL && req != NULL);
+	assert(link != NULL && req != NULL);
+
+	bool pub = (req->getType() == NetworkMessage::PUBLISH_INTERACTION_CLASS);
 
-    bool pub = (req->getType() == NetworkMessage::PUBLISH_INTERACTION_CLASS);
+	auditServer << "Publish Interaction Class = " << req->getInteractionClass() ;
+	federations.publishInteraction(req->federation,
+			req->federate,
+			req->getInteractionClass(),
+			pub);
+	D.Out(pdRequest, "Federate %u of Federation %u publishes Interaction %d.",
+			req->federate,
+			req->federation,
+			req->getInteractionClass());
 
-    auditServer << "Publish Interaction Class = " << req->interactionClass ;
-    federations.publishInteraction(req->federation,
-                                    req->federate,
-                                    req->interactionClass,
-                                    pub);
-    D.Out(pdRequest, "Federate %u of Federation %u publishes Interaction %d.",
-          req->federate,
-          req->federation,
-          req->interactionClass);
-
-    std::auto_ptr<NetworkMessage> rep(NM_Factory::create(req->getType())); ;
-    rep->federate = req->federate ;
-    rep->interactionClass = req->interactionClass ;
+	NM_Publish_Interaction_Class rep;
 
-    rep->send(link,NM_msgBufSend); // send answer to RTIA
+	rep.federate = req->federate ;
+	rep.setInteractionClass(req->getInteractionClass());
+
+	rep.send(link,NM_msgBufSend); // send answer to RTIA
 }
 
 // ----------------------------------------------------------------------------
 // processSubscribeInteractionClass
 void
-RTIG::processSubscribeInteractionClass(Socket *link, NetworkMessage *req)
+RTIG::processSubscribeInteractionClass(Socket *link, NM_Subscribe_Interaction_Class *req)
 {
-    bool sub = (req->getType() == NetworkMessage::SUBSCRIBE_INTERACTION_CLASS);
+	bool sub = (req->getType() == NetworkMessage::SUBSCRIBE_INTERACTION_CLASS);
 
-    auditServer << "Subscribe Interaction Class = " << req->interactionClass ;
-    federations.subscribeInteraction(req->federation,
-                                      req->federate,
-                                      req->interactionClass,
-                                      sub);
-    D.Out(pdRequest,
-          "Federate %u of Federation %u subscribed to Interaction %d.",
-          req->federate,
-          req->federation,
-          req->interactionClass);
-
-    std::auto_ptr<NetworkMessage> rep(NM_Factory::create(req->getType()));;
-    rep->federate = req->federate ;
-    rep->interactionClass = req->interactionClass ;
+	auditServer << "Subscribe Interaction Class = " << req->getInteractionClass() ;
+	federations.subscribeInteraction(req->federation,
+			req->federate,
+			req->getInteractionClass(),
+			sub);
+	D.Out(pdRequest,
+			"Federate %u of Federation %u subscribed to Interaction %d.",
+			req->federate,
+			req->federation,
+			req->getInteractionClass());
+
+	NM_Subscribe_Interaction_Class rep;
+	rep.federate = req->federate ;
+	rep.setInteractionClass(req->getInteractionClass());
 
-    rep->send(link,NM_msgBufSend); // send answer to RTIA
+	rep.send(link,NM_msgBufSend); // send answer to RTIA
 }
 
 // ----------------------------------------------------------------------------
 // processRegisterObject
 void
-RTIG::processRegisterObject(Socket *link, NetworkMessage *req)
+RTIG::processRegisterObject(Socket *link, NM_Register_Object *req)
 {
-  std::auto_ptr<NetworkMessage> rep(NM_Factory::create(req->getType()));;
+	NM_Register_Object rep;
 
-    auditServer << "Register Object Class = " << req->objectClass ;
-    rep->object = federations.registerObject(req->federation,
-                                             req->federate,
-                                             req->objectClass,
-                                             req->getLabel());
-    auditServer << ", Handle = " << rep->object ;
-
-    D.Out(pdRegister,
-          "Object \"%s\" of Federate %u has been registered under ID %u.",
-          req->getLabel().c_str(), req->federate, rep->object);
-
-    rep->federate    = req->federate ;
-    rep->federation  = req->federation;
-    rep->objectClass = req->objectClass;
-    // rep.object is set by the call of registerObject
-    rep->setLabel(req->getLabel());
+	auditServer << "Register Object Class = " << req->getObjectClass() ;
+	rep.setObject(federations.registerObject(req->federation,
+			req->federate,
+			req->getObjectClass(),
+			req->getLabel()));
+
+	D.Out(pdRegister,
+			"Object \"%s\" of Federate %u has been registered under ID %u.",
+			req->getLabel().c_str(), req->federate, rep.getObject());
+
+	rep.federate    = req->federate ;
+	rep.federation  = req->federation;
+	rep.setObjectClass(req->getObjectClass());
+	// rep.object is set by the call of registerObject
+	rep.setLabel(req->getLabel());
 
-    rep->send(link,NM_msgBufSend); // Send answer to RTIA
+	rep.send(link,NM_msgBufSend); // Send answer to RTIA
 }
 
 // ----------------------------------------------------------------------------
 // processUpdateAttributeValues
 void
-RTIG::processUpdateAttributeValues(Socket *link, NetworkMessage *req)
+RTIG::processUpdateAttributeValues(Socket *link, NM_Update_Attribute_Values *req)
 {
-    G.Out(pdGendoc,"enter RTIG::processUpdateAttributeValues");
+	G.Out(pdGendoc,"enter RTIG::processUpdateAttributeValues");
 
-    auditServer << "ObjID = " << req->object
-		<< ", Date = " << req->getDate().getTime();
+	auditServer << "ObjID = " << req->getObject()
+					<< ", Date = " << req->getDate().getTime();
 
-    // Forward the call
-    if ( req->isDated() )
-        {
-        // UAV with time
-        federations.updateAttribute(req->federation,
-                                 req->federate,
-                                 req->object,
-                                 req->handleArray,
-                                 req->valueArray,
-                                 req->handleArraySize,
-                                 req->getDate(),
-                                 req->getLabel());
-        }
-    else
-        {
-        // UAV without time
-        federations.updateAttribute(req->federation,
-                                 req->federate,
-                                 req->object,
-                                 req->handleArray,
-                                 req->valueArray,
-                                 req->handleArraySize,
-                                 req->getLabel());
-        }
-
-    // Building answer (Network Message re)
-    NM_Update_Attribute_Values rep ;
-    rep.federate = req->federate ;
-    rep.object   = req->object ;
-    rep.setDate(req->getDate());
-    rep.handleArraySize = 0 ;
-    // Don't forget label and tag
-    rep.setLabel(req->getLabel());
-    rep.setTag(req->getTag());
+	// Forward the call
+	if ( req->isDated() )
+	{
+		// UAV with time
+		federations.updateAttribute(req->federation,
+				req->federate,
+				req->getObject(),
+				req->getAttributes(),
+				req->getValues(),
+				req->getAttributesSize(),
+				req->getDate(),
+				req->getLabel());
+	}
+	else
+	{
+		// UAV without time
+		federations.updateAttribute(req->federation,
+				req->federate,
+				req->getObject(),
+				req->getAttributes(),
+				req->getValues(),
+				req->getAttributesSize(),
+				req->getLabel());
+	}
+
+	// Building answer (Network Message)
+	NM_Update_Attribute_Values rep ;
+	rep.federate = req->federate ;
+	rep.setObject(req->getObject());
+	rep.setDate(req->getDate());
+	// Don't forget label and tag
+	rep.setLabel(req->getLabel());
+	rep.setTag(req->getTag());
 
-    rep.send(link,NM_msgBufSend); // send answer to RTIA
-    G.Out(pdGendoc,"exit  RTIG::processUpdateAttributeValues");
+	rep.send(link,NM_msgBufSend); // send answer to RTIA
+	G.Out(pdGendoc,"exit  RTIG::processUpdateAttributeValues");
 }
 
 // ----------------------------------------------------------------------------
 // processSendInteraction
 void
-RTIG::processSendInteraction(Socket *link, NetworkMessage *req)
+RTIG::processSendInteraction(Socket *link, NM_Send_Interaction *req)
 {
-    G.Out(pdGendoc,"BEGIN ** SEND INTERACTION SERVICE **");
-    G.Out(pdGendoc,"enter RTIG::processSendInteraction");
+	G.Out(pdGendoc,"BEGIN ** SEND INTERACTION SERVICE **");
+	G.Out(pdGendoc,"enter RTIG::processSendInteraction");
 
-    // Building Value Array
-    auditServer << "IntID = " << req->interactionClass
-		<< ", date = " << req->getDate().getTime();
-    if ( req->isDated() )
-        {
-        federations.updateParameter(req->federation,
+	// Building Value Array
+	auditServer << "IntID = " << req->getInteractionClass()
+					<< ", date = " << req->getDate().getTime();
+	if ( req->isDated() )
+	{
+		federations.updateParameter(req->federation,
 				req->federate,
-				req->interactionClass,
-				req->handleArray,
-				req->valueArray,
-                                req->handleArraySize,
+				req->getInteractionClass(),
+				req->getParameters(),
+				req->getValues(),
+				req->getParametersSize(),
 				req->getDate(),
-				req->region,
+				req->getRegion(),
 				req->getLabel());
-        }
-    else
-        {
-        federations.updateParameter(req->federation,
+	}
+	else
+	{
+		federations.updateParameter(req->federation,
 				req->federate,
-				req->interactionClass,
-				req->handleArray,
-				req->valueArray,
-                                req->handleArraySize,
-				req->region,
+				req->getInteractionClass(),
+				req->getParameters(),
+				req->getValues(),
+				req->getParametersSize(),
+				req->getRegion(),
 				req->getLabel());
-        }
+	}
 
-    D.Out(pdDebug, "Interaction %d parameters update completed",
-          req->interactionClass);
+	D.Out(pdDebug, "Interaction %d parameters update completed",
+			req->getInteractionClass());
 
-    NM_Send_Interaction rep ;
-    rep.federate = req->federate ;
-    rep.interactionClass = req->interactionClass ;
-    rep.handleArraySize = 0 ;
-    // Don't forget label and tag
-    rep.setLabel(req->getLabel());
-    rep.setTag(req->getTag());
-    G.Out(pdGendoc,"processSendInteraction===>write");
-    rep.send(link,NM_msgBufSend); // send answer to RTIA
+	NM_Send_Interaction rep ;
+	rep.federate = req->federate ;
+	rep.setInteractionClass(req->getInteractionClass());
+	// Don't forget label and tag
+	rep.setLabel(req->getLabel());
+	rep.setTag(req->getTag());
+	G.Out(pdGendoc,"processSendInteraction===>write");
+	rep.send(link,NM_msgBufSend); // send answer to RTIA
 
-    G.Out(pdGendoc,"exit RTIG::processSendInteraction");
-    G.Out(pdGendoc,"END ** SEND INTERACTION SERVICE **");
+	G.Out(pdGendoc,"exit RTIG::processSendInteraction");
+	G.Out(pdGendoc,"END ** SEND INTERACTION SERVICE **");
 
 }
 
 // ----------------------------------------------------------------------------
 // processDeleteObject
 void
-RTIG::processDeleteObject(Socket *link, NetworkMessage *req)
+RTIG::processDeleteObject(Socket *link, NM_Delete_Object *req)
 {
-    G.Out(pdGendoc,"BEGIN ** DELETE OBJECT INSTANCE service **");
-    G.Out(pdGendoc,"enter RTIG::processDeleteObject");
-    auditServer << "Delete ObjID = " << req->object ;
-
-    if ( req->isDated() ) {
-    	federations.destroyObject(req->federation,
-        	                  req->federate,
-                                  req->object,
-				  req->getDate(),
-                                  req->getLabel());
-    }
-    else {
-    	federations.destroyObject(req->federation,
-        	                  req->federate,
-                                  req->object,
-                                  req->getLabel());
-    }
-
-    D.Out(pdRegister, "Object # %u of Federation %u has been deleted.",
-          req->object, req->federation);
-
-    NM_Delete_Object rep ;
-    rep.federate = req->federate ;
-    rep.object   = req->object ;
+	G.Out(pdGendoc,"BEGIN ** DELETE OBJECT INSTANCE service **");
+	G.Out(pdGendoc,"enter RTIG::processDeleteObject");
+	auditServer << "Delete ObjID = " << req->getObject() ;
+
+	if ( req->isDated() ) {
+		federations.destroyObject(req->federation,
+				req->federate,
+				req->getObject(),
+				req->getDate(),
+				req->getLabel());
+	}
+	else {
+		federations.destroyObject(req->federation,
+				req->federate,
+				req->getObject(),
+				req->getLabel());
+	}
+
+	D.Out(pdRegister, "Object # %u of Federation %u has been deleted.",
+			req->getObject(), req->federation);
 
-    rep.send(link,NM_msgBufSend); // send answer to RTIA
+	NM_Delete_Object rep ;
+	rep.federate = req->federate ;
+	rep.setObject(req->getObject());
 
-    G.Out(pdGendoc,"exit RTIG::processDeleteObject");
-    G.Out(pdGendoc,"END ** DELETE OBJECT INSTANCE **");
+	rep.send(link,NM_msgBufSend); // send answer to RTIA
+
+	G.Out(pdGendoc,"exit RTIG::processDeleteObject");
+	G.Out(pdGendoc,"END ** DELETE OBJECT INSTANCE **");
 }
 
 // ----------------------------------------------------------------------------
 // processqueryAttributeOwnership
 void
-RTIG::processQueryAttributeOwnership(Socket *link, NetworkMessage *req)
+RTIG::processQueryAttributeOwnership(Socket *link, NM_Query_Attribute_Ownership *req)
 {
-    D.Out(pdDebug, "Owner of Attribute %u of Object %u .",
-          req->handleArray[0], req->object);
+	D.Out(pdDebug, "Owner of Attribute %u of Object %u .",
+			req->getAttribute(), req->getObject());
 
-    auditServer << "AttributeHandle = " << req->handleArray[0] ;
+	auditServer << "AttributeHandle = " << req->getAttribute() ;
 
-    federations.searchOwner(req->federation,
-                             req->federate,
-                             req->object,
-                             req->handleArray[0]);
+	federations.searchOwner(req->federation,
+			req->federate,
+			req->getObject(),
+			req->getAttribute());
 
-    D.Out(pdDebug, "Owner of Attribute %u of Object %u .",
-          req->handleArray[0], req->object);
+	D.Out(pdDebug, "Owner of Attribute %u of Object %u .",
+			req->getAttribute(), req->getObject());
 
-    NM_Query_Attribute_Ownership rep ;
-    rep.federate = req->federate ;
-    rep.object = req->object ;
+	NM_Query_Attribute_Ownership rep ;
+	rep.federate = req->federate ;
+	rep.setObject(req->getObject());
 
-    rep.send(link,NM_msgBufSend); // send answer to RTIA
+	rep.send(link,NM_msgBufSend); // send answer to RTIA
 }
 
 // ----------------------------------------------------------------------------
 // processAttributeOwnedByFederate
 void
-RTIG::processAttributeOwnedByFederate(Socket *link, NetworkMessage *req)
+RTIG::processAttributeOwnedByFederate(Socket *link, NM_Is_Attribute_Owned_By_Federate *req)
 {
-    NM_Is_Attribute_Owned_By_Federate* ownedReq = static_cast<NM_Is_Attribute_Owned_By_Federate*>(req);
-    NM_Is_Attribute_Owned_By_Federate rep ;
+	NM_Is_Attribute_Owned_By_Federate rep ;
 
-    D.Out(pdDebug, "Owner of Attribute %u of Object %u .",
-          ownedReq->getAttribute(), ownedReq->object);
+	D.Out(pdDebug, "Owner of Attribute %u of Object %u .",
+			req->getAttribute(), req->getObject());
 
-    auditServer << "AttributeHandle = " << ownedReq->getAttribute() ;
+	auditServer << "AttributeHandle = " << req->getAttribute() ;
 
-    if (federations.isOwner(ownedReq->federation,
-                             ownedReq->federate,
-                             ownedReq->object,
-                             ownedReq->getAttribute()))
-        rep.setLabel("RTI_TRUE");
-    else
-        rep.setLabel("RTI_FALSE");
+	if (federations.isOwner(req->federation,
+			req->federate,
+			req->getObject(),
+			req->getAttribute()))
+		rep.setLabel("RTI_TRUE");
+	else
+		rep.setLabel("RTI_FALSE");
 
-    D.Out(pdDebug, "Owner of Attribute %u of Object %u .",
-          ownedReq->getAttribute(), ownedReq->object);
+	D.Out(pdDebug, "Owner of Attribute %u of Object %u .",
+			req->getAttribute(), req->getObject());
 
-    rep.federate = ownedReq->federate ;
-    rep.object = ownedReq->object ;
-    rep.setAttribute(ownedReq->getAttribute()) ;
+	rep.federate = req->federate ;
+	rep.setObject(req->getObject());
+	rep.setAttribute(req->getAttribute()) ;
 
-    rep.send(link,NM_msgBufSend); // send answer to RTIA
+	rep.send(link,NM_msgBufSend); // send answer to RTIA
 }
 
 // ----------------------------------------------------------------------------
 // processNegotiatedOwnershipDivestiture
 void
-RTIG::processNegotiatedOwnershipDivestiture(Socket *link, NetworkMessage *req)
+RTIG::processNegotiatedOwnershipDivestiture(Socket *link, NM_Negotiated_Attribute_Ownership_Divestiture *req)
 {
-    auditServer << "Object = " <<  req->object
-		<< ", # of att. = " << req->handleArraySize ;
-    federations.negotiateDivestiture(req->federation,
-                                      req->federate,
-                                      req->object,
-                                      req->handleArray,
-                                      req->handleArraySize,
-                                      req->getLabel());
-
-    D.Out(pdDebug, "Federate %u of Federation %u negotiate "
-          "divestiture of object %u.",
-          req->federate, req->federation, req->object);
-
-    NM_Negotiated_Attribute_Ownership_Divestiture rep ;
-    rep.federate = req->federate ;
-    rep.object = req->object ;
-    rep.handleArraySize = 0 ;
+	auditServer << "Object = " <<  req->getObject()
+						<< ", # of att. = " << req->getAttributesSize() ;
+	federations.negotiateDivestiture(req->federation,
+			req->federate,
+			req->getObject(),
+			req->getAttributes(),
+			req->getAttributesSize(),
+			req->getLabel());
+
+	D.Out(pdDebug, "Federate %u of Federation %u negotiate "
+			"divestiture of object %u.",
+			req->federate, req->federation, req->getObject());
+
+	NM_Negotiated_Attribute_Ownership_Divestiture rep ;
+	rep.federate = req->federate ;
+	rep.setObject(req->getObject());
 
-    rep.send(link,NM_msgBufSend); // send answer to RTIA
+	rep.send(link,NM_msgBufSend); // send answer to RTIA
 }
 
 // ----------------------------------------------------------------------------
 // processAcquisitionIfAvailable
 void
-RTIG::processAcquisitionIfAvailable(Socket *link, NetworkMessage *req)
+RTIG::processAcquisitionIfAvailable(Socket *link, NM_Attribute_Ownership_Acquisition_If_Available *req)
 {
-    auditServer << "Object = " << req->object
-		<< ", # of att. = " << req->handleArraySize ;
+	auditServer << "Object = " << req->getObject()
+						<< ", # of att. = " << req->getAttributesSize() ;
 
-    federations.acquireIfAvailable(req->federation,
-                                    req->federate,
-                                    req->object,
-                                    req->handleArray,
-                                    req->handleArraySize);
-
-    D.Out(pdDebug,
-          "Federate %u of Federation %u acquisitionIfAvailable "
-          "of object %u.",
-          req->federate, req->federation, req->object);
-
-    NM_Attribute_Ownership_Acquisition_If_Available rep ;
-    rep.federate = req->federate ;
-    rep.object = req->object ;
-    rep.handleArraySize = 0 ;
+	federations.acquireIfAvailable(req->federation,
+			req->federate,
+			req->getObject(),
+			req->getAttributes(),
+			req->getAttributesSize());
+
+	D.Out(pdDebug,
+			"Federate %u of Federation %u acquisitionIfAvailable "
+			"of object %u.",
+			req->federate, req->federation, req->getObject());
+
+	NM_Attribute_Ownership_Acquisition_If_Available rep ;
+	rep.federate = req->federate ;
+	rep.setObject(req->getObject());
 
-    rep.send(link,NM_msgBufSend); // send answer to RTIA
+	rep.send(link,NM_msgBufSend); // send answer to RTIA
 }
 
 // ----------------------------------------------------------------------------
 // processUnconditionalDivestiture
 void
-RTIG::processUnconditionalDivestiture(Socket *link, NetworkMessage *req)
+RTIG::processUnconditionalDivestiture(Socket *link, NM_Unconditional_Attribute_Ownership_Divestiture *req)
 {
-    auditServer << "Object = " << req->object
-		<< ", # of att. = " << req->handleArraySize ;
+	auditServer << "Object = " << req->getObject()
+						<< ", # of att. = " << req->getAttributesSize() ;
 
-    federations.divest(req->federation,
-                        req->federate,
-                        req->object,
-                        req->handleArray,
-                        req->handleArraySize);
-
-    D.Out(pdDebug,
-          "Federate %u of Federation %u UnconditionalDivestiture "
-          "of object %u.",
-          req->federate, req->federation, req->object);
-
-    NM_Unconditional_Attribute_Ownership_Divestiture rep ;
-    rep.federate = req->federate ;
-    rep.object = req->object ;
-    rep.handleArraySize = 0 ;
+	federations.divest(req->federation,
+			req->federate,
+			req->getObject(),
+			req->getAttributes(),
+			req->getAttributesSize());
+
+	D.Out(pdDebug,
+			"Federate %u of Federation %u UnconditionalDivestiture "
+			"of object %u.",
+			req->federate, req->federation, req->getObject());
+
+	NM_Unconditional_Attribute_Ownership_Divestiture rep ;
+	rep.federate = req->federate ;
+	rep.setObject(req->getObject());
 
-    rep.send(link,NM_msgBufSend); // send answer to RTIA
+	rep.send(link,NM_msgBufSend); // send answer to RTIA
 }
 
 // ----------------------------------------------------------------------------
 // processOwnershipAcquisition
 void
-RTIG::processOwnershipAcquisition(Socket *link, NetworkMessage *req)
+RTIG::processOwnershipAcquisition(Socket *link, NM_Attribute_Ownership_Acquisition *req)
 {
-    auditServer << "Object = " << req->object
-		<< ", # of att. = " << req->handleArraySize ;
+	auditServer << "Object = " << req->getObject()
+						<< ", # of att. = " << req->getAttributesSize() ;
 
-    federations.acquire(req->federation,
-                         req->federate,
-                         req->object,
-                         req->handleArray,
-                         req->handleArraySize,
-                         req->getLabel());
-
-    D.Out(pdDebug,
-          "Federate %u of Federation %u ownership acquisition of object %u.",
-          req->federate, req->federation, req->object);
-
-    NM_Attribute_Ownership_Acquisition rep ;
-    rep.federate = req->federate ;
-    rep.object = req->object ;
-    rep.handleArraySize = 0 ;
+	federations.acquire(req->federation,
+			req->federate,
+			req->getObject(),
+			req->getAttributes(),
+			req->getAttributesSize(),
+			req->getLabel());
+
+	D.Out(pdDebug,
+			"Federate %u of Federation %u ownership acquisition of object %u.",
+			req->federate, req->federation, req->getObject());
+
+	NM_Attribute_Ownership_Acquisition rep ;
+	rep.federate = req->federate ;
+	rep.setObject(req->getObject());
+	rep.setAttributesSize(0);
 
-    rep.send(link,NM_msgBufSend); // send answer to RTIA
+	rep.send(link,NM_msgBufSend); // send answer to RTIA
 }
 
 // ----------------------------------------------------------------------------
 // processCancelNegotiatedDivestiture
 void
-RTIG::processCancelNegotiatedDivestiture(Socket *link, NetworkMessage *req)
+RTIG::processCancelNegotiatedDivestiture(Socket *link, NM_Cancel_Negotiated_Attribute_Ownership_Divestiture *req)
 {
-    auditServer << "Object = " << req->object
-		<< ", # of att. = " << req->handleArraySize ;
+	auditServer << "Object = " << req->getObject()
+						<< ", # of att. = " << req->getAttributesSize() ;
 
-    federations.cancelDivestiture(req->federation,
-                                   req->federate,
-                                   req->object,
-                                   req->handleArray,
-                                   req->handleArraySize);
-
-    D.Out(pdDebug, "Federate %u of Federation %u cancel negotiate "
-          "divestiture of object %u.",
-          req->federate, req->federation, req->object);
-
-    NM_Cancel_Negotiated_Attribute_Ownership_Divestiture rep ;
-    rep.federate = req->federate ;
-    rep.object = req->object ;
-    rep.handleArraySize = 0 ;
+	federations.cancelDivestiture(req->federation,
+			req->federate,
+			req->getObject(),
+			req->getAttributes(),
+			req->getAttributesSize());
+
+	D.Out(pdDebug, "Federate %u of Federation %u cancel negotiate "
+			"divestiture of object %u.",
+			req->federate, req->federation, req->getObject());
+
+	NM_Cancel_Negotiated_Attribute_Ownership_Divestiture rep ;
+	rep.federate = req->federate ;
+	rep.setObject(req->getObject());
 
-    rep.send(link,NM_msgBufSend); // send answer to RTIA
+	rep.send(link,NM_msgBufSend); // send answer to RTIA
 }
 
 // ----------------------------------------------------------------------------
 // processReleaseResponse
 void
-RTIG::processReleaseResponse(Socket *link, NetworkMessage *req)
+RTIG::processReleaseResponse(Socket *link, NM_Attribute_Ownership_Release_Response *req)
 {
-    auditServer << "Object = " << req->object
-		<< ", # of att. = " << req->handleArraySize ;
+	auditServer << "Object = " << req->getObject()
+					<< ", # of att. = " << req->getAttributesSize() ;
+
+	AttributeHandleSet *attributes =
+			federations.respondRelease(req->federation,
+					req->federate,
+					req->getObject(),
+					req->getAttributes(),
+					req->getAttributesSize());
 
-    AttributeHandleSet *attributes =
-        federations.respondRelease(req->federation,
-                                    req->federate,
-                                    req->object,
-                                    req->handleArray,
-                                    req->handleArraySize);
-
-    D.Out(pdDebug, "Federate %u of Federation %u release response "
-          "of object %u.",
-          req->federate, req->federation, req->object);
-
-    NM_Attribute_Ownership_Release_Response rep ;
-    rep.handleArraySize = attributes->size();
-    rep.handleArray.resize(rep.handleArraySize) ;
-
-    for (unsigned int i = 0 ; i < attributes->size(); i++) {
-        rep.handleArray[i] = attributes->getHandle(i);
-    }
+	D.Out(pdDebug, "Federate %u of Federation %u release response "
+			"of object %u.",
+			req->federate, req->federation, req->getObject());
 
-    rep.federate = req->federate ;
-    rep.object = req->object ;
+	NM_Attribute_Ownership_Release_Response rep ;
+	rep.setAttributesSize(attributes->size()) ;
 
-    rep.send(link,NM_msgBufSend); // Send answer to RTIA
+	for (uint32_t i = 0 ; i < attributes->size(); ++i) {
+		rep.setAttributes(attributes->getHandle(i),i);
+	}
+
+	rep.federate = req->federate ;
+	rep.setObject(req->getObject());
+
+	rep.send(link,NM_msgBufSend); // Send answer to RTIA
 }
 
 // ----------------------------------------------------------------------------
 // processCancelAcquisition
 void
-RTIG::processCancelAcquisition(Socket *link, NetworkMessage *req)
+RTIG::processCancelAcquisition(Socket *link, NM_Cancel_Attribute_Ownership_Acquisition *req)
 {
-    auditServer << "Object = " << req->object
-		<< ", # of att. = " << req->handleArraySize ;
+	auditServer << "Object = " << req->getObject()
+					<< ", # of att. = " << req->getAttributesSize() ;
 
-    federations.cancelAcquisition(req->federation,
-                                   req->federate,
-                                   req->object,
-                                   req->handleArray,
-                                   req->handleArraySize);
-
-    D.Out(pdDebug,
-          "Federate %u of Federation %u release response of object %u.",
-          req->federate, req->federation, req->object);
-
-    NM_Cancel_Attribute_Ownership_Acquisition rep ;
-    rep.federate = req->federate ;
-    rep.object = req->object ;
-    rep.handleArraySize = 0 ;
+	federations.cancelAcquisition(req->federation,
+			req->federate,
+			req->getObject(),
+			req->getAttributes(),
+			req->getAttributesSize());
+
+	D.Out(pdDebug,
+			"Federate %u of Federation %u release response of object %u.",
+			req->federate, req->federation, req->getObject());
+
+	NM_Cancel_Attribute_Ownership_Acquisition rep ;
+	rep.federate = req->federate ;
+	rep.setObject(req->getObject());
 
-    rep.send(link,NM_msgBufSend); // send answer to RTIA
+	rep.send(link,NM_msgBufSend); // send answer to RTIA
 }
 
 // ----------------------------------------------------------------------------
 // processCreateRegion
 void
-RTIG::processCreateRegion(Socket *link, NetworkMessage *req)
+RTIG::processCreateRegion(Socket *link, NM_DDM_Create_Region *req)
 {
-    // TODO: audit...
+	// TODO: audit...
 
-    NM_DDM_Create_Region rep ;
-    rep.region = federations.createRegion(req->federation,
-                                           req->federate,
-                                           req->space,
-                                           req->nbExtents);
-
-    Debug(D, pdDebug) << "Federate " << req->federate << " of Federation "
-               << req->federation << " creates region " << rep.region
-               << endl ;
+	NM_DDM_Create_Region rep ;
+	rep.setRegion(federations.createRegion(req->federation,
+			req->federate,
+			req->getSpace(),
+			req->getNbExtents()));
+
+	Debug(D, pdDebug) << "Federate " << req->federate << " of Federation "
+			<< req->federation << " creates region " << rep.getRegion()
+			<< endl ;
 
-    rep.federate = req->federate ;
-    rep.send(link,NM_msgBufSend);
+	rep.federate = req->federate ;
+	rep.send(link,NM_msgBufSend);
 }
 
 // ----------------------------------------------------------------------------
 // processModifyRegion
 void
-RTIG::processModifyRegion(Socket *link, NetworkMessage *req)
+RTIG::processModifyRegion(Socket *link, NM_DDM_Modify_Region *req)
 {
-    Debug(D, pdDebug) << "Federate " << req->federate << " of Federation "
-               << req->federation << " modifies region " << req->region
-               << endl ;
-
-    federations.modifyRegion(req->federation, req->federate,
-			      req->region, req->getExtents());
-
-    NM_DDM_Modify_Region rep ;
-    rep.federate = req->federate ;
-    rep.send(link,NM_msgBufSend);
+	Debug(D, pdDebug) << "Federate " << req->federate << " of Federation "
+			<< req->federation << " modifies region " << req->getRegion()
+			<< endl ;
+
+	federations.modifyRegion(req->federation, req->federate,
+			req->getRegion(), req->getExtents());
+
+	NM_DDM_Modify_Region rep ;
+	rep.federate = req->federate ;
+	rep.send(link,NM_msgBufSend);
 }
 
 // ----------------------------------------------------------------------------
 // processDeleteRegion
 void
-RTIG::processDeleteRegion(Socket *link, NetworkMessage *req)
+RTIG::processDeleteRegion(Socket *link, NM_DDM_Delete_Region *req)
 {
-    // TODO: audit...
+	// TODO: audit...
+
+	Debug(D, pdDebug) << "Federate " << req->federate << " of Federation "
+			<< req->federation << " deletes region " << req->getRegion()
+			<< endl ;
 
-    Debug(D, pdDebug) << "Federate " << req->federate << " of Federation "
-               << req->federation << " deletes region " << req->region
-               << endl ;
+	federations.deleteRegion(req->federation, req->federate, req->getRegion());
 
-    federations.deleteRegion(req->federation, req->federate, req->region);
+	NM_DDM_Delete_Region rep;
 
-    NM_DDM_Delete_Region rep ;
-    rep.federate = req->federate ;
-    rep.region = req->region ;
-    rep.send(link,NM_msgBufSend);
+	rep.federate = req->federate ;
+	rep.setRegion(req->getRegion());
+	rep.send(link,NM_msgBufSend);
 }
 
 // ----------------------------------------------------------------------------
 // processAssociateRegion
 void
-RTIG::processAssociateRegion(Socket *link, NetworkMessage *req)
+RTIG::processAssociateRegion(Socket *link, NM_DDM_Associate_Region *req)
 {
-    // TODO: audit...
+	// TODO: audit...
 
-    Debug(D, pdDebug) << "Federate " << req->federate << " of Federation "
-               << req->federation << " associates region " << req->region
-               << " to some attributes of object " << req->object << endl ;
+	Debug(D, pdDebug) << "Federate " << req->federate << " of Federation "
+			<< req->federation << " associates region " << req->getRegion()
+			<< " to some attributes of object " << req->getObject() << endl ;
 
-    federations.associateRegion(req->federation, req->federate, req->object,
-				 req->region, req->handleArraySize,
-				 req->handleArray);
+	federations.associateRegion(req->federation, req->federate, req->getObject(),
+			req->getRegion(), req->getAttributesSize(),
+			req->getAttributes());
 
-    NM_DDM_Associate_Region rep ;
-    rep.federate = req->federate ;
-    rep.send(link,NM_msgBufSend);
+	NM_DDM_Associate_Region rep ;
+	rep.federate = req->federate ;
+	rep.send(link,NM_msgBufSend);
 }
 
 // ----------------------------------------------------------------------------
 // processUnassociateRegion
 void
-RTIG::processUnassociateRegion(Socket *link, NetworkMessage *req)
+RTIG::processUnassociateRegion(Socket *link, NM_DDM_Unassociate_Region *req)
 {
-    // TODO: audit...
+	// TODO: audit...
 
-    federations.unassociateRegion(req->federation, req->federate,
-				   req->object, req->region);
+	federations.unassociateRegion(req->federation, req->federate,
+			req->getObject(), req->getRegion());
 
-    Debug(D, pdDebug) << "Federate " << req->federate << " of Federation "
-               << req->federation << " associates region " << req->region
-               << " from object " << req->object << endl ;
+	Debug(D, pdDebug) << "Federate " << req->federate << " of Federation "
+			<< req->federation << " associates region " << req->getRegion()
+			<< " from object " << req->getObject() << endl ;
 
-    NM_DDM_Unassociate_Region rep ;
-    rep.federate = req->federate ;
-    rep.send(link,NM_msgBufSend);
+	NM_DDM_Unassociate_Region rep ;
+	rep.federate = req->federate ;
+	rep.send(link,NM_msgBufSend);
 }
 
 // ----------------------------------------------------------------------------
 // processSubscribeAttributes
 void
-RTIG::processSubscribeAttributesWR(Socket *link, NetworkMessage *req)
+RTIG::processSubscribeAttributesWR(Socket *link, NM_DDM_Subscribe_Attributes *req)
 {
-    // TODO: audit...
-    Debug(D, pdDebug) << "Federate " << req->federate << " of Federation "
-               << req->federation << " subscribes with region " << req->region
-               << " to some attributes of class " << req->objectClass << endl ;
-
-    federations.subscribeAttributesWR(req->federation, req->federate,
-				       req->objectClass, req->region,
-				       req->handleArraySize, req->handleArray);
-
-    NM_DDM_Subscribe_Attributes rep ;
-    rep.federate = req->federate ;
-    rep.objectClass = req->objectClass ;
-    rep.handleArraySize = 0 ;
-    rep.send(link,NM_msgBufSend);
+	// TODO: audit...
+	Debug(D, pdDebug) << "Federate " << req->federate << " of Federation "
+			<< req->federation << " subscribes with region " << req->getRegion()
+			<< " to some attributes of class " << req->getObjectClass() << endl ;
+
+	federations.subscribeAttributesWR(req->federation, req->federate,
+			req->getObjectClass(), req->getRegion(),
+			req->getAttributesSize(), req->getAttributes());
+
+	NM_DDM_Subscribe_Attributes rep ;
+	rep.federate = req->federate ;
+	rep.setObjectClass(req->getObjectClass());
+	rep.send(link,NM_msgBufSend);
 }
 
 // ----------------------------------------------------------------------------
 // processUnsubscribeAttributes
 void
-RTIG::processUnsubscribeAttributesWR(Socket *link, NetworkMessage *req)
+RTIG::processUnsubscribeAttributesWR(Socket *link, NM_DDM_Unsubscribe_Attributes *req)
 {
-    // TODO: audit...
-    Debug(D, pdDebug) << "Federate " << req->federate << " of Federation "
-               << req->federation << " unsubscribes with region " << req->region
-               << " from object class " << req->objectClass << endl ;
-
-    federations.unsubscribeAttributesWR(req->federation, req->federate,
-					 req->objectClass, req->region);
-
-    NM_DDM_Unsubscribe_Attributes rep ;
-    rep.federate = req->federate ;
-    rep.send(link,NM_msgBufSend);
+	// TODO: audit...
+	Debug(D, pdDebug) << "Federate " << req->federate << " of Federation "
+			<< req->federation << " unsubscribes with region " << req->getRegion()
+			<< " from object class " << req->getObjectClass() << endl ;
+
+	federations.unsubscribeAttributesWR(req->federation, req->federate,
+			req->getObjectClass(), req->getRegion());
+
+	NM_DDM_Unsubscribe_Attributes rep ;
+	rep.federate = req->federate ;
+	rep.send(link,NM_msgBufSend);
 }
 
 // ----------------------------------------------------------------------------
 // processSubscribeInteractions
 void
-RTIG::processSubscribeInteractionWR(Socket *link, NetworkMessage *req)
+RTIG::processSubscribeInteractionWR(Socket *link, NM_DDM_Subscribe_Interaction *req)
 {
-    // TODO: audit...
+	// TODO: audit...
 
-    federations.subscribeInteractionWR(req->federation, req->federate,
-					req->interactionClass, req->region);
+	federations.subscribeInteractionWR(req->federation, req->federate,
+			req->getInteractionClass(), req->getRegion());
 
-    Debug(D, pdDebug) << "Federate " << req->federate << " of Federation "
-               << req->federation << " subscribes with region " << req->region
-               << " to interaction class " << req->interactionClass << endl ;
+	Debug(D, pdDebug) << "Federate " << req->federate << " of Federation "
+			<< req->federation << " subscribes with region " << req->getRegion()
+			<< " to interaction class " << req->getInteractionClass() << endl ;
 
-    NM_DDM_Subscribe_Interaction rep ;
-    rep.federate = req->federate ;
-    rep.send(link,NM_msgBufSend);
+	NM_DDM_Subscribe_Interaction rep ;
+	rep.federate = req->federate ;
+	rep.send(link,NM_msgBufSend);
 }
 
 // ----------------------------------------------------------------------------
 // processUnsubscribeInteractions
 void
-RTIG::processUnsubscribeInteractionWR(Socket *link, NetworkMessage *req)
+RTIG::processUnsubscribeInteractionWR(Socket *link, NM_DDM_Unsubscribe_Interaction *req)
 {
-    // TODO: audit...
+	// TODO: audit...
 
-    federations.unsubscribeInteractionWR(req->federation, req->federate,
-				   req->interactionClass, req->region);
+	federations.unsubscribeInteractionWR(req->federation, req->federate,
+			req->getInteractionClass(), req->getRegion());
 
-    Debug(D, pdDebug) << "Federate " << req->federate << " of Federation "
-               << req->federation << " unsubscribes with region " << req->region
-               << " from interaction class " << req->interactionClass << endl ;
+	Debug(D, pdDebug) << "Federate " << req->federate << " of Federation "
+			<< req->federation << " unsubscribes with region " << req->getRegion()
+			<< " from interaction class " << req->getInteractionClass() << endl ;
 
-    NM_DDM_Unsubscribe_Interaction rep ;
-    rep.federate = req->federate ;
-    rep.send(link,NM_msgBufSend);
+	NM_DDM_Unsubscribe_Interaction rep ;
+	rep.federate = req->federate ;
+	rep.send(link,NM_msgBufSend);
 }
 
 // ----------------------------------------------------------------------------
 // processRegisterObjectWithRegion
 void
-RTIG::processRegisterObjectWithRegion(Socket *link, NetworkMessage *req)
+RTIG::processRegisterObjectWithRegion(Socket *link, NM_DDM_Register_Object *req)
 {
-	std::auto_ptr<NetworkMessage> rep(NM_Factory::create(req->getType()));
-    // FIXME bug #9869
-    // When we were passed a set of region
-    // we should register object for each region
-    // the trouble comes from the fact that
-    // there is both
-    //     - req->region  (coming from NetworkMessage::region)
-    //     - req->regions (coming from BasicMessage::regions)
-    // would be nice to sort those thing out.
-    rep->object = federations.registerObjectWithRegion(req->federation,
-						      req->federate,
-						      req->objectClass,
-						      req->getLabel(),
-						      req->region,
-						      req->handleArraySize,
-						      req->handleArray);
-
-    D.Out(pdRegister,
-          "Object \"%s\" of Federate %u has been registered under ID %u.",
-          req->getLabel().c_str(), req->federate, rep->object);
+	NM_DDM_Register_Object rep;
+	// FIXME bug #9869
+	// When we were passed a set of region
+	// we should register object for each region
+	// the trouble comes from the fact that
+	// there is both
+	//     - req->region  (coming from NetworkMessage::region)
+	//     - req->regions (coming from BasicMessage::regions)
+	// would be nice to sort those thing out.
+	rep.setObject(federations.registerObjectWithRegion(req->federation,
+			req->federate,
+			req->getObjectClass(),
+			req->getLabel(),
+			req->getRegion(),
+			req->getAttributesSize(),
+			req->getAttributes()));
+
+	D.Out(pdRegister,
+			"Object \"%s\" of Federate %u has been registered under ID %u.",
+			req->getLabel().c_str(), req->federate, rep.getObject());
 
-    rep->federate = req->federate ;
-    rep->send(link,NM_msgBufSend); // Send answer to RTIA
+	rep.federate = req->federate ;
+	rep.send(link,NM_msgBufSend); // Send answer to RTIA
 }
 
 // ----------------------------------------------------------------------------
 // processRequestObjectAttributeValueUpdate
 void
-RTIG::processRequestObjectAttributeValueUpdate(Socket *link, NetworkMessage *request)
+RTIG::processRequestObjectAttributeValueUpdate(Socket *link, NM_Request_Object_Attribute_Value_Update *request)
 {
-    NM_Request_Object_Attribute_Value_Update answer ;
-    Handle federateOwner ;  // federate owner of the object
-    G.Out(pdGendoc,"enter RTIG::processRequestObjectAttributeValueUpdate");
-    G.Out(pdGendoc,"BEGIN ** REQUEST OBJECT ATTRIBUTE VALUE UPDATE **");
-
-    auditServer << "ObjID = " << request->object ;
-
-    // We have to do verifications about this object and we need owner
-    answer.setException(e_NO_EXCEPTION);
-    try
-      {
-      federateOwner = federations.requestObjectOwner(request->federation,
-                                 request->federate,
-                                 request->object,
-                                 request->handleArray,
-                                 request->handleArraySize);
-      }
-     catch (ObjectNotKnown e)
-        {
-        answer.setException(e_ObjectNotKnown);
-        answer.exceptionReason = e._reason ;
-        }
-     catch (FederationExecutionDoesNotExist e)
-        {
-        answer.setException(e_FederationExecutionDoesNotExist);
-        answer.exceptionReason = e._reason ;
-        }
-     catch (RTIinternalError e)
-        {
-        answer.setException(e_RTIinternalError);
-        answer.exceptionReason = e._reason ;
-        }
-
-    answer.federate = request->federate ;
-    answer.object = request->object ;
-
-    answer.send(link,NM_msgBufSend); // Send answer to RTIA
-    G.Out(pdGendoc,"exit  RTIG::processRequestObjectAttributeValueUpdate");
-    G.Out(pdGendoc,"END   ** REQUEST OBJECT ATTRIBUTE VALUE UPDATE **");
+	NM_Request_Object_Attribute_Value_Update answer ;
+	Handle federateOwner ;  // federate owner of the object
+	G.Out(pdGendoc,"enter RTIG::processRequestObjectAttributeValueUpdate");
+	G.Out(pdGendoc,"BEGIN ** REQUEST OBJECT ATTRIBUTE VALUE UPDATE **");
+
+	auditServer << "ObjID = " << request->getObject() ;
+
+	// We have to do verifications about this object and we need owner
+	answer.setException(e_NO_EXCEPTION);
+	try
+	{
+		federateOwner = federations.requestObjectOwner(request->federation,
+				request->federate,
+				request->getObject(),
+				request->getAttributes(),
+				request->getAttributesSize());
+	}
+	catch (ObjectNotKnown e)
+	{
+		answer.setException(e_ObjectNotKnown);
+		answer.exceptionReason = e._reason ;
+	}
+	catch (FederationExecutionDoesNotExist e)
+	{
+		answer.setException(e_FederationExecutionDoesNotExist);
+		answer.exceptionReason = e._reason ;
+	}
+	catch (RTIinternalError e)
+	{
+		answer.setException(e_RTIinternalError);
+		answer.exceptionReason = e._reason ;
+	}
+
+	answer.federate = request->federate ;
+	answer.setObject(request->getObject());
+
+	answer.send(link,NM_msgBufSend); // Send answer to RTIA
+	G.Out(pdGendoc,"exit  RTIG::processRequestObjectAttributeValueUpdate");
+	G.Out(pdGendoc,"END   ** REQUEST OBJECT ATTRIBUTE VALUE UPDATE **");
 }
 
 }} // namespace certi/rtig
Index: RTIG/FederationsList.hh
===================================================================
RCS file: /sources/certi/certi/RTIG/FederationsList.hh,v
retrieving revision 3.53
diff -u -r3.53 FederationsList.hh
--- RTIG/FederationsList.hh	7 Mar 2010 21:30:30 -0000	3.53
+++ RTIG/FederationsList.hh	18 Mar 2010 18:31:09 -0000
@@ -109,7 +109,7 @@
                                const std::string& the_label,
                                const std::string& the_tag,
                                unsigned short federate_setSize,
-                               std::vector <FederateHandle> &federate_set)
+                               const std::vector <FederateHandle> &federate_set)
         throw (FederationAlreadyPaused,
                FederationNotPaused,
                FederateNotExecutionMember,
@@ -129,7 +129,7 @@
                                   const std::string& label,
                                   const std::string& tag,
                                   unsigned short federate_setSize,
-                                  std::vector <FederateHandle> &federate_set)
+                                  const std::vector <FederateHandle> &federate_set)
         throw (FederationExecutionDoesNotExist,
                RTIinternalError);
 
@@ -289,7 +289,7 @@
     void publishObject(Handle theHandle,
                        FederateHandle theFederateHandle,
                        ObjectClassHandle theObjectHandle,
-                       std::vector <AttributeHandle> &theAttributeList,
+                       const std::vector <AttributeHandle> &theAttributeList,
                        uint16_t theListSize,
                        bool pub)
         throw (ObjectClassNotDefined,
@@ -304,7 +304,7 @@
     void subscribeObject(Handle theHandle,
                          FederateHandle theFederateHandle,
                          ObjectClassHandle theObjectHandle,
-                         std::vector <AttributeHandle> &theAttributeList,
+                         const std::vector <AttributeHandle> &theAttributeList,
                          uint16_t theListSize)
         throw (ObjectClassNotDefined,
                AttributeNotDefined,
@@ -331,8 +331,8 @@
     FederateHandle requestObjectOwner(Handle handle,
                                 FederateHandle federate,
                                 ObjectHandle id,
-                                std::vector <AttributeHandle> &attributes,
-                                 uint16_t list_size)
+                                const std::vector <AttributeHandle> &attributes,
+                                 uint32_t list_size)
         throw (ObjectNotKnown,
                FederationExecutionDoesNotExist,
                RTIinternalError);
@@ -367,8 +367,8 @@
     void updateAttribute(Handle theHandle,
                          FederateHandle theFederateHandle,
                          ObjectHandle theObjectHandle,
-                         std::vector <AttributeHandle> &theAttributeList,
-                         std::vector <AttributeValue_t> &theValueList,
+                         const std::vector <AttributeHandle> &theAttributeList,
+                         const std::vector <AttributeValue_t> &theValueList,
                          uint16_t theListSize,
                          FederationTime theTime,
                          const std::string& theTag)
@@ -384,8 +384,8 @@
     void updateAttribute(Handle theHandle,
                          FederateHandle theFederateHandle,
                          ObjectHandle theObjectHandle,
-                         std::vector <AttributeHandle> &theAttributeList,
-                         std::vector <AttributeValue_t> &theValueList,
+                         const std::vector <AttributeHandle> &theAttributeList,
+                         const std::vector <AttributeValue_t> &theValueList,
                          uint16_t theListSize,
                          const std::string& theTag)
         throw (FederateNotExecutionMember,
@@ -428,8 +428,8 @@
     void updateParameter(Handle theFederation,
                          FederateHandle theFederateHandle,
                          InteractionClassHandle theInteractionHandle,
-                         std::vector <ParameterHandle> &theParameterList,
-                         std::vector <ParameterValue_t> &theValueList,
+                         const std::vector <ParameterHandle> &theParameterList,
+                         const std::vector <ParameterValue_t> &theValueList,
                          uint16_t theListSize,
                          FederationTime theTime,
 			 RegionHandle,
@@ -446,8 +446,8 @@
     void updateParameter(Handle theFederation,
                          FederateHandle theFederateHandle,
                          InteractionClassHandle theInteractionHandle,
-                         std::vector <ParameterHandle> &theParameterList,
-                         std::vector <ParameterValue_t> &theValueList,
+                         const std::vector <ParameterHandle> &theParameterList,
+                         const std::vector <ParameterValue_t> &theValueList,
                          uint16_t theListSize,
 			 RegionHandle,
                          const std::string& theTag)
@@ -488,7 +488,7 @@
     void negotiateDivestiture(Handle,
                               FederateHandle,
                               ObjectHandle,
-                              std::vector <AttributeHandle>&,
+                              const std::vector <AttributeHandle>&,
                               uint16_t,
                               const std::string& )
         throw (FederateNotExecutionMember,
@@ -503,7 +503,7 @@
     void acquireIfAvailable(Handle,
                             FederateHandle,
                             ObjectHandle,
-                            std::vector <AttributeHandle>&,
+                            const std::vector <AttributeHandle>&,
                             uint16_t)
         throw (ObjectNotKnown,
                ObjectClassNotPublished,
@@ -519,7 +519,7 @@
     void divest(Handle,
                 FederateHandle,
                 ObjectHandle,
-                std::vector <AttributeHandle>&,
+                const std::vector <AttributeHandle>&,
                 uint16_t)
         throw (ObjectNotKnown,
                AttributeNotDefined,
@@ -532,7 +532,7 @@
     void acquire(Handle theHandle,
                  FederateHandle theFederateHandle,
                  ObjectHandle theObjectHandle,
-                 std::vector <AttributeHandle> &theAttributeList,
+                 const std::vector <AttributeHandle> &theAttributeList,
                  uint16_t theListSize,
                  const std::string& theTag)
         throw (ObjectNotKnown,
@@ -548,7 +548,7 @@
     void cancelDivestiture(Handle theHandle,
                            FederateHandle theFederateHandle,
                            ObjectHandle theObjectHandle,
-                           std::vector <AttributeHandle> &theAttributeList,
+                           const std::vector <AttributeHandle> &theAttributeList,
                            uint16_t theListSize)
         throw (ObjectNotKnown,
                AttributeNotDefined,
@@ -562,7 +562,7 @@
     AttributeHandleSet* respondRelease(Handle theHandle,
                                        FederateHandle theFederateHandle,
                                        ObjectHandle theObjectHandle,
-                                       std::vector <AttributeHandle> &theAttributeList,
+                                       const std::vector <AttributeHandle> &theAttributeList,
                                        uint16_t theListSize)
         throw (ObjectNotKnown,
                AttributeNotDefined,
@@ -576,7 +576,7 @@
     void cancelAcquisition(Handle theHandle,
                            FederateHandle theFederateHandle,
                            ObjectHandle theObjectHandle,
-                           std::vector <AttributeHandle> &theAttributeList,
+                           const std::vector <AttributeHandle> &theAttributeList,
                            uint16_t theListSize)
         throw (ObjectNotKnown,
                AttributeNotDefined,
@@ -602,7 +602,7 @@
                SaveInProgress, RestoreInProgress, RTIinternalError);
 
     void associateRegion(Handle, FederateHandle, ObjectHandle, RegionHandle,
-			 unsigned short, std::vector <AttributeHandle> &)
+			 unsigned short, const std::vector <AttributeHandle> &)
 	throw (RegionInUse, FederateNotExecutionMember, SaveInProgress,
 	       RestoreInProgress, RTIinternalError);
 
@@ -611,7 +611,7 @@
 	       RestoreInProgress, RTIinternalError);
 
     void subscribeAttributesWR(Handle, FederateHandle, ObjectClassHandle,
-			       RegionHandle, unsigned short, std::vector <AttributeHandle> &)
+			       RegionHandle, unsigned short,const std::vector <AttributeHandle> &)
 	throw (FederateNotExecutionMember, SaveInProgress, RestoreInProgress,
 	       RTIinternalError);
 
@@ -632,7 +632,7 @@
 
     ObjectHandle registerObjectWithRegion(Handle, FederateHandle,
 					  ObjectClassHandle, ObjectName_t,
-					  RegionHandle, int, std::vector <AttributeHandle> &)
+					  RegionHandle, int, const std::vector <AttributeHandle> &)
 	throw (ObjectClassNotDefined, ObjectClassNotPublished,
 	       AttributeNotDefined, AttributeNotPublished, RegionNotKnown,
 	       InvalidRegionContext, ObjectAlreadyRegistered,
Index: RTIG/FederationsList.cc
===================================================================
RCS file: /sources/certi/certi/RTIG/FederationsList.cc,v
retrieving revision 3.69
diff -u -r3.69 FederationsList.cc
--- RTIG/FederationsList.cc	7 Mar 2010 21:30:30 -0000	3.69
+++ RTIG/FederationsList.cc	18 Mar 2010 18:31:08 -0000
@@ -497,8 +497,8 @@
 FederationsList::updateAttribute(Handle federationHandle,
                                  FederateHandle federate,
                                  ObjectHandle id,
-                                 std::vector <AttributeHandle> &attributes,
-                                 std::vector <AttributeValue_t> &values,
+                                 const std::vector <AttributeHandle> &attributes,
+                                 const std::vector <AttributeValue_t> &values,
                                  uint16_t list_size,
                                  FederationTime time,
                                  const std::string& tag)
@@ -524,8 +524,8 @@
 FederationsList::updateAttribute(Handle federationHandle,
                                  FederateHandle federate,
                                  ObjectHandle id,
-                                 std::vector <AttributeHandle> &attributes,
-                                 std::vector <AttributeValue_t> &values,
+                                 const std::vector <AttributeHandle> &attributes,
+                                 const std::vector <AttributeValue_t> &values,
                                  uint16_t list_size,
                                  const std::string& tag)
     throw (FederateNotExecutionMember,
@@ -549,8 +549,8 @@
 FederationsList::updateParameter(Handle federationHandle,
                                  FederateHandle federate,
                                  InteractionClassHandle interaction,
-                                 std::vector <ParameterHandle> &parameters,
-                                 std::vector <ParameterValue_t> &values,
+                                 const std::vector <ParameterHandle> &parameters,
+                                 const std::vector <ParameterValue_t> &values,
                                  uint16_t list_size,
                                  FederationTime time,
 				 RegionHandle region,
@@ -582,8 +582,8 @@
 FederationsList::updateParameter(Handle federationHandle,
                                  FederateHandle federate,
                                  InteractionClassHandle interaction,
-                                 std::vector <ParameterHandle> &parameters,
-                                 std::vector <ParameterValue_t> &values,
+                                 const std::vector <ParameterHandle> &parameters,
+                                 const std::vector <ParameterValue_t> &values,
                                  uint16_t list_size,
 				 RegionHandle region,
                                  const std::string& tag)
@@ -646,7 +646,7 @@
                                        const std::string& label,
                                        const std::string& tag,
                                        unsigned short federate_setSize,
-                                       std::vector <FederateHandle> &federate_set)
+                                       const std::vector <FederateHandle> &federate_set)
     throw (FederationAlreadyPaused,
            FederationNotPaused,
            FederateNotExecutionMember,
@@ -699,7 +699,7 @@
                                           const std::string& label,
                                           const std::string& tag,
                                           unsigned short federate_setSize,
-                                          std::vector <FederateHandle> &federate_set)
+                                          const std::vector <FederateHandle> &federate_set)
     throw (FederationExecutionDoesNotExist,
            RTIinternalError)
 {
@@ -741,7 +741,7 @@
 FederationsList::publishObject(Handle federationHandle,
                                FederateHandle federate,
                                ObjectClassHandle object_class,
-                               std::vector <AttributeHandle> &attributes,
+                               const std::vector <AttributeHandle> &attributes,
                                uint16_t list_size,
                                bool pub)
     throw (ObjectClassNotDefined,
@@ -788,7 +788,7 @@
 FederationsList::subscribeObject(Handle federationHandle,
                                  FederateHandle federate,
                                  ObjectClassHandle object_class,
-                                 std::vector <AttributeHandle> &attributes,
+                                 const std::vector <AttributeHandle> &attributes,
                                  uint16_t list_size)
     throw (ObjectClassNotDefined,
            AttributeNotDefined,
@@ -950,7 +950,7 @@
 FederationsList::negotiateDivestiture(Handle federationHandle,
                                       FederateHandle federate,
                                       ObjectHandle id,
-                                      std::vector <AttributeHandle> &attributes,
+                                      const std::vector <AttributeHandle> &attributes,
                                       uint16_t list_size,
                                       const std::string& tag)
     throw (FederateNotExecutionMember,
@@ -976,7 +976,7 @@
 FederationsList::acquireIfAvailable(Handle federationHandle,
                                     FederateHandle federate,
                                     ObjectHandle id,
-                                    std::vector <AttributeHandle> &attributes,
+                                    const std::vector <AttributeHandle> &attributes,
                                     uint16_t list_size)
     throw (ObjectNotKnown,
            ObjectClassNotPublished,
@@ -1001,7 +1001,7 @@
 FederationsList::divest(Handle federationHandle,
                         FederateHandle federate,
                         ObjectHandle id,
-                        std::vector <AttributeHandle> &attributes,
+                        const std::vector <AttributeHandle> &attributes,
                         uint16_t list_size)
     throw (ObjectNotKnown,
            AttributeNotDefined,
@@ -1022,7 +1022,7 @@
 FederationsList::acquire(Handle federationHandle,
                          FederateHandle federate,
                          ObjectHandle id,
-                         std::vector <AttributeHandle> &attributes,
+                         const std::vector <AttributeHandle> &attributes,
                          uint16_t list_size,
                          const std::string& tag)
     throw (ObjectNotKnown,
@@ -1047,7 +1047,7 @@
 FederationsList::cancelDivestiture(Handle federationHandle,
                                    FederateHandle federate,
                                    ObjectHandle id,
-                                   std::vector <AttributeHandle> &attributes,
+                                   const std::vector <AttributeHandle> &attributes,
                                    uint16_t list_size)
     throw (ObjectNotKnown, AttributeNotDefined, AttributeNotOwned,
            AttributeDivestitureWasNotRequested, FederateNotExecutionMember,
@@ -1068,7 +1068,7 @@
 FederationsList::respondRelease(Handle federationHandle,
                                 FederateHandle federate,
                                 ObjectHandle id,
-                                std::vector <AttributeHandle> &attributes,
+                                const std::vector <AttributeHandle> &attributes,
                                 uint16_t list_size)
     throw (ObjectNotKnown,
            AttributeNotDefined,
@@ -1093,7 +1093,7 @@
 FederationsList::cancelAcquisition(Handle federationHandle,
                                    FederateHandle federate,
                                    ObjectHandle id,
-                                   std::vector <AttributeHandle> &attributes,
+                                   const std::vector <AttributeHandle> &attributes,
                                    uint16_t list_size)
     throw (ObjectNotKnown,
            AttributeNotDefined,
@@ -1165,7 +1165,7 @@
 				 ObjectHandle object,
 				 RegionHandle region,
 				 unsigned short nb_attributes,
-				 std::vector <AttributeHandle> &attributes)
+				 const std::vector <AttributeHandle> &attributes)
 	throw (RegionInUse, FederateNotExecutionMember, SaveInProgress,
 	       RestoreInProgress, RTIinternalError)
 {
@@ -1199,7 +1199,7 @@
 				       ObjectClassHandle object_class,
 				       RegionHandle region,
 				       unsigned short nb,
-				       std::vector <AttributeHandle> &attributes)
+				       const std::vector <AttributeHandle> &attributes)
     throw (FederateNotExecutionMember, SaveInProgress, RestoreInProgress,
 	   RTIinternalError)
 {
@@ -1266,7 +1266,7 @@
 						       ObjectName_t tag,
 						       RegionHandle region,
 						       int nb,
-						       std::vector <AttributeHandle> &attrs)
+						       const std::vector <AttributeHandle> &attrs)
 	throw (ObjectClassNotDefined, ObjectClassNotPublished,
 	       AttributeNotDefined, AttributeNotPublished, RegionNotKnown,
 	       InvalidRegionContext, ObjectAlreadyRegistered,
@@ -1379,8 +1379,8 @@
 FederationsList::requestObjectOwner(Handle federationHandle,
                                  FederateHandle federate,
                                  ObjectHandle id,
-                                 std::vector <AttributeHandle> &attributes,
-                                 uint16_t list_size)
+                                 const std::vector <AttributeHandle> &attributes,
+                                 uint32_t list_size)
         throw (ObjectNotKnown,
                FederationExecutionDoesNotExist,
                RTIinternalError)
Index: RTIG/RTIG.hh
===================================================================
RCS file: /sources/certi/certi/RTIG/RTIG.hh,v
retrieving revision 3.32
diff -u -r3.32 RTIG.hh
--- RTIG/RTIG.hh	14 Sep 2009 17:54:09 -0000	3.32
+++ RTIG/RTIG.hh	18 Mar 2010 18:31:09 -0000
@@ -91,38 +91,36 @@
     void processFederateSaveStatus(Socket*, NetworkMessage*);
     void processRequestFederationRestore(Socket*, NetworkMessage*);
     void processFederateRestoreStatus(Socket*, NetworkMessage*);
-    void processPublishObjectClass(Socket*, NetworkMessage*);
-    void processSubscribeObjectClass(Socket*, NetworkMessage*);
-    void processUnpublishObjectClass(Socket*, NetworkMessage*);
-    void processUnsubscribeObjectClass(Socket*, NetworkMessage*);
-    void processPublishInteractionClass(Socket*, NetworkMessage*);
-    void processSubscribeInteractionClass(Socket*, NetworkMessage*);
+    void processPublishObjectClass(Socket*, NM_Publish_Object_Class*);
+    void processSubscribeObjectClass(Socket*, NM_Subscribe_Object_Class*);
+    void processPublishInteractionClass(Socket*, NM_Publish_Interaction_Class*);
+    void processSubscribeInteractionClass(Socket*, NM_Subscribe_Interaction_Class*);
     void processUnpublishInteractionClass(Socket*, NetworkMessage*);
     void processUnsubscribeInteractionClass(Socket*, NetworkMessage*msg);
-    void processRegisterObject(Socket*, NetworkMessage*);
-    void processUpdateAttributeValues(Socket*, NetworkMessage*);
-    void processSendInteraction(Socket*, NetworkMessage*);
-    void processDeleteObject(Socket*, NetworkMessage*);
-    void processQueryAttributeOwnership(Socket*, NetworkMessage*);
-    void processNegotiatedOwnershipDivestiture(Socket*, NetworkMessage*);
-    void processAcquisitionIfAvailable(Socket*, NetworkMessage*);
-    void processUnconditionalDivestiture(Socket*, NetworkMessage*);
-    void processOwnershipAcquisition(Socket*, NetworkMessage*);
-    void processCancelNegotiatedDivestiture(Socket*, NetworkMessage*);
-    void processAttributeOwnedByFederate(Socket*, NetworkMessage*);
-    void processReleaseResponse(Socket*, NetworkMessage*);
-    void processCancelAcquisition(Socket*, NetworkMessage*);
-    void processCreateRegion(Socket*, NetworkMessage*);
-    void processModifyRegion(Socket*, NetworkMessage*);
-    void processDeleteRegion(Socket*, NetworkMessage*);
-    void processAssociateRegion(Socket*, NetworkMessage*);
-    void processUnassociateRegion(Socket*, NetworkMessage*);
-    void processSubscribeAttributesWR(Socket*, NetworkMessage*);
-    void processUnsubscribeAttributesWR(Socket*, NetworkMessage*);
-    void processSubscribeInteractionWR(Socket*, NetworkMessage*);
-    void processUnsubscribeInteractionWR(Socket*, NetworkMessage*);
-    void processRegisterObjectWithRegion(Socket*, NetworkMessage*);
-    void processRequestObjectAttributeValueUpdate(Socket*, NetworkMessage*);
+    void processRegisterObject(Socket*, NM_Register_Object*);
+    void processUpdateAttributeValues(Socket*, NM_Update_Attribute_Values*);
+    void processSendInteraction(Socket*, NM_Send_Interaction*);
+    void processDeleteObject(Socket*, NM_Delete_Object*);
+    void processQueryAttributeOwnership(Socket*, NM_Query_Attribute_Ownership*);
+    void processNegotiatedOwnershipDivestiture(Socket*, NM_Negotiated_Attribute_Ownership_Divestiture*);
+    void processAcquisitionIfAvailable(Socket*, NM_Attribute_Ownership_Acquisition_If_Available*);
+    void processUnconditionalDivestiture(Socket*, NM_Unconditional_Attribute_Ownership_Divestiture*);
+    void processOwnershipAcquisition(Socket*, NM_Attribute_Ownership_Acquisition*);
+    void processCancelNegotiatedDivestiture(Socket*, NM_Cancel_Negotiated_Attribute_Ownership_Divestiture*);
+    void processAttributeOwnedByFederate(Socket*, NM_Is_Attribute_Owned_By_Federate*);
+    void processReleaseResponse(Socket*, NM_Attribute_Ownership_Release_Response*);
+    void processCancelAcquisition(Socket*, NM_Cancel_Attribute_Ownership_Acquisition*);
+    void processCreateRegion(Socket*, NM_DDM_Create_Region*);
+    void processModifyRegion(Socket*, NM_DDM_Modify_Region*);
+    void processDeleteRegion(Socket*, NM_DDM_Delete_Region*);
+    void processAssociateRegion(Socket*, NM_DDM_Associate_Region*);
+    void processUnassociateRegion(Socket*, NM_DDM_Unassociate_Region*);
+    void processSubscribeAttributesWR(Socket*, NM_DDM_Subscribe_Attributes*);
+    void processUnsubscribeAttributesWR(Socket*, NM_DDM_Unsubscribe_Attributes*);
+    void processSubscribeInteractionWR(Socket*, NM_DDM_Subscribe_Interaction*);
+    void processUnsubscribeInteractionWR(Socket*, NM_DDM_Unsubscribe_Interaction*);
+    void processRegisterObjectWithRegion(Socket*, NM_DDM_Register_Object*);
+    void processRequestObjectAttributeValueUpdate(Socket*, NM_Request_Object_Attribute_Value_Update*);
 
 private:
     int tcpPort ;
Index: test/Billard/Billard.hh
===================================================================
RCS file: /sources/certi/certi/test/Billard/Billard.hh,v
retrieving revision 3.13
diff -u -r3.13 Billard.hh
--- test/Billard/Billard.hh	28 Sep 2007 14:07:54 -0000	3.13
+++ test/Billard/Billard.hh	18 Mar 2010 18:31:12 -0000
@@ -61,9 +61,12 @@
 // Here no test. Comment next line if you want to test requestFederationSave
 #undef TEST_RFSP
 
+
+
 class Billard : public NullFederateAmbassador
 {
 public:
+
     Billard(std::string);
     virtual ~Billard() throw (RTI::FederateInternalError);
 
@@ -145,6 +148,36 @@
 
     bool getCreator(){return creator;};
 
+    /**
+     * Helper class to simplify string construction. Implemented as
+     * a stringstream wrapper.
+     *
+     * For example:
+     * throw AttributeNotDefined(stringize() << "value: " << number);
+     */
+    template<typename C>
+    struct basic_stringize
+    {
+      template<typename T>
+      basic_stringize<C> & operator << (const T& t)
+      {
+        m_s << t;
+        return *this;
+      }
+
+      // note: must not return reference
+      operator const std::basic_string<C>() const
+      {
+        return m_s.str();
+      }
+
+    private:
+      std::basic_stringstream<C> m_s;
+    };
+
+    typedef basic_stringize<char> stringize;
+    typedef basic_stringize<wchar_t> wstringize;
+
 protected:
     virtual void getHandles();
  
Index: test/Billard/Billard.cc
===================================================================
RCS file: /sources/certi/certi/test/Billard/Billard.cc,v
retrieving revision 3.43
diff -u -r3.43 Billard.cc
--- test/Billard/Billard.cc	24 Nov 2009 21:44:48 -0000	3.43
+++ test/Billard/Billard.cc	18 Mar 2010 18:31:12 -0000
@@ -774,7 +774,8 @@
 {
     if (theObjectClass != BilleClassID) {
         D.Out(pdError, "Object of Unknown Class discovered.");
-        throw RTI::FederateInternalError("");
+        std::string msg = stringize() << "Unknown objectClass < "<<theObjectClass <<">";
+        throw RTI::FederateInternalError(msg.c_str());
     }
     
     bool already = false ;
Index: libRTI/RTIambPrivateRefs.cc
===================================================================
RCS file: /sources/certi/certi/libRTI/RTIambPrivateRefs.cc,v
retrieving revision 3.25
diff -u -r3.25 RTIambPrivateRefs.cc
--- libRTI/RTIambPrivateRefs.cc	7 Mar 2010 18:23:39 -0000	3.25
+++ libRTI/RTIambPrivateRefs.cc	18 Mar 2010 18:31:12 -0000
@@ -740,6 +740,7 @@
 	case Message::DISCOVER_OBJECT_INSTANCE:
 		try {
 			M_Discover_Object_Instance* DOI = static_cast<M_Discover_Object_Instance *>(msg);
+			DOI->show(std::cerr);
 			fed_amb->discoverObjectInstance(DOI->getObject(),
 					DOI->getObjectClass(),
 					DOI->getObjectName().c_str());
