diff --exclude=CVS -Nru certi/include/baseTypes.hh certi.new/include/baseTypes.hh
--- certi/include/baseTypes.hh	2008-09-29 14:31:28.000000000 +0200
+++ certi.new/include/baseTypes.hh	2008-11-26 10:26:07.000000000 +0100
@@ -17,7 +17,7 @@
     RTI_TRUE
 };
 
-class CERTI_EXPORT Exception
+class RTI_EXPORT Exception
 {
 public:
     ULong _serial ;
@@ -35,7 +35,7 @@
 };
 
 #define RTI_EXCEPT(A) \
-class CERTI_EXPORT A : public Exception { \
+class RTI_EXPORT A : public Exception { \
 public: \
     static const char *_ex ; \
     static long type ; \
diff --exclude=CVS -Nru certi/include/certi.hh certi.new/include/certi.hh
--- certi/include/certi.hh	2008-10-28 13:07:26.000000000 +0100
+++ certi.new/include/certi.hh	2008-11-26 14:25:29.000000000 +0100
@@ -98,10 +98,8 @@
 
 // RTI Shortcuts
 typedef RTI::AttributeHandle AttributeHandle ;
-typedef RTI::AttributeHandleSet AttributeHandleSet ;
 typedef RTI::DimensionHandle DimensionHandle ;
 typedef RTI::EventRetractionHandle EventRetractionHandle ;
-typedef RTI::Exception Exception ;
 typedef RTI::ExtentIndex ExtentIndex ;
 typedef RTI::FederateHandle FederateHandle ;
 typedef RTI::Handle Handle ;
@@ -115,113 +113,6 @@
 typedef RTI::ULong ULong ;
 typedef RTI::UShort UShort ;
 
-// RTI Shortcuts (exceptions)
-typedef RTI::ArrayIndexOutOfBounds ArrayIndexOutOfBounds ;
-typedef RTI::AsynchronousDeliveryAlreadyDisabled AsynchronousDeliveryAlreadyDisabled ;
-typedef RTI::AsynchronousDeliveryAlreadyEnabled  AsynchronousDeliveryAlreadyEnabled ;
-typedef RTI::AttributeAcquisitionWasNotRequested AttributeAcquisitionWasNotRequested ;
-typedef RTI::AttributeAcquisitionWasNotCanceled AttributeAcquisitionWasNotCanceled ;
-typedef RTI::AttributeAlreadyBeingAcquired AttributeAlreadyBeingAcquired ;
-typedef RTI::AttributeAlreadyBeingDivested AttributeAlreadyBeingDivested ;
-typedef RTI::AttributeAlreadyOwned AttributeAlreadyOwned ;
-typedef RTI::AttributeDivestitureWasNotRequested AttributeDivestitureWasNotRequested ;
-typedef RTI::AttributeNotDefined AttributeNotDefined ;
-typedef RTI::AttributeNotKnown AttributeNotKnown ;
-typedef RTI::AttributeNotOwned AttributeNotOwned ;
-typedef RTI::AttributeNotPublished AttributeNotPublished ;
-typedef RTI::ConcurrentAccessAttempted ConcurrentAccessAttempted ;
-typedef RTI::CouldNotDiscover CouldNotDiscover ;
-typedef RTI::CouldNotOpenFED CouldNotOpenFED ;
-typedef RTI::CouldNotRestore CouldNotRestore ;
-typedef RTI::DeletePrivilegeNotHeld DeletePrivilegeNotHeld ;
-typedef RTI::DimensionNotDefined DimensionNotDefined ;
-typedef RTI::EnableTimeConstrainedPending EnableTimeConstrainedPending ;
-typedef RTI::EnableTimeConstrainedWasNotPending EnableTimeConstrainedWasNotPending ;
-typedef RTI::EnableTimeRegulationPending EnableTimeRegulationPending ;
-typedef RTI::EnableTimeRegulationWasNotPending EnableTimeRegulationWasNotPending ;
-typedef RTI::ErrorReadingFED ErrorReadingFED ;
-typedef RTI::EventNotKnown EventNotKnown ;
-typedef RTI::FederateAlreadyExecutionMember FederateAlreadyExecutionMember ;
-typedef RTI::FederateInternalError FederateInternalError ;
-typedef RTI::FederateLoggingServiceCalls FederateLoggingServiceCalls ;
-typedef RTI::FederateNotExecutionMember FederateNotExecutionMember ;
-typedef RTI::FederateOwnsAttributes FederateOwnsAttributes ;
-typedef RTI::FederateWasNotAskedToReleaseAttribute FederateWasNotAskedToReleaseAttribute ;
-typedef RTI::FederatesCurrentlyJoined FederatesCurrentlyJoined ;
-typedef RTI::FederationExecutionAlreadyExists FederationExecutionAlreadyExists ;
-typedef RTI::FederationExecutionDoesNotExist FederationExecutionDoesNotExist ;
-typedef RTI::FederationTimeAlreadyPassed FederationTimeAlreadyPassed ;
-typedef RTI::HandleValuePairMaximumExceeded HandleValuePairMaximumExceeded ;
-typedef RTI::InteractionClassNotDefined InteractionClassNotDefined ;
-typedef RTI::InteractionClassNotKnown InteractionClassNotKnown ;
-typedef RTI::InteractionClassNotPublished InteractionClassNotPublished ;
-typedef RTI::InteractionClassNotSubscribed InteractionClassNotSubscribed ;
-typedef RTI::InteractionParameterNotDefined InteractionParameterNotDefined ;
-typedef RTI::InteractionParameterNotKnown InteractionParameterNotKnown ;
-typedef RTI::InvalidExtents InvalidExtents ;
-typedef RTI::InvalidFederationTime InvalidFederationTime ;
-typedef RTI::InvalidHandleValuePairSetContext InvalidHandleValuePairSetContext ;
-typedef RTI::InvalidLookahead InvalidLookahead ;
-typedef RTI::InvalidOrderingHandle InvalidOrderingHandle ;
-typedef RTI::InvalidRegionContext InvalidRegionContext ;
-typedef RTI::InvalidResignAction InvalidResignAction ;
-typedef RTI::InvalidRetractionHandle InvalidRetractionHandle ;
-typedef RTI::InvalidTransportationHandle InvalidTransportationHandle ;
-typedef RTI::MemoryExhausted MemoryExhausted ;
-typedef RTI::NameNotFound NameNotFound ;
-typedef RTI::ObjectClassNotDefined ObjectClassNotDefined ;
-typedef RTI::ObjectClassNotKnown ObjectClassNotKnown ;
-typedef RTI::ObjectClassNotPublished ObjectClassNotPublished ;
-typedef RTI::ObjectClassNotSubscribed ObjectClassNotSubscribed ;
-typedef RTI::ObjectNotKnown ObjectNotKnown ;
-typedef RTI::ObjectAlreadyRegistered ObjectAlreadyRegistered ;
-typedef RTI::OwnershipAcquisitionPending OwnershipAcquisitionPending ;
-typedef RTI::RegionInUse RegionInUse ;
-typedef RTI::RegionNotKnown RegionNotKnown ;
-typedef RTI::RestoreInProgress RestoreInProgress ;
-typedef RTI::RestoreNotRequested RestoreNotRequested ;
-typedef RTI::RTIinternalError RTIinternalError ;
-typedef RTI::SpaceNotDefined SpaceNotDefined ;
-typedef RTI::SaveInProgress SaveInProgress ;
-typedef RTI::SaveNotInitiated SaveNotInitiated ;
-typedef RTI::SpecifiedSaveLabelDoesNotExist SpecifiedSaveLabelDoesNotExist ;
-typedef RTI::SynchronizationPointLabelWasNotAnnounced SynchronizationPointLabelWasNotAnnounced ;
-typedef RTI::TimeAdvanceAlreadyInProgress TimeAdvanceAlreadyInProgress ;
-typedef RTI::TimeAdvanceWasNotInProgress TimeAdvanceWasNotInProgress ;
-typedef RTI::TimeConstrainedAlreadyEnabled TimeConstrainedAlreadyEnabled ;
-typedef RTI::TimeConstrainedWasNotEnabled TimeConstrainedWasNotEnabled ;
-typedef RTI::TimeRegulationAlreadyEnabled TimeRegulationAlreadyEnabled ;
-typedef RTI::TimeRegulationWasNotEnabled TimeRegulationWasNotEnabled ;
-typedef RTI::UnableToPerformSave UnableToPerformSave ;
-typedef RTI::ValueCountExceeded ValueCountExceeded ;
-typedef RTI::ValueLengthExceeded ValueLengthExceeded ;
-
-// CERTI Exception-derived Exceptions (including deprecated HLA exceptions)
-RTI_EXCEPT(FederateNotPublishing)
-RTI_EXCEPT(FederateNotSubscribing)
-RTI_EXCEPT(InvalidObjectHandle)
-RTI_EXCEPT(SecurityError)
-RTI_EXCEPT(CouldNotOpenRID)
-RTI_EXCEPT(ErrorReadingRID)
-RTI_EXCEPT(FederationAlreadyPaused)
-RTI_EXCEPT(FederationNotPaused)
-RTI_EXCEPT(AttributeNotSubscribed)
-RTI_EXCEPT(FederateAlreadyPaused)
-RTI_EXCEPT(FederateDoesNotExist)
-RTI_EXCEPT(FederateNameAlreadyInUse)
-RTI_EXCEPT(FederateNotPaused)
-RTI_EXCEPT(IDsupplyExhausted)
-RTI_EXCEPT(InvalidDivestitureCondition)
-RTI_EXCEPT(InvalidFederationTimeDelta)
-RTI_EXCEPT(InvalidRoutingSpace)
-RTI_EXCEPT(NoPauseRequested)
-RTI_EXCEPT(NoResumeRequested)
-RTI_EXCEPT(TooManyIDsRequested)
-RTI_EXCEPT(UnimplementedService)
-RTI_EXCEPT(UnknownLabel)
-RTI_EXCEPT(NetworkSignal)
-RTI_EXCEPT(NetworkError)
-
 typedef RTI::Double FederationTime ;
 typedef UShort ObjectHandlecount ;
 typedef std::string ObjectName_t ;
diff --exclude=CVS -Nru certi/libCERTI/CMakeLists.txt certi.new/libCERTI/CMakeLists.txt
--- certi/libCERTI/CMakeLists.txt	2008-12-03 11:23:54.000000000 +0100
+++ certi.new/libCERTI/CMakeLists.txt	2008-12-05 12:33:43.000000000 +0100
@@ -46,7 +46,6 @@
 )
 
 SET(CERTI_OWNERSHIP_SRCS
-GAV_aux.cc
 GAV.cc
 GAV.hh
 )
@@ -225,8 +224,9 @@
     ${FEDTIME_SRCS}
 )
 
+TARGET_LINK_LIBRARIES(FedTime RTI)
+
 SET_TARGET_PROPERTIES(FedTime PROPERTIES PROJECT_LABEL LibFedTime)
-                        
 IF (MINGW)
     SET_TARGET_PROPERTIES(FedTime PROPERTIES LINK_FLAGS "-Wl,--output-def,${LIBRARY_OUTPUT_PATH}/libFedTime.def")
     INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/libFedTime.def
diff --exclude=CVS -Nru certi/libCERTI/Exception.cc certi.new/libCERTI/Exception.cc
--- certi/libCERTI/Exception.cc	2008-11-25 17:32:14.000000000 +0100
+++ certi.new/libCERTI/Exception.cc	2008-12-05 17:19:44.000000000 +0100
@@ -26,55 +26,110 @@
 #include "certi.hh"
 
 // static members for HLA Exceptions
-const char *certi::FederateNotPublishing::_ex = "FederateNotPublishing" ;
-const char *certi::FederateNotSubscribing::_ex = "FederateNotSubscribing" ;
-const char *certi::InvalidObjectHandle::_ex = "InvalidObjectHandle" ;
-const char *certi::SecurityError::_ex = "SecurityError" ;
-const char *certi::CouldNotOpenRID::_ex = "CouldNotOpenRID" ;
-const char *certi::ErrorReadingRID::_ex = "ErrorReadingRID" ;
-const char *certi::FederationAlreadyPaused::_ex = "FederationAlreadyPaused" ;
-const char *certi::FederationNotPaused::_ex = "FederationNotPaused" ;
-const char *certi::AttributeNotSubscribed::_ex = "AttributeNotSubscribed" ;
-const char *certi::FederateAlreadyPaused::_ex = "FederateAlreadyPaused" ;
-const char *certi::FederateDoesNotExist::_ex = "FederateDoesNotExist" ;
-const char *certi::FederateNameAlreadyInUse::_ex = "FederateNameAlreadyInUse" ;
-const char *certi::FederateNotPaused::_ex = "FederateNotPaused" ;
-const char *certi::IDsupplyExhausted::_ex = "IDsupplyExhausted" ;
-const char *certi::InvalidDivestitureCondition::_ex = "InvalidDivestitureCondition" ;
-const char *certi::InvalidFederationTimeDelta::_ex = "InvalidFederationTimeDelta" ;
-const char *certi::InvalidRoutingSpace::_ex = "InvalidRoutingSpace" ;
-const char *certi::NoPauseRequested::_ex = "NoPauseRequested" ;
-const char *certi::NoResumeRequested::_ex = "NoResumeRequested" ;
-const char *certi::TooManyIDsRequested::_ex = "TooManyIDsRequested" ;
-const char *certi::UnimplementedService::_ex = "UnimplementedService" ;
-const char *certi::UnknownLabel::_ex = "UnknownLabel" ;
-const char *certi::NetworkError::_ex = "NetworkError" ;
-const char *certi::NetworkSignal::_ex = "NetworkSignal" ;
+long certi::ArrayIndexOutOfBounds::_type = certi::e_ArrayIndexOutOfBounds ;
+long certi::AsynchronousDeliveryAlreadyDisabled::_type = certi::e_AsynchronousDeliveryAlreadyDisabled ;
+long certi::AsynchronousDeliveryAlreadyEnabled::_type = certi::e_AsynchronousDeliveryAlreadyEnabled ;
+long certi::AttributeAcquisitionWasNotRequested::_type = certi::e_AttributeAcquisitionWasNotRequested ;
+long certi::AttributeAcquisitionWasNotCanceled::_type = certi::e_AttributeAcquisitionWasNotCanceled ;
+long certi::AttributeAlreadyBeingAcquired::_type = certi::e_AttributeAlreadyBeingAcquired ;
+long certi::AttributeAlreadyBeingDivested::_type = certi::e_AttributeAlreadyBeingDivested ;
+long certi::AttributeAlreadyOwned::_type = certi::e_AttributeAlreadyOwned ;
+long certi::AttributeDivestitureWasNotRequested::_type = certi::e_AttributeDivestitureWasNotRequested ;
+long certi::AttributeNotDefined::_type = certi::e_AttributeNotDefined ;
+long certi::AttributeNotKnown::_type = certi::e_AttributeNotKnown ;
+long certi::AttributeNotOwned::_type = certi::e_AttributeNotOwned ;
+long certi::AttributeNotPublished::_type = certi::e_AttributeNotPublished ;
+long certi::ConcurrentAccessAttempted::_type = certi::e_ConcurrentAccessAttempted ;
+long certi::CouldNotDiscover::_type = certi::e_CouldNotDiscover ;
+long certi::CouldNotOpenFED::_type = certi::e_CouldNotOpenFED ;
+long certi::CouldNotRestore::_type = certi::e_CouldNotRestore ;
+long certi::DeletePrivilegeNotHeld::_type = certi::e_DeletePrivilegeNotHeld ;
+long certi::DimensionNotDefined::_type = certi::e_DimensionNotDefined ;
+long certi::EnableTimeConstrainedPending::_type = certi::e_EnableTimeConstrainedPending ;
+long certi::EnableTimeConstrainedWasNotPending::_type = certi::e_EnableTimeConstrainedWasNotPending ;
+long certi::EnableTimeRegulationPending::_type = certi::e_EnableTimeRegulationPending ;
+long certi::EnableTimeRegulationWasNotPending::_type = certi::e_EnableTimeRegulationWasNotPending ;
+long certi::ErrorReadingFED::_type = certi::e_ErrorReadingFED ;
+long certi::EventNotKnown::_type = certi::e_EventNotKnown ;
+long certi::FederateAlreadyExecutionMember::_type = certi::e_FederateAlreadyExecutionMember ;
+long certi::FederateInternalError::_type = certi::e_FederateInternalError ;
+long certi::FederateLoggingServiceCalls::_type = certi::e_FederateLoggingServiceCalls ;
+long certi::FederateNotExecutionMember::_type = certi::e_FederateNotExecutionMember ;
+long certi::FederateOwnsAttributes::_type = certi::e_FederateOwnsAttributes ;
+long certi::FederateWasNotAskedToReleaseAttribute::_type = certi::e_FederateWasNotAskedToReleaseAttribute ;
+long certi::FederatesCurrentlyJoined::_type = certi::e_FederatesCurrentlyJoined ;
+long certi::FederationExecutionAlreadyExists::_type = certi::e_FederationExecutionAlreadyExists ;
+long certi::FederationExecutionDoesNotExist::_type = certi::e_FederationExecutionDoesNotExist ;
+long certi::FederationTimeAlreadyPassed::_type = certi::e_FederationTimeAlreadyPassed ;
+long certi::HandleValuePairMaximumExceeded::_type = certi::e_HandleValuePairMaximumExceeded ;
+long certi::InteractionClassNotDefined::_type = certi::e_InteractionClassNotDefined ;
+long certi::InteractionClassNotKnown::_type = certi::e_InteractionClassNotKnown ;
+long certi::InteractionClassNotPublished::_type = certi::e_InteractionClassNotPublished ;
+long certi::InteractionClassNotSubscribed::_type = certi::e_InteractionClassNotSubscribed ;
+long certi::InteractionParameterNotDefined::_type = certi::e_InteractionParameterNotDefined ;
+long certi::InteractionParameterNotKnown::_type = certi::e_InteractionParameterNotKnown ;
+long certi::InvalidExtents::_type = certi::e_InvalidExtents ;
+long certi::InvalidFederationTime::_type = certi::e_InvalidFederationTime ;
+long certi::InvalidHandleValuePairSetContext::_type = certi::e_InvalidHandleValuePairSetContext ;
+long certi::InvalidLookahead::_type = certi::e_InvalidLookahead ;
+long certi::InvalidOrderingHandle::_type = certi::e_InvalidOrderingHandle ;
+long certi::InvalidRegionContext::_type = certi::e_InvalidRegionContext ;
+long certi::InvalidResignAction::_type = certi::e_InvalidResignAction ;
+long certi::InvalidRetractionHandle::_type = certi::e_InvalidRetractionHandle ;
+long certi::InvalidTransportationHandle::_type = certi::e_InvalidTransportationHandle ;
+long certi::MemoryExhausted::_type = certi::e_MemoryExhausted ;
+long certi::NameNotFound::_type = certi::e_NameNotFound ;
+long certi::ObjectClassNotDefined::_type = certi::e_ObjectClassNotDefined ;
+long certi::ObjectClassNotKnown::_type = certi::e_ObjectClassNotKnown ;
+long certi::ObjectClassNotPublished::_type = certi::e_ObjectClassNotPublished ;
+long certi::ObjectClassNotSubscribed::_type = certi::e_ObjectClassNotSubscribed ;
+long certi::ObjectNotKnown::_type = certi::e_ObjectNotKnown ;
+long certi::ObjectAlreadyRegistered::_type = certi::e_ObjectAlreadyRegistered ;
+long certi::OwnershipAcquisitionPending::_type = certi::e_OwnershipAcquisitionPending ;
+long certi::RegionInUse::_type = certi::e_RegionInUse ;
+long certi::RegionNotKnown::_type = certi::e_RegionNotKnown ;
+long certi::RestoreInProgress::_type = certi::e_RestoreInProgress ;
+long certi::RestoreNotRequested::_type = certi::e_RestoreNotRequested ;
+long certi::RTIinternalError::_type = certi::e_RTIinternalError ;
+long certi::SpaceNotDefined::_type = certi::e_SpaceNotDefined ;
+long certi::SaveInProgress::_type = certi::e_SaveInProgress ;
+long certi::SaveNotInitiated::_type = certi::e_SaveNotInitiated ;
+long certi::SpecifiedSaveLabelDoesNotExist::_type = certi::e_SpecifiedSaveLabelDoesNotExist ;
+long certi::SynchronizationPointLabelWasNotAnnounced::_type = certi::e_SynchronizationPointLabelWasNotAnnounced ;
+long certi::TimeAdvanceAlreadyInProgress::_type = certi::e_TimeAdvanceAlreadyInProgress ;
+long certi::TimeAdvanceWasNotInProgress::_type = certi::e_TimeAdvanceWasNotInProgress ;
+long certi::TimeConstrainedAlreadyEnabled::_type = certi::e_TimeConstrainedAlreadyEnabled ;
+long certi::TimeConstrainedWasNotEnabled::_type = certi::e_TimeConstrainedWasNotEnabled ;
+long certi::TimeRegulationAlreadyEnabled::_type = certi::e_TimeRegulationAlreadyEnabled ;
+long certi::TimeRegulationWasNotEnabled::_type = certi::e_TimeRegulationWasNotEnabled ;
+long certi::UnableToPerformSave::_type = certi::e_UnableToPerformSave ;
+long certi::ValueCountExceeded::_type = certi::e_ValueCountExceeded ;
+long certi::ValueLengthExceeded::_type = certi::e_ValueLengthExceeded ;
 
 //  TypeException managing (how to obtain TypeException from Exception name ?)
-long certi::FederateNotPublishing::type = certi::e_FederateNotPublishing ;
-long certi::FederateNotSubscribing::type = certi::e_FederateNotSubscribing ;
-long certi::InvalidObjectHandle::type = certi::e_InvalidObjectHandle ;
-long certi::SecurityError::type = certi::e_SecurityError ;
-long certi::CouldNotOpenRID::type = certi::e_CouldNotOpenRID ;
-long certi::ErrorReadingRID::type = certi::e_ErrorReadingRID ;
-long certi::FederationAlreadyPaused::type = certi::e_FederationAlreadyPaused ;
-long certi::FederationNotPaused::type = certi::e_FederationNotPaused ;
-long certi::AttributeNotSubscribed::type = certi::e_AttributeNotSubscribed ;
-long certi::FederateAlreadyPaused::type = certi::e_FederateAlreadyPaused ;
-long certi::FederateDoesNotExist::type = certi::e_FederateDoesNotExist ;
-long certi::FederateNameAlreadyInUse::type = certi::e_FederateNameAlreadyInUse ;
-long certi::FederateNotPaused::type = certi::e_FederateNotPaused ;
-long certi::IDsupplyExhausted::type = certi::e_IDsupplyExhausted ;
-long certi::InvalidDivestitureCondition::type = certi::e_InvalidDivestitureCondition ;
-long certi::InvalidFederationTimeDelta::type = certi::e_InvalidFederationTimeDelta ;
-long certi::InvalidRoutingSpace::type = certi::e_InvalidRoutingSpace ;
-long certi::NoPauseRequested::type = certi::e_NoPauseRequested ;
-long certi::NoResumeRequested::type = certi::e_NoResumeRequested ;
-long certi::TooManyIDsRequested::type = certi::e_TooManyIDsRequested ;
-long certi::UnimplementedService::type = certi::e_UnimplementedService ;
-long certi::UnknownLabel::type = certi::e_UnknownLabel ;
-long certi::NetworkError::type = certi::e_NetworkError ;
-long certi::NetworkSignal::type = certi::e_NetworkSignal ;
+long certi::FederateNotPublishing::_type = certi::e_FederateNotPublishing ;
+long certi::FederateNotSubscribing::_type = certi::e_FederateNotSubscribing ;
+long certi::InvalidObjectHandle::_type = certi::e_InvalidObjectHandle ;
+long certi::CouldNotOpenRID::_type = certi::e_CouldNotOpenRID ;
+long certi::ErrorReadingRID::_type = certi::e_ErrorReadingRID ;
+long certi::AttributeNotSubscribed::_type = certi::e_AttributeNotSubscribed ;
+long certi::FederationAlreadyPaused::_type = certi::e_FederationAlreadyPaused ;
+long certi::FederationNotPaused::_type = certi::e_FederationNotPaused ;
+long certi::SecurityError::_type = certi::e_SecurityError ;
+long certi::FederateAlreadyPaused::_type = certi::e_FederateAlreadyPaused ;
+long certi::FederateDoesNotExist::_type = certi::e_FederateDoesNotExist ;
+long certi::FederateNameAlreadyInUse::_type = certi::e_FederateNameAlreadyInUse ;
+long certi::FederateNotPaused::_type = certi::e_FederateNotPaused ;
+long certi::IDsupplyExhausted::_type = certi::e_IDsupplyExhausted ;
+long certi::InvalidDivestitureCondition::_type = certi::e_InvalidDivestitureCondition ;
+long certi::InvalidFederationTimeDelta::_type = certi::e_InvalidFederationTimeDelta ;
+long certi::InvalidRoutingSpace::_type = certi::e_InvalidRoutingSpace ;
+long certi::NoPauseRequested::_type = certi::e_NoPauseRequested ;
+long certi::NoResumeRequested::_type = certi::e_NoResumeRequested ;
+long certi::TooManyIDsRequested::_type = certi::e_TooManyIDsRequested ;
+long certi::UnimplementedService::_type = certi::e_UnimplementedService ;
+long certi::UnknownLabel::_type = certi::e_UnknownLabel ;
+long certi::NetworkError::_type = certi::e_NetworkError ;
+long certi::NetworkSignal::_type = certi::e_NetworkSignal ;
 
 // $Id: Exception.cc,v 3.16 2008/11/25 16:32:14 gotthardp Exp $
diff --exclude=CVS -Nru certi/libCERTI/Exception.hh certi.new/libCERTI/Exception.hh
--- certi/libCERTI/Exception.hh	2008-10-28 13:07:26.000000000 +0100
+++ certi.new/libCERTI/Exception.hh	2008-12-05 17:37:51.000000000 +0100
@@ -26,7 +26,8 @@
 #ifndef _CERTI_EXCEPTION_HH
 #define _CERTI_EXCEPTION_HH
 
-#define MAX_EXCEPTION_REASON_LENGTH 256
+#include "certi.hh"
+#include <string>
 
 namespace certi {
 
@@ -138,6 +139,134 @@
     e_NetworkSignal
 } TypeException ;
 
+class CERTI_EXPORT Exception
+{
+public:
+    const std::string _reason;
+    const char *_name;
+
+    Exception(const std::string &reason)
+        : _reason(reason) { }
+    virtual ~Exception() { }
+
+    virtual long getType() const = 0;
+};
+
+#define CERTI_EXCEPTION(A) \
+    class CERTI_EXPORT A : public Exception { \
+    public: \
+        static long _type; \
+        A(const std::string &reason) : Exception(reason) { _name = #A; } \
+        long getType() const { return _type; } \
+};
+
+// RTI Exceptions for use inside libCERTI
+CERTI_EXCEPTION(ArrayIndexOutOfBounds)
+CERTI_EXCEPTION(AsynchronousDeliveryAlreadyDisabled)
+CERTI_EXCEPTION(AsynchronousDeliveryAlreadyEnabled)
+CERTI_EXCEPTION(AttributeAcquisitionWasNotRequested)
+CERTI_EXCEPTION(AttributeAcquisitionWasNotCanceled)
+CERTI_EXCEPTION(AttributeAlreadyBeingAcquired)
+CERTI_EXCEPTION(AttributeAlreadyBeingDivested)
+CERTI_EXCEPTION(AttributeAlreadyOwned)
+CERTI_EXCEPTION(AttributeDivestitureWasNotRequested)
+CERTI_EXCEPTION(AttributeNotDefined)
+CERTI_EXCEPTION(AttributeNotKnown)
+CERTI_EXCEPTION(AttributeNotOwned)
+CERTI_EXCEPTION(AttributeNotPublished)
+CERTI_EXCEPTION(ConcurrentAccessAttempted)
+CERTI_EXCEPTION(CouldNotDiscover)
+CERTI_EXCEPTION(CouldNotOpenFED)
+CERTI_EXCEPTION(CouldNotRestore)
+CERTI_EXCEPTION(DeletePrivilegeNotHeld)
+CERTI_EXCEPTION(DimensionNotDefined)
+CERTI_EXCEPTION(EnableTimeConstrainedPending)
+CERTI_EXCEPTION(EnableTimeConstrainedWasNotPending)
+CERTI_EXCEPTION(EnableTimeRegulationPending)
+CERTI_EXCEPTION(EnableTimeRegulationWasNotPending)
+CERTI_EXCEPTION(ErrorReadingFED)
+CERTI_EXCEPTION(EventNotKnown)
+CERTI_EXCEPTION(FederateAlreadyExecutionMember)
+CERTI_EXCEPTION(FederateInternalError)
+CERTI_EXCEPTION(FederateLoggingServiceCalls)
+CERTI_EXCEPTION(FederateNotExecutionMember)
+CERTI_EXCEPTION(FederateOwnsAttributes)
+CERTI_EXCEPTION(FederateWasNotAskedToReleaseAttribute)
+CERTI_EXCEPTION(FederatesCurrentlyJoined)
+CERTI_EXCEPTION(FederationExecutionAlreadyExists)
+CERTI_EXCEPTION(FederationExecutionDoesNotExist)
+CERTI_EXCEPTION(FederationTimeAlreadyPassed)
+CERTI_EXCEPTION(HandleValuePairMaximumExceeded)
+CERTI_EXCEPTION(InteractionClassNotDefined)
+CERTI_EXCEPTION(InteractionClassNotKnown)
+CERTI_EXCEPTION(InteractionClassNotPublished)
+CERTI_EXCEPTION(InteractionClassNotSubscribed)
+CERTI_EXCEPTION(InteractionParameterNotDefined)
+CERTI_EXCEPTION(InteractionParameterNotKnown)
+CERTI_EXCEPTION(InvalidExtents)
+CERTI_EXCEPTION(InvalidFederationTime)
+CERTI_EXCEPTION(InvalidHandleValuePairSetContext)
+CERTI_EXCEPTION(InvalidLookahead)
+CERTI_EXCEPTION(InvalidOrderingHandle)
+CERTI_EXCEPTION(InvalidRegionContext)
+CERTI_EXCEPTION(InvalidResignAction)
+CERTI_EXCEPTION(InvalidRetractionHandle)
+CERTI_EXCEPTION(InvalidTransportationHandle)
+CERTI_EXCEPTION(MemoryExhausted)
+CERTI_EXCEPTION(NameNotFound)
+CERTI_EXCEPTION(ObjectClassNotDefined)
+CERTI_EXCEPTION(ObjectClassNotKnown)
+CERTI_EXCEPTION(ObjectClassNotPublished)
+CERTI_EXCEPTION(ObjectClassNotSubscribed)
+CERTI_EXCEPTION(ObjectNotKnown)
+CERTI_EXCEPTION(ObjectAlreadyRegistered)
+CERTI_EXCEPTION(OwnershipAcquisitionPending)
+CERTI_EXCEPTION(RegionInUse)
+CERTI_EXCEPTION(RegionNotKnown)
+CERTI_EXCEPTION(RestoreInProgress)
+CERTI_EXCEPTION(RestoreNotRequested)
+CERTI_EXCEPTION(RTIinternalError)
+CERTI_EXCEPTION(SpaceNotDefined)
+CERTI_EXCEPTION(SaveInProgress)
+CERTI_EXCEPTION(SaveNotInitiated)
+CERTI_EXCEPTION(SpecifiedSaveLabelDoesNotExist)
+CERTI_EXCEPTION(SynchronizationPointLabelWasNotAnnounced)
+CERTI_EXCEPTION(TimeAdvanceAlreadyInProgress)
+CERTI_EXCEPTION(TimeAdvanceWasNotInProgress)
+CERTI_EXCEPTION(TimeConstrainedAlreadyEnabled)
+CERTI_EXCEPTION(TimeConstrainedWasNotEnabled)
+CERTI_EXCEPTION(TimeRegulationAlreadyEnabled)
+CERTI_EXCEPTION(TimeRegulationWasNotEnabled)
+CERTI_EXCEPTION(UnableToPerformSave)
+CERTI_EXCEPTION(ValueCountExceeded)
+CERTI_EXCEPTION(ValueLengthExceeded)
+
+// Additional CERTI exceptions
+CERTI_EXCEPTION(FederateNotPublishing)
+CERTI_EXCEPTION(FederateNotSubscribing)
+CERTI_EXCEPTION(InvalidObjectHandle)
+CERTI_EXCEPTION(SecurityError)
+CERTI_EXCEPTION(CouldNotOpenRID)
+CERTI_EXCEPTION(ErrorReadingRID)
+CERTI_EXCEPTION(FederationAlreadyPaused)
+CERTI_EXCEPTION(FederationNotPaused)
+CERTI_EXCEPTION(AttributeNotSubscribed)
+CERTI_EXCEPTION(FederateAlreadyPaused)
+CERTI_EXCEPTION(FederateDoesNotExist)
+CERTI_EXCEPTION(FederateNameAlreadyInUse)
+CERTI_EXCEPTION(FederateNotPaused)
+CERTI_EXCEPTION(IDsupplyExhausted)
+CERTI_EXCEPTION(InvalidDivestitureCondition)
+CERTI_EXCEPTION(InvalidFederationTimeDelta)
+CERTI_EXCEPTION(InvalidRoutingSpace)
+CERTI_EXCEPTION(NoPauseRequested)
+CERTI_EXCEPTION(NoResumeRequested)
+CERTI_EXCEPTION(TooManyIDsRequested)
+CERTI_EXCEPTION(UnimplementedService)
+CERTI_EXCEPTION(UnknownLabel)
+CERTI_EXCEPTION(NetworkSignal)
+CERTI_EXCEPTION(NetworkError)
+
 } // namespace certi
 
 #endif // _CERTI_EXCEPTION_HH
diff --exclude=CVS -Nru certi/libCERTI/Extent.hh certi.new/libCERTI/Extent.hh
--- certi/libCERTI/Extent.hh	2007-09-03 15:26:05.000000000 +0200
+++ certi.new/libCERTI/Extent.hh	2008-11-26 12:58:01.000000000 +0100
@@ -26,6 +26,7 @@
 #define CERTI_EXTENT_HH
 
 #include "certi.hh"
+#include "Exception.hh"
 
 #include <vector>
 #include <utility>
diff --exclude=CVS -Nru certi/libCERTI/FedRegion.hh certi.new/libCERTI/FedRegion.hh
--- certi/libCERTI/FedRegion.hh	2008-06-23 15:25:05.000000000 +0200
+++ certi.new/libCERTI/FedRegion.hh	2008-11-26 14:28:52.000000000 +0100
@@ -32,7 +32,7 @@
 
 class RoutingSpace ;
 
-class CERTI_EXPORT FedRegion : public BaseRegion, public RTI::Region
+class CERTI_EXPORT FedRegion : public BaseRegion
 {
 public:
     FedRegion(RegionHandle, SpaceHandle, const std::vector<Extent> &);
diff --exclude=CVS -Nru certi/libCERTI/GAV_aux.cc certi.new/libCERTI/GAV_aux.cc
--- certi/libCERTI/GAV_aux.cc	2008-11-25 17:32:14.000000000 +0100
+++ certi.new/libCERTI/GAV_aux.cc	2008-11-26 11:23:52.000000000 +0100
@@ -1,570 +0,0 @@
-// ----------------------------------------------------------------------------
-// CERTI - HLA RunTime Infrastructure
-// Copyright (C) 2002-2006  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.
-//
-// This program is distributed in the hope that it will be useful, but
-// WITHOUT ANY WARRANTY ; without even the implied warranty of
-// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-// Lesser General Public License for more details.
-//
-// 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
-// ----------------------------------------------------------------------------
-
-
-#include "GAV.hh"
-#include "PrettyDebug.hh"
-#include <string.h>
-
-#include <algorithm>
-#include <assert.h>
-
-using std::list ;
-
-using namespace certi ;
-
-// ----------------------------------------------------------------------------
-// AttributeHandleValuePair
-// ----------------------------------------------------------------------------
-
-namespace certi {
-
-// ----------------------------------------------------------------------------
-AttributeHandleValuePair::AttributeHandleValuePair(Handle handle,
-                                                   const char *value,
-                                                   ULong value_length)
-{
-    _handle = handle ;
-    _valueLength = value_length ;
-
-    _value = new char[value_length];
-    memcpy(_value, value, value_length);
-}
-
-// ----------------------------------------------------------------------------
-AttributeHandleValuePair::~AttributeHandleValuePair()
-{
-    delete[] _value ;
-}
-
-// ----------------------------------------------------------------------------
-// AttributeHandleValuePairSetImp
-// ----------------------------------------------------------------------------
-AttributeHandleValuePairSetImp::~AttributeHandleValuePairSetImp()
-{
-    empty();
-}
-
-// ----------------------------------------------------------------------------
-ULong
-AttributeHandleValuePairSetImp::size() const
-{
-    return list<AttributeHandleValuePair *>::size();
-}
-
-// ----------------------------------------------------------------------------
-Handle
-AttributeHandleValuePairSetImp::getHandle(ULong i) const
-    throw (ArrayIndexOutOfBounds)
-{
-    list<AttributeHandleValuePair *>::const_iterator j = begin();
-    for (ULong k = 0 ; j != end(); j++, k++) {
-        if (i == k)
-            return (*j)->_handle ;
-    }
-
-    throw ArrayIndexOutOfBounds("");
-}
-
-// ----------------------------------------------------------------------------
-ULong
-AttributeHandleValuePairSetImp::getValueLength(ULong i) const
-    throw (ArrayIndexOutOfBounds)
-{
-    list<AttributeHandleValuePair *>::const_iterator j = begin();
-    for (ULong k = 0 ; j != end(); j++, k++) {
-        if (i == k)
-            return (*j)->_valueLength ;
-    }
-
-    throw ArrayIndexOutOfBounds("");
-}
-
-// ----------------------------------------------------------------------------
-void
-AttributeHandleValuePairSetImp::getValue(ULong i,
-                                         char *buff,
-                                         ULong& value_length) const
-    throw (ArrayIndexOutOfBounds)
-{
-    list<AttributeHandleValuePair *>::const_iterator j = begin();
-    for (ULong k = 0 ; j != end(); j++, k++) {
-        if (i == k) {
-            value_length = (*j)->_valueLength ;
-            memcpy(buff, (*j)->_value, (*j)->_valueLength);
-            return ;
-        }
-    }
-
-    throw ArrayIndexOutOfBounds("");
-}
-
-// ----------------------------------------------------------------------------
-char *
-AttributeHandleValuePairSetImp::getValuePointer(ULong i,
-                                                ULong& value_length) const
-    throw (ArrayIndexOutOfBounds)
-{
-    list<AttributeHandleValuePair *>::const_iterator j = begin();
-    for (ULong k = 0 ; j != end(); j++, k++) {
-        if (i == k) {
-            value_length = (*j)->_valueLength ;
-            return (*j)->_value ;
-        }
-    }
-
-    throw ArrayIndexOutOfBounds("");
-}
-
-// ----------------------------------------------------------------------------
-TransportType
-AttributeHandleValuePairSetImp::getTransportType(ULong) const
-    throw (RTI::InvalidHandleValuePairSetContext)
-{
-    return _transport ;
-}
-
-// ----------------------------------------------------------------------------
-OrderType
-AttributeHandleValuePairSetImp::getOrderType(ULong) const
-    throw (ArrayIndexOutOfBounds, InvalidHandleValuePairSetContext)
-{
-    return _order ;
-}
-
-// ----------------------------------------------------------------------------
-RTI::Region *
-AttributeHandleValuePairSetImp::getRegion(ULong) const
-    throw (ArrayIndexOutOfBounds, InvalidHandleValuePairSetContext)
-{
-    throw RTIinternalError("Unimplemented service");
-}
-
-// ----------------------------------------------------------------------------
-void
-AttributeHandleValuePairSetImp::add(Handle h,
-                                    const char *buff,
-                                    ULong value_length)
-    throw (ValueLengthExceeded, ValueCountExceeded)
-{
-    AttributeHandleValuePair *ahvp ;
-    ahvp = new AttributeHandleValuePair(h, buff, value_length);
-
-    push_front(ahvp);
-}
-
-// ----------------------------------------------------------------------------
-void
-AttributeHandleValuePairSetImp::remove(Handle h)
-    throw (ArrayIndexOutOfBounds)
-{
-    list<AttributeHandleValuePair *>::iterator j ;
-    for (j = begin(); j != end(); j++) {
-        if ((*j)->_handle == h) {
-            delete (*j);
-            erase(j);
-            return ;
-        }
-    }
-
-    throw ArrayIndexOutOfBounds("");
-}
-
-// ----------------------------------------------------------------------------
-void
-AttributeHandleValuePairSetImp::moveFrom(const AttributeHandleValuePairSet&,
-                                         ULong&)
-    throw (ValueCountExceeded, ArrayIndexOutOfBounds)
-{
-    throw RTIinternalError("Unimplemented service");
-}
-
-// ----------------------------------------------------------------------------
-void
-AttributeHandleValuePairSetImp::empty()
-{
-    while (!list<AttributeHandleValuePair *>::empty()) {
-        delete front();
-        pop_front();
-    }
-}
-
-// ----------------------------------------------------------------------------
-ULong
-AttributeHandleValuePairSetImp::start() const
-{
-    //not implemented
-    return 0 ;
-}
-
-// ----------------------------------------------------------------------------
-ULong
-AttributeHandleValuePairSetImp::valid(ULong) const
-{
-    //not implemented
-    return 0 ;
-}
-
-// ----------------------------------------------------------------------------
-ULong
-AttributeHandleValuePairSetImp::next(ULong) const
-{
-    //not implemented
-    return 0 ;
-}
-
-// ----------------------------------------------------------------------------
-// AttributeHandleSetImp
-// ----------------------------------------------------------------------------
-AttributeHandleSetImp::~AttributeHandleSetImp()
-{
-    empty();
-}
-
-// ----------------------------------------------------------------------------
-inline ULong
-AttributeHandleSetImp::size() const
-{
-    return list<AttributeHandle>::size();
-}
-
-// ----------------------------------------------------------------------------
-AttributeHandle
-AttributeHandleSetImp::getHandle(ULong i) const
-    throw (ArrayIndexOutOfBounds)
-{
-    list<AttributeHandle>::const_iterator h ;
-    ULong j ;
-    for (j = 0, h = begin(); h != end(); h++, j++) {
-        if (i == j)
-            return (*h);
-    }
-
-    throw ArrayIndexOutOfBounds("");
-}
-
-// ----------------------------------------------------------------------------
-void
-AttributeHandleSetImp::add(AttributeHandle h)
-    throw (ArrayIndexOutOfBounds, AttributeNotDefined)
-{
-    push_front(h);
-}
-
-// ----------------------------------------------------------------------------
-void
-AttributeHandleSetImp::remove(AttributeHandle h)
-    throw (AttributeNotDefined)// not guaranteed safe while iterating
-{
-    if (isMember(h) == RTI::RTI_TRUE)
-        list<AttributeHandle>::remove(h);
-    else
-        throw AttributeNotDefined("");
-}
-
-// ----------------------------------------------------------------------------
-void
-AttributeHandleSetImp::empty()
-{
-    list<AttributeHandle>::clear();
-}
-
-// ----------------------------------------------------------------------------
-RTI::Boolean
-AttributeHandleSetImp::isEmpty() const
-{
-    return RTI::Boolean(list<AttributeHandle>::empty());
-}
-
-// ----------------------------------------------------------------------------
-RTI::Boolean
-AttributeHandleSetImp::isMember(AttributeHandle h) const
-{
-    return RTI::Boolean(find(begin(), end(), h) != end());
-}
-
-// ----------------------------------------------------------------------------
-// FederateHandleSetImp
-// ----------------------------------------------------------------------------
-FederateHandleSetImp::~FederateHandleSetImp()
-{
-    empty();
-}
-
-// ----------------------------------------------------------------------------
-inline ULong
-FederateHandleSetImp::size() const
-{
-    return list<FederateHandle>::size();
-}
-
-// ----------------------------------------------------------------------------
-FederateHandle
-FederateHandleSetImp::getHandle(ULong i) const
-    throw (ArrayIndexOutOfBounds)
-{
-    list<FederateHandle>::const_iterator h ;
-    ULong j ;
-    for (j = 0, h = begin(); h != end(); h++, j++) {
-        if (i == j)
-            return (*h);
-    }
-
-    throw ArrayIndexOutOfBounds("");
-}
-
-// ----------------------------------------------------------------------------
-void
-FederateHandleSetImp::add(FederateHandle h)
-    throw (ValueCountExceeded)
-{
-    push_front(h);
-}
-
-// ----------------------------------------------------------------------------
-void
-FederateHandleSetImp::remove(FederateHandle h)
-    throw (ArrayIndexOutOfBounds)
-{
-    if (isMember(h) == RTI::RTI_TRUE)
-        list<FederateHandle>::remove(h);
-    else
-        throw AttributeNotDefined("");
-}
-
-// ----------------------------------------------------------------------------
-void
-FederateHandleSetImp::empty()
-{
-    list<FederateHandle>::clear();
-}
-
-// ----------------------------------------------------------------------------
-RTI::Boolean
-FederateHandleSetImp::isMember(FederateHandle h) const
-{
-    return RTI::Boolean(find(begin(), end(), h) != end());
-}
-
-// ----------------------------------------------------------------------------
-// ParameterHandleValuePair
-// ----------------------------------------------------------------------------
-
-ParameterHandleValuePair::ParameterHandleValuePair(Handle handle,
-                                                   const char *value,
-                                                   ULong value_length)
-{
-    _handle = handle ;
-    _valueLength = value_length ;
-
-    _value = (char *) malloc(value_length);
-    memcpy(_value, value, value_length);
-}
-
-// ----------------------------------------------------------------------------
-ParameterHandleValuePair::~ParameterHandleValuePair()
-{
-    free(_value);
-}
-
-// ----------------------------------------------------------------------------
-// ParameterHandleValuePairSetImp
-// ----------------------------------------------------------------------------
-ParameterHandleValuePairSetImp::ParameterHandleValuePairSetImp(ULong)
-{
-    _order = RECEIVE ;
-    _transport = RELIABLE ;
-}
-
-ParameterHandleValuePairSetImp::~ParameterHandleValuePairSetImp()
-{
-    empty();
-}
-
-// ----------------------------------------------------------------------------
-ULong
-ParameterHandleValuePairSetImp::size() const
-{
-    return list<ParameterHandleValuePair *>::size();
-}
-
-// ----------------------------------------------------------------------------
-Handle
-ParameterHandleValuePairSetImp::getHandle(ULong i) const
-    throw (ArrayIndexOutOfBounds)
-{
-    list<ParameterHandleValuePair *>::const_iterator j = begin();
-    for (ULong k = 0 ; j != end(); j++, k++) {
-        if (i == k)
-            return (*j)->_handle ;
-    }
-
-    throw ArrayIndexOutOfBounds("");
-}
-
-// ----------------------------------------------------------------------------
-ULong
-ParameterHandleValuePairSetImp::getValueLength(ULong i) const
-    throw (ArrayIndexOutOfBounds)
-{
-    list<ParameterHandleValuePair *>::const_iterator j = begin();
-    for (ULong k = 0 ; j != end(); j++, k++) {
-        if (i == k)
-            return (*j)->_valueLength ;
-    }
-
-    throw ArrayIndexOutOfBounds("");
-}
-
-// ----------------------------------------------------------------------------
-void
-ParameterHandleValuePairSetImp::getValue(ULong i,
-                                         char *buff,
-                                         ULong& value_length) const
-    throw (ArrayIndexOutOfBounds)
-{
-    list<ParameterHandleValuePair *>::const_iterator j = begin();
-    for (ULong k = 0 ; j != end(); j++, k++) {
-        if (i == k) {
-            value_length = (*j)->_valueLength ;
-            memcpy(buff, (*j)->_value, (*j)->_valueLength);
-            return ;
-        }
-    }
-
-    throw ArrayIndexOutOfBounds("");
-}
-
-// ----------------------------------------------------------------------------
-char *
-ParameterHandleValuePairSetImp::getValuePointer(ULong i,
-                                                ULong& value_length) const
-    throw (ArrayIndexOutOfBounds)
-{
-    list<ParameterHandleValuePair *>::const_iterator j = begin();
-    for (ULong k = 0 ; j != end(); j++, k++) {
-        if (i == k) {
-            value_length = (*j)->_valueLength ;
-            return (*j)->_value ;
-        }
-    }
-
-    throw ArrayIndexOutOfBounds("");
-}
-
-// ----------------------------------------------------------------------------
-inline TransportType
-ParameterHandleValuePairSetImp::getTransportType() const
-    throw (InvalidHandleValuePairSetContext)
-{
-    return _transport ;
-}
-
-// ----------------------------------------------------------------------------
-inline OrderType
-ParameterHandleValuePairSetImp::getOrderType() const
-    throw (InvalidHandleValuePairSetContext)
-{
-    return _order ;
-}
-
-// ----------------------------------------------------------------------------
-RTI::Region *
-ParameterHandleValuePairSetImp::getRegion() const
-    throw (InvalidHandleValuePairSetContext)
-{
-    throw RTIinternalError("Unimplemented service");
-}
-
-// ----------------------------------------------------------------------------
-void
-ParameterHandleValuePairSetImp::add(Handle h,
-                                    const char *buff,
-                                    ULong value_length)
-    throw (ValueLengthExceeded, ValueCountExceeded)
-{
-    ParameterHandleValuePair *phvp ;
-    phvp = new ParameterHandleValuePair(h, buff, value_length);
-
-    push_front(phvp);
-}
-
-// ----------------------------------------------------------------------------
-void
-ParameterHandleValuePairSetImp::remove(Handle h)
-    throw (ArrayIndexOutOfBounds)
-{
-    list<ParameterHandleValuePair *>::iterator j ;
-    for (j = begin(); j != end(); j++) {
-        if ((*j)->_handle == h) {
-            delete (*j);
-            erase(j);
-            return ;
-        }
-    }
-
-    throw ArrayIndexOutOfBounds("");
-}
-
-// ----------------------------------------------------------------------------
-void
-ParameterHandleValuePairSetImp::moveFrom(const ParameterHandleValuePairSet&,
-                                         ULong&)
-    throw (ValueCountExceeded, ArrayIndexOutOfBounds)
-{
-    throw RTIinternalError("Unimplemented service");
-}
-
-// ----------------------------------------------------------------------------
-void
-ParameterHandleValuePairSetImp::empty()
-{
-    while (!list<ParameterHandleValuePair *>::empty()) {
-        delete front();
-        pop_front();
-    }
-}
-
-// ----------------------------------------------------------------------------
-ULong
-ParameterHandleValuePairSetImp::start() const
-{
-    //not implemented
-    return 0 ;
-}
-
-// ----------------------------------------------------------------------------
-ULong
-ParameterHandleValuePairSetImp::valid(ULong) const
-{
-    //not implemented
-    return 0 ;
-}
-
-// ----------------------------------------------------------------------------
-ULong
-ParameterHandleValuePairSetImp::next(ULong) const
-{
-    //not implemented
-    return 0 ;
-}
-
-} // namespace certi
-
-// $Id: GAV_aux.cc,v 3.18 2008/11/25 16:32:14 gotthardp Exp $
diff --exclude=CVS -Nru certi/libCERTI/GAV.cc certi.new/libCERTI/GAV.cc
--- certi/libCERTI/GAV.cc	2007-07-06 11:25:17.000000000 +0200
+++ certi.new/libCERTI/GAV.cc	2008-12-05 12:09:17.000000000 +0100
@@ -15,35 +15,571 @@
 // 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
+//
+// $Id: Dimension.cc,v 3.8 2008/06/12 07:39:49 erk Exp $
 // ----------------------------------------------------------------------------
-// $id
-
-
 
 #include "GAV.hh"
 #include "PrettyDebug.hh"
+#include <string.h>
 
 #include <algorithm>
 #include <assert.h>
 
+using std::list ;
+
+using namespace certi ;
+
+// ----------------------------------------------------------------------------
+// AttributeHandleValuePair
+// ----------------------------------------------------------------------------
+
 namespace certi {
 
 static pdCDebug D("GAV", "(gav) - ");
 
 // ----------------------------------------------------------------------------
-// CAttributeHandleValuePair deleted
+AttributeHandleValuePair::AttributeHandleValuePair(Handle handle,
+                                                   const char *value,
+                                                   ULong value_length)
+{
+    _handle = handle ;
+    _valueLength = value_length ;
+
+    _value = new char[value_length];
+    memcpy(_value, value, value_length);
+}
+
+// ----------------------------------------------------------------------------
+AttributeHandleValuePair::~AttributeHandleValuePair()
+{
+    delete[] _value ;
+}
+
+// ----------------------------------------------------------------------------
+// AttributeHandleValuePairSet
+// ----------------------------------------------------------------------------
+AttributeHandleValuePairSet::AttributeHandleValuePairSet(ULong)
+{
+    _order = RECEIVE ;
+    _transport = RELIABLE ;
+}
+
 // ----------------------------------------------------------------------------
+AttributeHandleValuePairSet::~AttributeHandleValuePairSet()
+{
+    empty();
+}
 
 // ----------------------------------------------------------------------------
-// CParameterHandleValuePair deleted
+ULong
+AttributeHandleValuePairSet::size() const
+{
+    return list<AttributeHandleValuePair *>::size();
+}
+
 // ----------------------------------------------------------------------------
+Handle
+AttributeHandleValuePairSet::getHandle(ULong i) const
+    throw (ArrayIndexOutOfBounds)
+{
+    list<AttributeHandleValuePair *>::const_iterator j = begin();
+    for (ULong k = 0 ; j != end(); j++, k++) {
+        if (i == k)
+            return (*j)->_handle ;
+    }
+
+    throw ArrayIndexOutOfBounds("");
+}
 
 // ----------------------------------------------------------------------------
-// CAttributeHandleValuePairSet deleted
+ULong
+AttributeHandleValuePairSet::getValueLength(ULong i) const
+    throw (ArrayIndexOutOfBounds)
+{
+    list<AttributeHandleValuePair *>::const_iterator j = begin();
+    for (ULong k = 0 ; j != end(); j++, k++) {
+        if (i == k)
+            return (*j)->_valueLength ;
+    }
+
+    throw ArrayIndexOutOfBounds("");
+}
+
+// ----------------------------------------------------------------------------
+void
+AttributeHandleValuePairSet::getValue(ULong i,
+                                         char *buff,
+                                         ULong& value_length) const
+    throw (ArrayIndexOutOfBounds)
+{
+    list<AttributeHandleValuePair *>::const_iterator j = begin();
+    for (ULong k = 0 ; j != end(); j++, k++) {
+        if (i == k) {
+            value_length = (*j)->_valueLength ;
+            memcpy(buff, (*j)->_value, (*j)->_valueLength);
+            return ;
+        }
+    }
+
+    throw ArrayIndexOutOfBounds("");
+}
+
+// ----------------------------------------------------------------------------
+char *
+AttributeHandleValuePairSet::getValuePointer(ULong i,
+                                                ULong& value_length) const
+    throw (ArrayIndexOutOfBounds)
+{
+    list<AttributeHandleValuePair *>::const_iterator j = begin();
+    for (ULong k = 0 ; j != end(); j++, k++) {
+        if (i == k) {
+            value_length = (*j)->_valueLength ;
+            return (*j)->_value ;
+        }
+    }
+
+    throw ArrayIndexOutOfBounds("");
+}
+
+// ----------------------------------------------------------------------------
+TransportType
+AttributeHandleValuePairSet::getTransportType(ULong) const
+    throw (InvalidHandleValuePairSetContext)
+{
+    return _transport ;
+}
+
+// ----------------------------------------------------------------------------
+OrderType
+AttributeHandleValuePairSet::getOrderType(ULong) const
+    throw (ArrayIndexOutOfBounds, InvalidHandleValuePairSetContext)
+{
+    return _order ;
+}
+
+// ----------------------------------------------------------------------------
+RTI::Region *
+AttributeHandleValuePairSet::getRegion(ULong) const
+    throw (ArrayIndexOutOfBounds, InvalidHandleValuePairSetContext)
+{
+    throw RTIinternalError("Unimplemented service");
+}
+
+// ----------------------------------------------------------------------------
+void
+AttributeHandleValuePairSet::add(Handle h,
+                                    const char *buff,
+                                    ULong value_length)
+    throw (ValueLengthExceeded, ValueCountExceeded)
+{
+    AttributeHandleValuePair *ahvp ;
+    ahvp = new AttributeHandleValuePair(h, buff, value_length);
+
+    push_front(ahvp);
+}
+
+// ----------------------------------------------------------------------------
+void
+AttributeHandleValuePairSet::remove(Handle h)
+    throw (ArrayIndexOutOfBounds)
+{
+    list<AttributeHandleValuePair *>::iterator j ;
+    for (j = begin(); j != end(); j++) {
+        if ((*j)->_handle == h) {
+            delete (*j);
+            erase(j);
+            return ;
+        }
+    }
+
+    throw ArrayIndexOutOfBounds("");
+}
+
+// ----------------------------------------------------------------------------
+void
+AttributeHandleValuePairSet::moveFrom(const AttributeHandleValuePairSet&,
+                                         ULong&)
+    throw (ValueCountExceeded, ArrayIndexOutOfBounds)
+{
+    throw RTIinternalError("Unimplemented service");
+}
+
+// ----------------------------------------------------------------------------
+void
+AttributeHandleValuePairSet::empty()
+{
+    while (!list<AttributeHandleValuePair *>::empty()) {
+        delete front();
+        pop_front();
+    }
+}
+
+// ----------------------------------------------------------------------------
+ULong
+AttributeHandleValuePairSet::start() const
+{
+    //not implemented
+    return 0 ;
+}
+
+// ----------------------------------------------------------------------------
+ULong
+AttributeHandleValuePairSet::valid(ULong) const
+{
+    //not implemented
+    return 0 ;
+}
+
+// ----------------------------------------------------------------------------
+ULong
+AttributeHandleValuePairSet::next(ULong) const
+{
+    //not implemented
+    return 0 ;
+}
+
+// ----------------------------------------------------------------------------
+// AttributeHandleSet
+// ----------------------------------------------------------------------------
+AttributeHandleSet::AttributeHandleSet(ULong size)
+{
+}
+
+AttributeHandleSet::~AttributeHandleSet()
+{
+    empty();
+}
+
+// ----------------------------------------------------------------------------
+inline ULong
+AttributeHandleSet::size() const
+{
+    return list<AttributeHandle>::size();
+}
+
+// ----------------------------------------------------------------------------
+AttributeHandle
+AttributeHandleSet::getHandle(ULong i) const
+    throw (ArrayIndexOutOfBounds)
+{
+    list<AttributeHandle>::const_iterator h ;
+    ULong j ;
+    for (j = 0, h = begin(); h != end(); h++, j++) {
+        if (i == j)
+            return (*h);
+    }
+
+    throw ArrayIndexOutOfBounds("");
+}
+
+// ----------------------------------------------------------------------------
+void
+AttributeHandleSet::add(AttributeHandle h)
+    throw (ArrayIndexOutOfBounds, AttributeNotDefined)
+{
+    push_front(h);
+}
+
+// ----------------------------------------------------------------------------
+void
+AttributeHandleSet::remove(AttributeHandle h)
+    throw (AttributeNotDefined)// not guaranteed safe while iterating
+{
+    if (isMember(h) == RTI::RTI_TRUE)
+        list<AttributeHandle>::remove(h);
+    else
+        throw AttributeNotDefined("");
+}
+
+// ----------------------------------------------------------------------------
+void
+AttributeHandleSet::empty()
+{
+    list<AttributeHandle>::clear();
+}
+
+// ----------------------------------------------------------------------------
+RTI::Boolean
+AttributeHandleSet::isEmpty() const
+{
+    return RTI::Boolean(list<AttributeHandle>::empty());
+}
+
 // ----------------------------------------------------------------------------
+RTI::Boolean
+AttributeHandleSet::isMember(AttributeHandle h) const
+{
+    return RTI::Boolean(find(begin(), end(), h) != end());
+}
 
 // ----------------------------------------------------------------------------
-// CParameterHandleValuePairSet deleted
+// FederateHandleSet
 // ----------------------------------------------------------------------------
+FederateHandleSet::~FederateHandleSet()
+{
+    empty();
+}
+
+// ----------------------------------------------------------------------------
+inline ULong
+FederateHandleSet::size() const
+{
+    return list<FederateHandle>::size();
+}
+
+// ----------------------------------------------------------------------------
+FederateHandle
+FederateHandleSet::getHandle(ULong i) const
+    throw (ArrayIndexOutOfBounds)
+{
+    list<FederateHandle>::const_iterator h ;
+    ULong j ;
+    for (j = 0, h = begin(); h != end(); h++, j++) {
+        if (i == j)
+            return (*h);
+    }
+
+    throw ArrayIndexOutOfBounds("");
+}
+
+// ----------------------------------------------------------------------------
+void
+FederateHandleSet::add(FederateHandle h)
+    throw (ValueCountExceeded)
+{
+    push_front(h);
+}
+
+// ----------------------------------------------------------------------------
+void
+FederateHandleSet::remove(FederateHandle h)
+    throw (ArrayIndexOutOfBounds)
+{
+    if (isMember(h) == RTI::RTI_TRUE)
+        list<FederateHandle>::remove(h);
+    else
+        throw AttributeNotDefined("");
+}
+
+// ----------------------------------------------------------------------------
+void
+FederateHandleSet::empty()
+{
+    list<FederateHandle>::clear();
+}
+
+// ----------------------------------------------------------------------------
+RTI::Boolean
+FederateHandleSet::isMember(FederateHandle h) const
+{
+    return RTI::Boolean(find(begin(), end(), h) != end());
+}
+
+// ----------------------------------------------------------------------------
+// ParameterHandleValuePair
+// ----------------------------------------------------------------------------
+
+ParameterHandleValuePair::ParameterHandleValuePair(Handle handle,
+                                                   const char *value,
+                                                   ULong value_length)
+{
+    _handle = handle ;
+    _valueLength = value_length ;
+
+    _value = (char *) malloc(value_length);
+    memcpy(_value, value, value_length);
+}
+
+// ----------------------------------------------------------------------------
+ParameterHandleValuePair::~ParameterHandleValuePair()
+{
+    free(_value);
+}
+
+// ----------------------------------------------------------------------------
+// ParameterHandleValuePairSet
+// ----------------------------------------------------------------------------
+ParameterHandleValuePairSet::ParameterHandleValuePairSet(ULong)
+{
+    _order = RECEIVE ;
+    _transport = RELIABLE ;
+}
+
+ParameterHandleValuePairSet::~ParameterHandleValuePairSet()
+{
+    empty();
+}
+
+// ----------------------------------------------------------------------------
+ULong
+ParameterHandleValuePairSet::size() const
+{
+    return list<ParameterHandleValuePair *>::size();
+}
+
+// ----------------------------------------------------------------------------
+Handle
+ParameterHandleValuePairSet::getHandle(ULong i) const
+    throw (ArrayIndexOutOfBounds)
+{
+    list<ParameterHandleValuePair *>::const_iterator j = begin();
+    for (ULong k = 0 ; j != end(); j++, k++) {
+        if (i == k)
+            return (*j)->_handle ;
+    }
+
+    throw ArrayIndexOutOfBounds("");
+}
+
+// ----------------------------------------------------------------------------
+ULong
+ParameterHandleValuePairSet::getValueLength(ULong i) const
+    throw (ArrayIndexOutOfBounds)
+{
+    list<ParameterHandleValuePair *>::const_iterator j = begin();
+    for (ULong k = 0 ; j != end(); j++, k++) {
+        if (i == k)
+            return (*j)->_valueLength ;
+    }
+
+    throw ArrayIndexOutOfBounds("");
+}
+
+// ----------------------------------------------------------------------------
+void
+ParameterHandleValuePairSet::getValue(ULong i,
+                                         char *buff,
+                                         ULong& value_length) const
+    throw (ArrayIndexOutOfBounds)
+{
+    list<ParameterHandleValuePair *>::const_iterator j = begin();
+    for (ULong k = 0 ; j != end(); j++, k++) {
+        if (i == k) {
+            value_length = (*j)->_valueLength ;
+            memcpy(buff, (*j)->_value, (*j)->_valueLength);
+            return ;
+        }
+    }
+
+    throw ArrayIndexOutOfBounds("");
+}
+
+// ----------------------------------------------------------------------------
+char *
+ParameterHandleValuePairSet::getValuePointer(ULong i,
+                                                ULong& value_length) const
+    throw (ArrayIndexOutOfBounds)
+{
+    list<ParameterHandleValuePair *>::const_iterator j = begin();
+    for (ULong k = 0 ; j != end(); j++, k++) {
+        if (i == k) {
+            value_length = (*j)->_valueLength ;
+            return (*j)->_value ;
+        }
+    }
+
+    throw ArrayIndexOutOfBounds("");
+}
+
+// ----------------------------------------------------------------------------
+inline TransportType
+ParameterHandleValuePairSet::getTransportType() const
+    throw (InvalidHandleValuePairSetContext)
+{
+    return _transport ;
+}
+
+// ----------------------------------------------------------------------------
+inline OrderType
+ParameterHandleValuePairSet::getOrderType() const
+    throw (InvalidHandleValuePairSetContext)
+{
+    return _order ;
+}
+
+// ----------------------------------------------------------------------------
+RTI::Region *
+ParameterHandleValuePairSet::getRegion() const
+    throw (InvalidHandleValuePairSetContext)
+{
+    throw RTIinternalError("Unimplemented service");
+}
+
+// ----------------------------------------------------------------------------
+void
+ParameterHandleValuePairSet::add(Handle h,
+                                    const char *buff,
+                                    ULong value_length)
+    throw (ValueLengthExceeded, ValueCountExceeded)
+{
+    ParameterHandleValuePair *phvp ;
+    phvp = new ParameterHandleValuePair(h, buff, value_length);
+
+    push_front(phvp);
+}
+
+// ----------------------------------------------------------------------------
+void
+ParameterHandleValuePairSet::remove(Handle h)
+    throw (ArrayIndexOutOfBounds)
+{
+    list<ParameterHandleValuePair *>::iterator j ;
+    for (j = begin(); j != end(); j++) {
+        if ((*j)->_handle == h) {
+            delete (*j);
+            erase(j);
+            return ;
+        }
+    }
+
+    throw ArrayIndexOutOfBounds("");
+}
+
+// ----------------------------------------------------------------------------
+void
+ParameterHandleValuePairSet::moveFrom(const ParameterHandleValuePairSet&,
+                                         ULong&)
+    throw (ValueCountExceeded, ArrayIndexOutOfBounds)
+{
+    throw RTIinternalError("Unimplemented service");
+}
+
+// ----------------------------------------------------------------------------
+void
+ParameterHandleValuePairSet::empty()
+{
+    while (!list<ParameterHandleValuePair *>::empty()) {
+        delete front();
+        pop_front();
+    }
+}
+
+// ----------------------------------------------------------------------------
+ULong
+ParameterHandleValuePairSet::start() const
+{
+    //not implemented
+    return 0 ;
+}
+
+// ----------------------------------------------------------------------------
+ULong
+ParameterHandleValuePairSet::valid(ULong) const
+{
+    //not implemented
+    return 0 ;
+}
+
+// ----------------------------------------------------------------------------
+ULong
+ParameterHandleValuePairSet::next(ULong) const
+{
+    //not implemented
+    return 0 ;
+}
 
 } // namespace certi
+
+// $Id: GAV.cc,v 3.18 2008/11/25 16:32:14 gotthardp Exp $
+
diff --exclude=CVS -Nru certi/libCERTI/GAV.hh certi.new/libCERTI/GAV.hh
--- certi/libCERTI/GAV.hh	2008-06-25 10:27:47.000000000 +0200
+++ certi.new/libCERTI/GAV.hh	2008-11-27 17:15:02.000000000 +0100
@@ -21,16 +21,18 @@
 #define CERTI_GAV_HH
 
 #include "certi.hh"
+#include "Exception.hh"
 
 #include <list>
 
 namespace certi {
 
-class AttributeHandleSetImp
-    : public std::list<AttributeHandle>, public AttributeHandleSet
+class AttributeHandleSet
+    : public std::list<AttributeHandle>
 {
 public:
-    virtual ~AttributeHandleSetImp();
+    AttributeHandleSet(ULong size);
+    virtual ~AttributeHandleSet();
 
     virtual ULong size() const ;
 
@@ -49,10 +51,11 @@
     virtual RTI::Boolean isMember(AttributeHandle h) const ;
 };
 
-class FederateHandleSetImp : public std::list<FederateHandle>, RTI::FederateHandleSet
+class FederateHandleSet : public std::list<FederateHandle>
 {
 public:
-    virtual ~FederateHandleSetImp();
+    FederateHandleSet(ULong size);
+    virtual ~FederateHandleSet();
 
     virtual ULong size() const ;
 
@@ -63,7 +66,7 @@
         throw (ValueCountExceeded);
 
     virtual void remove(FederateHandle h)
-        throw (RTI::ArrayIndexOutOfBounds);
+        throw (ArrayIndexOutOfBounds);
 
     virtual void empty();
 
@@ -86,8 +89,8 @@
     ~AttributeHandleValuePair();
 };
 
-class AttributeHandleValuePairSetImp
-    : public std::list<AttributeHandleValuePair *>, RTI::AttributeHandleValuePairSet
+class AttributeHandleValuePairSet
+    : public std::list<AttributeHandleValuePair *>
 {
     // ATTRIBUTES
 public:
@@ -96,7 +99,8 @@
 
     // METHODS
 public:
-    virtual ~AttributeHandleValuePairSetImp();
+    AttributeHandleValuePairSet(ULong size);
+    virtual ~AttributeHandleValuePairSet();
 
     virtual ULong size() const ;
     virtual Handle getHandle(ULong i) const throw (ArrayIndexOutOfBounds);
@@ -109,7 +113,7 @@
         throw (ArrayIndexOutOfBounds);
 
     virtual TransportType getTransportType(ULong i) const
-        throw (RTI::InvalidHandleValuePairSetContext);
+        throw (InvalidHandleValuePairSetContext);
 
     virtual OrderType getOrderType(ULong i) const
         throw (ArrayIndexOutOfBounds, InvalidHandleValuePairSetContext);
@@ -141,16 +145,16 @@
     ~ParameterHandleValuePair();
 };
 
-class ParameterHandleValuePairSetImp
-    : public std::list<ParameterHandleValuePair *>, public RTI::ParameterHandleValuePairSet
+class ParameterHandleValuePairSet
+    : public std::list<ParameterHandleValuePair *>
 {
 public:
     OrderType _order ;
     TransportType _transport ;
 
 public:
-    ParameterHandleValuePairSetImp(ULong size);
-    virtual ~ParameterHandleValuePairSetImp();
+    ParameterHandleValuePairSet(ULong size);
+    virtual ~ParameterHandleValuePairSet();
 
     virtual ULong size() const ;
 
diff --exclude=CVS -Nru certi/libCERTI/GSSAPIHandler.cc certi.new/libCERTI/GSSAPIHandler.cc
--- certi/libCERTI/GSSAPIHandler.cc	2007-07-06 11:25:17.000000000 +0200
+++ certi.new/libCERTI/GSSAPIHandler.cc	2008-11-26 10:27:03.000000000 +0100
@@ -24,10 +24,7 @@
 
 #ifdef WITH_GSSAPI
 
-
-
 #include "GSSAPIHandler.hh"
-#include "RTItypes.hh"
 #include "PrettyDebug.hh"
 #include "SocketTCP.hh"
 
diff --exclude=CVS -Nru certi/libCERTI/LBTS.cc certi.new/libCERTI/LBTS.cc
--- certi/libCERTI/LBTS.cc	2008-06-23 15:25:05.000000000 +0200
+++ certi.new/libCERTI/LBTS.cc	2008-11-26 14:33:03.000000000 +0100
@@ -25,6 +25,7 @@
 
 
 #include "LBTS.hh"
+#include "Exception.hh"
 #include "PrettyDebug.hh"
 
 #ifndef _WIN32
diff --exclude=CVS -Nru certi/libCERTI/MessageBuffer.cc certi.new/libCERTI/MessageBuffer.cc
--- certi/libCERTI/MessageBuffer.cc	2008-09-18 16:41:28.000000000 +0200
+++ certi.new/libCERTI/MessageBuffer.cc	2008-11-26 14:33:28.000000000 +0100
@@ -20,6 +20,7 @@
 // ----------------------------------------------------------------------------
 
 #include "MessageBuffer.hh"
+#include "Exception.hh"
 #include "PrettyDebug.hh"
 #include <cassert>
 #include <sstream>
diff --exclude=CVS -Nru certi/libCERTI/Message.cc certi.new/libCERTI/Message.cc
--- certi/libCERTI/Message.cc	2008-10-28 13:07:26.000000000 +0100
+++ certi.new/libCERTI/Message.cc	2008-12-05 18:34:52.000000000 +0100
@@ -23,7 +23,6 @@
 #include "Message.hh"
 #include "certi.hh"
 #include "PrettyDebug.hh"
-#include "GAV.hh"
 
 #include <stdlib.h>
 #include <cstdio>
@@ -272,13 +271,9 @@
 */
 void
 Message::setException(TypeException the_exception,
-                      const char *the_reason)
+                      const std::string& the_reason)
 {
     exception = the_exception ;
-
-    if (strlen(the_reason) > MAX_EXCEPTION_REASON_LENGTH)
-        throw ValueLengthExceeded("Exception reason too long to fit in"
-                                  " Message.");
     exceptionReason = the_reason;
 }
 
@@ -290,29 +285,22 @@
 }
 
 // ----------------------------------------------------------------------------
-AttributeHandleSet*
+const std::vector<AttributeHandle>&
 Message::getAHS() const
 {
-    AttributeHandleSet *attributeSet ;
-    attributeSet = RTI::AttributeHandleSetFactory::create(handleArraySize);
-
-    for (int i = 0 ; i < handleArraySize ; i++) {
-        attributeSet->add(handleArray[i]);
-    }
-
-    return attributeSet ;
+    return handleArray;
 }
 
 // ----------------------------------------------------------------------------
 void
-Message::setAHS(const AttributeHandleSet &the_attributes)
+Message::setAHS(const std::vector<AttributeHandle> &the_attributes)
 {
     G.Out(pdGendoc,"enter Message::setAHS");
     handleArraySize = the_attributes.size();
     handleArray.resize(handleArraySize);
 
     for (unsigned int i = 0 ; i < the_attributes.size(); ++i) {
-        handleArray[i] = the_attributes.getHandle(i);
+        handleArray[i] = the_attributes[i];
     }
     G.Out(pdGendoc,"exit  Message::setAHS");
 }
@@ -332,16 +320,18 @@
 }
 
 // ----------------------------------------------------------------------------
-RTI::AttributeHandleValuePairSet *
+std::vector<std::pair<AttributeHandle, AttributeValue_t> >
 Message::getAHVPS() const
 {
-    RTI::AttributeHandleValuePairSet *ahvps ;
-    ahvps = RTI::AttributeSetFactory::create(handleArraySize);
+    std::vector<std::pair<AttributeHandle, AttributeValue_t> > result;
+    result.resize(handleArraySize);
 
-    for (int i = 0 ; i < handleArraySize ; i++)
-        ahvps->add(handleArray[i], valueArray[i].data(), valueArray[i].length());
+    for (int i = 0 ; i < handleArraySize ; i++) {
+        result[i].first = handleArray[i];
+        result[i].second.assign(valueArray[i].data(), valueArray[i].length());
+    }
 
-    return ahvps ;
+    return result;
 }
 
 // ----------------------------------------------------------------------------
@@ -349,7 +339,7 @@
     @param the_attributes attribute set
 */
 void
-Message::setAHVPS(const RTI::AttributeHandleValuePairSet &the_attributes)
+Message::setAHVPS(const std::vector<std::pair<AttributeHandle, AttributeValue_t> > &the_attributes)
 {
     G.Out(pdGendoc,"enter Message::setAHVPS");
 
@@ -361,35 +351,30 @@
     valueArray.resize(size) ;
 
     for (unsigned long i = 0 ; i < size ; i++) {
-
-        // handle stored into handleArray[i]
-        handleArray[i] = the_attributes.getHandle(size-1-i);
-
-        // value stored into valueArray[i]
-        ULong length;
-        char *valueptr = the_attributes.getValuePointer(size-1-i, length);
-        valueArray[i].assign(valueptr, length);
-        // no free(valueptr), getValuePointer does not allocate memory
+        handleArray[i] = the_attributes[size-1-i].first;
+        valueArray[i] = the_attributes[size-1-i].second;
     }
     G.Out(pdGendoc,"exit  Message::setAHVPS");
 }
 
 // ----------------------------------------------------------------------------
-RTI::ParameterHandleValuePairSet *
+std::vector<std::pair<ParameterHandle, ParameterValue_t> >
 Message::getPHVPS() const
 {
-    ParameterHandleValuePairSetImp *phvps ;
-    phvps = new ParameterHandleValuePairSetImp(handleArraySize);
+    std::vector<std::pair<ParameterHandle, ParameterValue_t> > result;
+    result.resize(handleArraySize);
 
-    for (int i = 0 ; i < handleArraySize ; i++)
-        phvps->add(handleArray[i], valueArray[i].data(), valueArray[i].length());
+    for (int i = 0 ; i < handleArraySize ; i++) {
+        result[i].first = handleArray[i];
+        result[i].second.assign(valueArray[i].data(), valueArray[i].length());
+    }
 
-    return phvps ;
+    return result;
 }
 
 // ----------------------------------------------------------------------------
 void
-Message::setPHVPS(const RTI::ParameterHandleValuePairSet &the_parameters)
+Message::setPHVPS(const std::vector<std::pair<ParameterHandle, ParameterValue_t> > &the_parameters)
 {
     G.Out(pdGendoc,"enter Message::setPHVPS");
 
@@ -401,15 +386,8 @@
     valueArray.resize(size) ;
 
     for (unsigned long i = 0 ; i < size ; i++) {
-
-        // handle stored into handleArray[i]
-        handleArray[i] = the_parameters.getHandle(size-1-i);
-
-        // value stored into valueArray[i]
-        ULong length;
-        char *valueptr = the_parameters.getValuePointer(size-1-i, length);
-        valueArray[i].assign(valueptr, length);
-        // no free(valueptr), getValuePointer does not allocate memory
+        handleArray[i] = the_parameters[size-1-i].first;
+        valueArray[i] = the_parameters[size-1-i].second;
     }
     G.Out(pdGendoc,"exit  Message::setPHVPS");
 }
@@ -441,9 +419,7 @@
     valueArray.resize(the_size) ;
 
     for (int i = 0 ; i < the_size ; i++) {
-        // attributes into handleArray
         handleArray[i] = the_attributes[i] ;
-        // values into valueArray
         valueArray[i] = the_values[i] ;
     }
     G.Out(pdGendoc,"exit  Message::setAttributes");
@@ -464,9 +440,7 @@
     valueArray.resize(the_size) ;
 
     for (int i = 0 ; i < the_size ; i++) {
-        // parameters into handleArray
         handleArray[i] = the_parameters[i] ;
-        // values into valueArray
         valueArray[i] = the_values[i] ;
     }
 }
@@ -599,7 +573,7 @@
         printf("NO_EXCEPTION ");
     else
         printf(" exception=%d: ",exception);
-    printf(" reason=%s: ",((exceptionReason.c_str()==NULL)?"empty":exceptionReason.c_str()));
+    printf(" reason=%s: ",(exceptionReason.empty()?"empty":exceptionReason.c_str()));
     printf(" objectClass=%ld: ", objectClass);
     printf(" interactionClass=%ld:\n", interactionClass);
     printf(" attribute=%ld:\n", attribute);
diff --exclude=CVS -Nru certi/libCERTI/Message.hh certi.new/libCERTI/Message.hh
--- certi/libCERTI/Message.hh	2008-11-06 15:28:58.000000000 +0100
+++ certi.new/libCERTI/Message.hh	2008-12-05 17:36:34.000000000 +0100
@@ -25,6 +25,7 @@
 #include "Exception.hh"
 #include "SocketUN.hh"
 #include "BasicMessage.hh"
+#include "GAV.hh"
 #include "fedtime.hh"
 
 #include <vector>
@@ -333,7 +334,7 @@
 
     void setFederationTime(FederationTime);
     FederationTime getFederationTime() const { return fed_time.getTime(); };
-    
+
     void setBoolean(bool);
     bool getBoolean() const { return boolean ; };
 
@@ -350,7 +351,6 @@
 
     void setEventRetraction(EventRetractionHandle);
     EventRetractionHandle getEventRetraction() const
-
     { return eventRetraction ; };
 
     void setParameter(ParameterHandle);
@@ -359,21 +359,21 @@
     void setFederate(FederateHandle);
     FederateHandle getFederate() const { return federate ; };
 
-    AttributeHandleSet* getAHS() const ;
-    void setAHS(const AttributeHandleSet &);
+    const std::vector<AttributeHandle>& getAHS() const ;
+    void setAHS(const std::vector<AttributeHandle> &);
     void setAHS(const AttributeHandle *, int);
 
-    RTI::AttributeHandleValuePairSet* getAHVPS() const ;
-    void setAHVPS(const RTI::AttributeHandleValuePairSet &);
+    std::vector<std::pair<AttributeHandle, AttributeValue_t> > getAHVPS() const ;
+    void setAHVPS(const std::vector<std::pair<AttributeHandle, AttributeValue_t> > &);
 
-    RTI::ParameterHandleValuePairSet* getPHVPS() const ;
-    void setPHVPS(const RTI::ParameterHandleValuePairSet &);
+    std::vector<std::pair<ParameterHandle, ParameterValue_t> > getPHVPS() const ;
+    void setPHVPS(const std::vector<std::pair<ParameterHandle, ParameterValue_t> > &);
 
     void setAttributes(std::vector <AttributeHandle> &, ushort);
     void setAttributes(std::vector <AttributeHandle> &, std::vector <AttributeValue_t> &, ushort);
     void setParameters(std::vector <ParameterHandle> &, std::vector <ParameterValue_t> &, ushort);
 
-    void setException(TypeException, const char *the_reason = "\0");
+    void setException(TypeException, const std::string& the_reason = "");
     TypeException getExceptionType() const { return exception ; };
     const char *getExceptionReason() const { return exceptionReason.c_str() ; };
 
@@ -387,7 +387,6 @@
 
 protected:
     TypeException exception ;
-    //char exceptionReason[MAX_EXCEPTION_REASON_LENGTH + 1] ;
     std::string exceptionReason;
 
     RTIfedTime fed_time;
diff --exclude=CVS -Nru certi/libCERTI/ObjectAttribute.hh certi.new/libCERTI/ObjectAttribute.hh
--- certi/libCERTI/ObjectAttribute.hh	2007-06-22 10:51:38.000000000 +0200
+++ certi.new/libCERTI/ObjectAttribute.hh	2008-11-26 14:29:24.000000000 +0100
@@ -26,6 +26,7 @@
 #define CERTI_OBJECT_ATTRIBUTE_HH
 
 #include "certi.hh"
+#include "Exception.hh"
 
 #include <list>
 
diff --exclude=CVS -Nru certi/libCERTI/ObjectClass.cc certi.new/libCERTI/ObjectClass.cc
--- certi/libCERTI/ObjectClass.cc	2008-11-08 12:36:05.000000000 +0100
+++ certi.new/libCERTI/ObjectClass.cc	2008-11-26 14:29:51.000000000 +0100
@@ -1603,7 +1603,7 @@
     if (server != NULL) {
         CDiffusion *diffusionAcquisition = new CDiffusion();
 
-        theAttribute = RTI::AttributeHandleSetFactory::create(the_size);
+        theAttribute = new AttributeHandleSet(the_size);
 
         ObjectClassAttribute * oca ;
         for (int i = 0 ; i < the_size ; i++) {
diff --exclude=CVS -Nru certi/libCERTI/ObjectClass.hh certi.new/libCERTI/ObjectClass.hh
--- certi/libCERTI/ObjectClass.hh	2008-11-08 12:08:03.000000000 +0100
+++ certi.new/libCERTI/ObjectClass.hh	2008-11-26 14:28:10.000000000 +0100
@@ -39,6 +39,7 @@
 #include "certi.hh"
 #include "SecurityServer.hh"
 #include "Named.hh"
+#include "GAV.hh"
 
 // Standard
 #include <list>
diff --exclude=CVS -Nru certi/libCERTI/Object.hh certi.new/libCERTI/Object.hh
--- certi/libCERTI/Object.hh	2008-09-18 19:13:32.000000000 +0200
+++ certi.new/libCERTI/Object.hh	2008-11-26 11:49:22.000000000 +0100
@@ -34,6 +34,7 @@
 #include "certi.hh"
 #include "Named.hh"
 #include "Handled.hh"
+#include "Exception.hh"
 
 #include <deque>
 #include <list>
diff --exclude=CVS -Nru certi/libCERTI/ObjectSet.hh certi.new/libCERTI/ObjectSet.hh
--- certi/libCERTI/ObjectSet.hh	2008-06-10 15:41:47.000000000 +0200
+++ certi.new/libCERTI/ObjectSet.hh	2008-11-26 14:30:13.000000000 +0100
@@ -28,6 +28,7 @@
 class Object;
 #include "SecurityServer.hh"
 #include "MessageBuffer.hh"
+#include "GAV.hh"
 #include "certi.hh"
 
 // Standard
diff --exclude=CVS -Nru certi/libCERTI/RTItypes.cc certi.new/libCERTI/RTItypes.cc
--- certi/libCERTI/RTItypes.cc	1970-01-01 01:00:00.000000000 +0100
+++ certi.new/libCERTI/RTItypes.cc	2008-11-26 14:16:16.000000000 +0100
@@ -0,0 +1,274 @@
+// ----------------------------------------------------------------------------
+// CERTI - HLA RunTime Infrastructure
+// Copyright (C) 2002-2006  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.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY ; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// 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
+// ----------------------------------------------------------------------------
+
+#include "GAV.hh"
+#include "Exception.hh"
+#include "PrettyDebug.hh"
+#include <assert.h>
+#include <sstream>
+#include <cstdlib>
+#include <cstring>
+
+using namespace certi ;
+
+namespace {
+
+static PrettyDebug D("LIBRTI", __FILE__);
+static PrettyDebug G("GENDOC",__FILE__);
+
+}
+
+// static members for HLA Exceptions
+const char *RTI::ArrayIndexOutOfBounds::_ex = "ArrayIndexOutOfBounds" ;
+const char *RTI::AsynchronousDeliveryAlreadyDisabled::_ex = "AsynchronousDeliveryAlreadyDisabled" ;
+const char *RTI::AsynchronousDeliveryAlreadyEnabled::_ex = "AsynchronousDeliveryAlreadyEnabled" ;
+const char *RTI::AttributeAcquisitionWasNotRequested::_ex = "AttributeAcquisitionWasNotRequested" ;
+const char *RTI::AttributeAcquisitionWasNotCanceled::_ex = "AttributeAcquisitionWasNotCanceled" ;
+const char *RTI::AttributeAlreadyBeingAcquired::_ex = "AttributeAlreadyBeingAcquired" ;
+const char *RTI::AttributeAlreadyBeingDivested::_ex = "AttributeAlreadyBeingDivested" ;
+const char *RTI::AttributeAlreadyOwned::_ex = "AttributeAlreadyOwned" ;
+const char *RTI::AttributeDivestitureWasNotRequested::_ex = "AttributeDivestitureWasNotRequested" ;
+const char *RTI::AttributeNotDefined::_ex = "AttributeNotDefined" ;
+const char *RTI::AttributeNotKnown::_ex = "AttributeNotKnown" ;
+const char *RTI::AttributeNotOwned::_ex = "AttributeNotOwned" ;
+const char *RTI::AttributeNotPublished::_ex = "AttributeNotPublished" ;
+const char *RTI::ConcurrentAccessAttempted::_ex = "ConcurrentAccessAttempted" ;
+const char *RTI::CouldNotDiscover::_ex = "CouldNotDiscover" ;
+const char *RTI::CouldNotOpenFED::_ex = "CouldNotOpenFED" ;
+const char *RTI::CouldNotRestore::_ex = "CouldNotRestore" ;
+const char *RTI::DeletePrivilegeNotHeld::_ex = "DeletePrivilegeNotHeld" ;
+const char *RTI::DimensionNotDefined::_ex = "DimensionNotDefined" ;
+const char *RTI::EnableTimeConstrainedPending::_ex = "EnableTimeConstrainedPending" ;
+const char *RTI::EnableTimeConstrainedWasNotPending::_ex = "EnableTimeConstrainedWasNotPending" ;
+const char *RTI::EnableTimeRegulationPending::_ex = "EnableTimeRegulationPending" ;
+const char *RTI::EnableTimeRegulationWasNotPending::_ex = "EnableTimeRegulationWasNotPending" ;
+const char *RTI::ErrorReadingFED::_ex = "ErrorReadingFED" ;
+const char *RTI::EventNotKnown::_ex = "EventNotKnown" ;
+const char *RTI::FederateAlreadyExecutionMember::_ex = "FederateAlreadyExecutionMember" ;
+const char *RTI::FederateInternalError::_ex = "FederateInternalError" ;
+const char *RTI::FederateLoggingServiceCalls::_ex = "FederateLoggingServiceCalls" ;
+const char *RTI::FederateNotExecutionMember::_ex = "FederateNotExecutionMember" ;
+const char *RTI::FederateOwnsAttributes::_ex = "FederateOwnsAttributes" ;
+const char *RTI::FederateWasNotAskedToReleaseAttribute::_ex = "FederateWasNotAskedToReleaseAttribute" ;
+const char *RTI::FederatesCurrentlyJoined::_ex = "FederatesCurrentlyJoined" ;
+const char *RTI::FederationExecutionAlreadyExists::_ex = "FederationExecutionAlreadyExists" ;
+const char *RTI::FederationExecutionDoesNotExist::_ex = "FederationExecutionDoesNotExist" ;
+const char *RTI::FederationTimeAlreadyPassed::_ex = "FederationTimeAlreadyPassed" ;
+const char *RTI::HandleValuePairMaximumExceeded::_ex = "HandleValuePairMaximumExceeded" ;
+const char *RTI::InteractionClassNotDefined::_ex = "InteractionClassNotDefined" ;
+const char *RTI::InteractionClassNotKnown::_ex = "InteractionClassNotKnown" ;
+const char *RTI::InteractionClassNotPublished::_ex = "InteractionClassNotPublished" ;
+const char *RTI::InteractionClassNotSubscribed::_ex = "InteractionClassNotSubscribed" ;
+const char *RTI::InteractionParameterNotDefined::_ex = "InteractionParameterNotDefined" ;
+const char *RTI::InteractionParameterNotKnown::_ex = "InteractionParameterNotKnown" ;
+const char *RTI::InvalidExtents::_ex = "InvalidExtents" ;
+const char *RTI::InvalidFederationTime::_ex = "InvalidFederationTime" ;
+const char *RTI::InvalidHandleValuePairSetContext::_ex = "InvalidHandleValuePairSetContext" ;
+const char *RTI::InvalidLookahead::_ex = "InvalidLookahead" ;
+const char *RTI::InvalidOrderingHandle::_ex = "InvalidOrderingHandle" ;
+const char *RTI::InvalidRegionContext::_ex = "InvalidRegionContext" ;
+const char *RTI::InvalidResignAction::_ex = "InvalidResignAction" ;
+const char *RTI::InvalidRetractionHandle::_ex = "InvalidRetractionHandle" ;
+const char *RTI::InvalidTransportationHandle::_ex = "InvalidTransportationHandle" ;
+const char *RTI::MemoryExhausted::_ex = "MemoryExhausted" ;
+const char *RTI::NameNotFound::_ex = "NameNotFound" ;
+const char *RTI::ObjectClassNotDefined::_ex = "ObjectClassNotDefined" ;
+const char *RTI::ObjectClassNotKnown::_ex = "ObjectClassNotKnown" ;
+const char *RTI::ObjectClassNotPublished::_ex = "ObjectClassNotPublished" ;
+const char *RTI::ObjectClassNotSubscribed::_ex = "ObjectClassNotSubscribed" ;
+const char *RTI::ObjectNotKnown::_ex = "ObjectNotKnown" ;
+const char *RTI::ObjectAlreadyRegistered::_ex = "ObjectAlreadyRegistered" ;
+const char *RTI::OwnershipAcquisitionPending::_ex = "OwnershipAcquisitionPending" ;
+const char *RTI::RegionInUse::_ex = "RegionInUse" ;
+const char *RTI::RegionNotKnown::_ex = "RegionNotKnown" ;
+const char *RTI::RestoreInProgress::_ex = "RestoreInProgress" ;
+const char *RTI::RestoreNotRequested::_ex = "RestoreNotRequested" ;
+const char *RTI::RTIinternalError::_ex = "RTIinternalError" ;
+const char *RTI::SpaceNotDefined::_ex = "SpaceNotDefined" ;
+const char *RTI::SaveInProgress::_ex = "SaveInProgress" ;
+const char *RTI::SaveNotInitiated::_ex = "SaveNotInitiated" ;
+const char *RTI::SpecifiedSaveLabelDoesNotExist::_ex = "SpecifiedSaveLabelDoesNotExist" ;
+const char *RTI::SynchronizationPointLabelWasNotAnnounced::_ex = "SynchronizationPointLabelWasNotAnnounced" ;
+const char *RTI::TimeAdvanceAlreadyInProgress::_ex = "TimeAdvanceAlreadyInProgress" ;
+const char *RTI::TimeAdvanceWasNotInProgress::_ex = "TimeAdvanceWasNotInProgress" ;
+const char *RTI::TimeConstrainedAlreadyEnabled::_ex = "TimeConstrainedAlreadyEnabled" ;
+const char *RTI::TimeConstrainedWasNotEnabled::_ex = "TimeConstrainedWasNotEnabled" ;
+const char *RTI::TimeRegulationAlreadyEnabled::_ex = "TimeRegulationAlreadyEnabled" ;
+const char *RTI::TimeRegulationWasNotEnabled::_ex = "TimeRegulationWasNotEnabled" ;
+const char *RTI::UnableToPerformSave::_ex = "UnableToPerformSave" ;
+const char *RTI::ValueCountExceeded::_ex = "ValueCountExceeded" ;
+const char *RTI::ValueLengthExceeded::_ex = "ValueLengthExceeded" ;
+
+// TypeException managing (how to obtain TypeException from Exception name ?)
+long RTI::ArrayIndexOutOfBounds::type = certi::e_ArrayIndexOutOfBounds ;
+long RTI::AsynchronousDeliveryAlreadyDisabled::type = certi::e_AsynchronousDeliveryAlreadyDisabled ;
+long RTI::AsynchronousDeliveryAlreadyEnabled::type = certi::e_AsynchronousDeliveryAlreadyEnabled ;
+long RTI::AttributeAcquisitionWasNotRequested::type = certi::e_AttributeAcquisitionWasNotRequested ;
+long RTI::AttributeAcquisitionWasNotCanceled::type = certi::e_AttributeAcquisitionWasNotCanceled ;
+long RTI::AttributeAlreadyBeingAcquired::type = certi::e_AttributeAlreadyBeingAcquired ;
+long RTI::AttributeAlreadyBeingDivested::type = certi::e_AttributeAlreadyBeingDivested ;
+long RTI::AttributeAlreadyOwned::type = certi::e_AttributeAlreadyOwned ;
+long RTI::AttributeDivestitureWasNotRequested::type = certi::e_AttributeDivestitureWasNotRequested ;
+long RTI::AttributeNotDefined::type = certi::e_AttributeNotDefined ;
+long RTI::AttributeNotKnown::type = certi::e_AttributeNotKnown ;
+long RTI::AttributeNotOwned::type = certi::e_AttributeNotOwned ;
+long RTI::AttributeNotPublished::type = certi::e_AttributeNotPublished ;
+long RTI::ConcurrentAccessAttempted::type = certi::e_ConcurrentAccessAttempted ;
+long RTI::CouldNotDiscover::type = certi::e_CouldNotDiscover ;
+long RTI::CouldNotOpenFED::type = certi::e_CouldNotOpenFED ;
+long RTI::CouldNotRestore::type = certi::e_CouldNotRestore ;
+long RTI::DeletePrivilegeNotHeld::type = certi::e_DeletePrivilegeNotHeld ;
+long RTI::DimensionNotDefined::type = certi::e_DimensionNotDefined ;
+long RTI::EnableTimeConstrainedPending::type = certi::e_EnableTimeConstrainedPending ;
+long RTI::EnableTimeConstrainedWasNotPending::type = certi::e_EnableTimeConstrainedWasNotPending ;
+long RTI::EnableTimeRegulationPending::type = certi::e_EnableTimeRegulationPending ;
+long RTI::EnableTimeRegulationWasNotPending::type = certi::e_EnableTimeRegulationWasNotPending ;
+long RTI::ErrorReadingFED::type = certi::e_ErrorReadingFED ;
+long RTI::EventNotKnown::type = certi::e_EventNotKnown ;
+long RTI::FederateAlreadyExecutionMember::type = certi::e_FederateAlreadyExecutionMember ;
+long RTI::FederateInternalError::type = certi::e_FederateInternalError ;
+long RTI::FederateLoggingServiceCalls::type = certi::e_FederateLoggingServiceCalls ;
+long RTI::FederateNotExecutionMember::type = certi::e_FederateNotExecutionMember ;
+long RTI::FederateOwnsAttributes::type = certi::e_FederateOwnsAttributes ;
+long RTI::FederateWasNotAskedToReleaseAttribute::type = certi::e_FederateWasNotAskedToReleaseAttribute ;
+long RTI::FederatesCurrentlyJoined::type = certi::e_FederatesCurrentlyJoined ;
+long RTI::FederationExecutionAlreadyExists::type = certi::e_FederationExecutionAlreadyExists ;
+long RTI::FederationExecutionDoesNotExist::type = certi::e_FederationExecutionDoesNotExist ;
+long RTI::FederationTimeAlreadyPassed::type = certi::e_FederationTimeAlreadyPassed ;
+long RTI::HandleValuePairMaximumExceeded::type = certi::e_HandleValuePairMaximumExceeded ;
+long RTI::InteractionClassNotDefined::type = certi::e_InteractionClassNotDefined ;
+long RTI::InteractionClassNotKnown::type = certi::e_InteractionClassNotKnown ;
+long RTI::InteractionClassNotPublished::type = certi::e_InteractionClassNotPublished ;
+long RTI::InteractionClassNotSubscribed::type = certi::e_InteractionClassNotSubscribed ;
+long RTI::InteractionParameterNotDefined::type = certi::e_InteractionParameterNotDefined ;
+long RTI::InteractionParameterNotKnown::type = certi::e_InteractionParameterNotKnown ;
+long RTI::InvalidExtents::type = certi::e_InvalidExtents ;
+long RTI::InvalidFederationTime::type = certi::e_InvalidFederationTime ;
+long RTI::InvalidHandleValuePairSetContext::type = certi::e_InvalidHandleValuePairSetContext ;
+long RTI::InvalidLookahead::type = certi::e_InvalidLookahead ;
+long RTI::InvalidOrderingHandle::type = certi::e_InvalidOrderingHandle ;
+long RTI::InvalidRegionContext::type = certi::e_InvalidRegionContext ;
+long RTI::InvalidResignAction::type = certi::e_InvalidResignAction ;
+long RTI::InvalidRetractionHandle::type = certi::e_InvalidRetractionHandle ;
+long RTI::InvalidTransportationHandle::type = certi::e_InvalidTransportationHandle ;
+long RTI::MemoryExhausted::type = certi::e_MemoryExhausted ;
+long RTI::NameNotFound::type = certi::e_NameNotFound ;
+long RTI::ObjectClassNotDefined::type = certi::e_ObjectClassNotDefined ;
+long RTI::ObjectClassNotKnown::type = certi::e_ObjectClassNotKnown ;
+long RTI::ObjectClassNotPublished::type = certi::e_ObjectClassNotPublished ;
+long RTI::ObjectClassNotSubscribed::type = certi::e_ObjectClassNotSubscribed ;
+long RTI::ObjectNotKnown::type = certi::e_ObjectNotKnown ;
+long RTI::ObjectAlreadyRegistered::type = certi::e_ObjectAlreadyRegistered ;
+long RTI::OwnershipAcquisitionPending::type = certi::e_OwnershipAcquisitionPending ;
+long RTI::RegionInUse::type = certi::e_RegionInUse ;
+long RTI::RegionNotKnown::type = certi::e_RegionNotKnown ;
+long RTI::RestoreInProgress::type = certi::e_RestoreInProgress ;
+long RTI::RestoreNotRequested::type = certi::e_RestoreNotRequested ;
+long RTI::RTIinternalError::type = certi::e_RTIinternalError ;
+long RTI::SpaceNotDefined::type = certi::e_SpaceNotDefined ;
+long RTI::SaveInProgress::type = certi::e_SaveInProgress ;
+long RTI::SaveNotInitiated::type = certi::e_SaveNotInitiated ;
+long RTI::SpecifiedSaveLabelDoesNotExist::type = certi::e_SpecifiedSaveLabelDoesNotExist ;
+long RTI::SynchronizationPointLabelWasNotAnnounced::type = certi::e_SynchronizationPointLabelWasNotAnnounced ;
+long RTI::TimeAdvanceAlreadyInProgress::type = certi::e_TimeAdvanceAlreadyInProgress ;
+long RTI::TimeAdvanceWasNotInProgress::type = certi::e_TimeAdvanceWasNotInProgress ;
+long RTI::TimeConstrainedAlreadyEnabled::type = certi::e_TimeConstrainedAlreadyEnabled ;
+long RTI::TimeConstrainedWasNotEnabled::type = certi::e_TimeConstrainedWasNotEnabled ;
+long RTI::TimeRegulationAlreadyEnabled::type = certi::e_TimeRegulationAlreadyEnabled ;
+long RTI::TimeRegulationWasNotEnabled::type = certi::e_TimeRegulationWasNotEnabled ;
+long RTI::UnableToPerformSave::type = certi::e_UnableToPerformSave ;
+long RTI::ValueCountExceeded::type = certi::e_ValueCountExceeded ;
+long RTI::ValueLengthExceeded::type = certi::e_ValueLengthExceeded ;
+
+static PrettyDebug PD_Exception("RTI_EXCEPTION",__FILE__);
+
+RTI::Exception::~Exception()
+{
+    if (NULL!=_reason) {
+        free(_reason);
+    }
+}
+
+RTI::Exception::Exception(const char *reason)
+{
+    _reason = (reason == NULL)?NULL:strdup(reason);
+    _serial = 0 ;
+}
+
+RTI::Exception::Exception(ULong serial, const char *reason)
+{
+    _serial = serial ;
+    _reason = (reason == NULL)?NULL:strdup(reason);
+}
+
+
+RTI::Exception::Exception(const Exception &toCopy)
+{
+    _serial = toCopy._serial ;
+    _reason = ( toCopy._reason== NULL)?NULL:strdup(toCopy._reason) ;
+    _name = toCopy._name ;
+}
+
+RTI::Exception& RTI::Exception::operator=(const Exception &toCopy)
+{
+    _serial = toCopy._serial ;
+    _reason = (toCopy._reason == NULL)?NULL:strdup(toCopy._reason) ;
+    _name = toCopy._name ;
+    return *this ;
+}
+
+const std::string RTI::Exception::displayMe() const
+{
+    std::stringstream msg;
+
+    msg << "RTI::Exception [";
+    if (NULL!=_name) {
+        msg <<_name;
+    } else {
+        msg<<"<noname>";
+    }
+    msg <<",0x"<<std::hex<<_serial<<"]";
+    msg << " - reason=";
+    if (NULL !=_reason) {
+        msg << _reason;
+    } else {
+        msg << "<noreason>";
+    }
+    msg << std::endl;
+    msg << std::flush;
+
+    PD_Exception[pdExcept] << msg.str().c_str();
+    return msg.str();
+}
+
+RTI_STD::ostream &
+operator<<(RTI_STD::ostream &os, RTI::Exception const &ex)
+{
+    // FIXME
+    return os << ex.displayMe();
+}
+
+RTI_STD::ostream &
+operator<<(RTI_STD::ostream &os, RTI::Exception *ex)
+{
+    assert(ex);
+    return os<<(*ex);
+}
+
+// $Id: RTItypes.cc,v 1.1 2008/11/25 16:32:14 gotthardp Exp $
diff --exclude=CVS -Nru certi/libCERTI/SecurityLevel.hh certi.new/libCERTI/SecurityLevel.hh
--- certi/libCERTI/SecurityLevel.hh	2008-06-24 14:23:31.000000000 +0200
+++ certi.new/libCERTI/SecurityLevel.hh	2008-11-26 12:57:16.000000000 +0100
@@ -26,6 +26,7 @@
 #define _CERTI_SECURITY_LEVEL_HH
 
 #include "certi.hh"
+#include "Exception.hh"
 
 #include <stdlib.h>
 #include <string.h>
diff --exclude=CVS -Nru certi/libCERTI/Socket.hh certi.new/libCERTI/Socket.hh
--- certi/libCERTI/Socket.hh	2008-10-13 13:27:51.000000000 +0200
+++ certi.new/libCERTI/Socket.hh	2008-11-26 11:53:58.000000000 +0100
@@ -21,6 +21,7 @@
 #define CERTI_SOCKET_HH
 
 #include "certi.hh"
+#include "Exception.hh"
 #ifndef _WIN32
 	#include <sys/time.h>
 	#include <sys/types.h>
diff --exclude=CVS -Nru certi/libCERTI/SocketTCP.cc certi.new/libCERTI/SocketTCP.cc
--- certi/libCERTI/SocketTCP.cc	2008-10-12 13:46:41.000000000 +0200
+++ certi.new/libCERTI/SocketTCP.cc	2008-11-26 15:10:28.000000000 +0100
@@ -32,7 +32,6 @@
 
 #include "SocketTCP.hh"
 #include "PrettyDebug.hh"
-#include "baseTypes.hh"
 
 #include <cassert>
 #include <cerrno>
@@ -59,11 +58,11 @@
 if (winsockInits > 0)
 	{
 	winsockInits++;
-	return RTI_TRUE;
-	} 
+	return true;
+	}
 else if (winsockInits <0)
 	{
-	return RTI_FALSE;
+	return false;
 	}
 
 wVersionRequested = MAKEWORD( 2, 0 );
@@ -71,18 +70,18 @@
 if (lError != 0)
 	{
 	winsockInits = -1;
-	return RTI_FALSE;
+	return false;
 	}
 
 if (LOBYTE( wsaData.wVersion ) != 2 || HIBYTE( wsaData.wVersion ) != 0)
-	{// Tell the user that we couldn't find a usable WinSock DLL.    
+	{// Tell the user that we couldn't find a usable WinSock DLL.
 	WSACleanup( );
 	winsockInits = -1;
-	return RTI_FALSE; 
+	return false;
 	}
 
 winsockInits = 1;
-return RTI_TRUE;
+return true;
 }
 
 void SocketTCP::winsockShutdown()
@@ -156,7 +155,7 @@
 // Set the TCP_NODELAY option(Client Side)
 
 TCPent = getprotobyname("tcp");
-if (TCPent == NULL) 
+if (TCPent == NULL)
 	{
 	cout << "Unable to retrieve TCP protocol number." << endl ;
 	return 0 ;
@@ -166,7 +165,7 @@
 				TCPent->p_proto,
 				TCP_NODELAY,
 				(char *) &optval,
-				sizeof(optval))) 
+				sizeof(optval)))
 	{
 	cout << "Error while calling setsockopt." << endl ;
 	return 0 ;
@@ -197,16 +196,16 @@
 l = sizeof(_sockIn);
 
 _socket_tcp = ::accept(serveur->_socket_tcp, (sockaddr*)&_sockIn, &l);
-if (_socket_tcp < 0) 
+if (_socket_tcp < 0)
 	{
 	  msg << "SocketTCP: Accept Failed"
-	      << "<" << strerror(errno) <<">"; 
-	  throw NetworkError(msg.str().c_str());	
+	      << "<" << strerror(errno) <<">";
+	  throw NetworkError(msg.str().c_str());
 	}
 
 // Set the TCP_NODELAY option(Server Side)
 TCPent = getprotobyname("tcp");
-if (TCPent == NULL) 
+if (TCPent == NULL)
 	{
 	cout << "Unable to retrieve TCP protocol number." << endl ;
 	return 0 ;
@@ -216,7 +215,7 @@
 					TCPent->p_proto,
 					TCP_NODELAY,
 					(char *) &optval,
-					sizeof(optval))) 
+					sizeof(optval)))
 	{
 	cout << "Error while calling setsockopt." << endl ;
 	return 0 ;
@@ -287,25 +286,25 @@
 
 // ----------------------------------------------------------------------------
 void
-SocketTCP::createTCPClient(in_port_t port, in_addr_t addr) 
+SocketTCP::createTCPClient(in_port_t port, in_addr_t addr)
 throw (NetworkError)
 {
 assert(!_est_init_tcp);
 std::stringstream msg;
-if (!open()) 
+if (!open())
 	{
-		msg << "Cannot open port <" << port 
+		msg << "Cannot open port <" << port
 			<< "> on addr <" << addr2string(addr)
 			<< "> : error =" << strerror(errno);
 		throw NetworkError(msg.str().c_str());
 	}
 
-if (!connect(port, addr)) 
+if (!connect(port, addr))
 	{
-		msg << "Cannot connect port <" << port 
+		msg << "Cannot connect port <" << port
 		    << "> on addr <" << addr2string(addr)
 			<< "> : error =" << strerror(errno);
-		throw NetworkError(msg.str().c_str());	
+		throw NetworkError(msg.str().c_str());
 	}
 
 _est_init_tcp = true ;
@@ -320,25 +319,25 @@
 	assert(!_est_init_tcp);
 
 
-if (!open()) 
+if (!open())
 	{
-	msg << "Cannot open port <" << port 
+	msg << "Cannot open port <" << port
 		<< "> on addr <" << addr2string(addr)
 		<< "> : error =" << strerror(errno);
 	throw NetworkError(msg.str().c_str());
 	}
 
-if (!bind(port, addr)) 
+if (!bind(port, addr))
 	{
-	msg << "Cannot bind port <" << port 
+	msg << "Cannot bind port <" << port
 		<< "> on addr <" << addr2string(addr)
 		<< "> : error =" << strerror(errno);
 	throw NetworkError(msg.str().c_str());
 	}
 
-if (!listen(MAX_BACKLOG)) 
+if (!listen(MAX_BACKLOG))
 	{
-	msg << "Cannot listen port <" << port 
+	msg << "Cannot listen port <" << port
 		<< "> on addr <" << addr2string(addr)
 		<< "> : error =" << strerror(errno);
 	throw NetworkError(msg.str().c_str());
@@ -360,7 +359,7 @@
 
 D.Out(pdDebug, "Beginning to send TCP message...");
 
-while (total_sent < expected_size) 
+while (total_sent < expected_size)
 	{
 	#ifdef _WIN32
 		int sent = ::send(_socket_tcp, (char*) buffer + total_sent, expected_size - total_sent, 0);
@@ -368,7 +367,7 @@
 		int sent = ::send(_socket_tcp, buffer + total_sent, expected_size - total_sent, 0);
 	#endif
 
-	if (sent < 0) 
+	if (sent < 0)
 		{
 		D.Out(pdExcept, "Error while sending on TCP socket.");
 
@@ -378,14 +377,14 @@
 			if(errno == EINTR)
 		#endif
 			throw NetworkSignal("");
-		else 
+		else
 			{
 			perror("TCP Socket(EmettreTCP) ");
 			throw NetworkError("Error while sending TCP message.");
 			}
 		}
 
-	if (sent == 0) 
+	if (sent == 0)
 		{
 		D.Out(pdExcept, "No data could be sent, connection closed?.");
 		throw NetworkError("Could not send any data on TCP socket.");
@@ -402,7 +401,7 @@
 void
 SocketTCP::close()
 {
-if (_est_init_tcp) 
+if (_est_init_tcp)
 	{
 	#ifdef _WIN32
 		::closesocket(_socket_tcp);
@@ -501,7 +500,7 @@
 							0);
 	#endif
 
-	if (nReceived < 0) 
+	if (nReceived < 0)
 		{
 		D.Out(pdExcept, "Error while receiving on TCP socket.");
 		#ifdef _WIN32
@@ -510,14 +509,14 @@
 			if(errno == EINTR)
 		#endif
 			throw NetworkSignal("");
-		else 
+		else
 			{
 			perror("TCP Socket(RecevoirTCP) ");
 			throw NetworkError("Error while receiving TCP message.");
 			}
 		}
 
-	if (nReceived == 0) 
+	if (nReceived == 0)
 		{
 		D.Out(pdExcept, "TCP connection has been closed by peer.");
 		throw NetworkError("Connection closed by client.");
@@ -570,7 +569,7 @@
 {
 assert(_est_init_tcp);
 
-struct timeval time_out ;    
+struct timeval time_out ;
 time_out.tv_sec = sec ;
 time_out.tv_usec = usec ;
 
@@ -580,7 +579,7 @@
 
 int nb = select(_socket_tcp+1, &fdset, NULL, NULL, &time_out);
 
-if (nb < 0) 
+if (nb < 0)
 	{
 	#ifdef _WIN32
 		 if(WSAGetLastError() == WSAEINTR)
@@ -591,7 +590,7 @@
 	else
 		throw NetworkError("Select gave negative return value");
 	}
-else 
+else
 	return nb > 0 ;
 }
 
diff --exclude=CVS -Nru certi/libCERTI/SocketUN.cc certi.new/libCERTI/SocketUN.cc
--- certi/libCERTI/SocketUN.cc	2008-10-11 14:53:53.000000000 +0200
+++ certi.new/libCERTI/SocketUN.cc	2008-11-26 15:09:41.000000000 +0100
@@ -18,10 +18,8 @@
 // ----------------------------------------------------------------------------
 
 
-
 #include "certi.hh"
 #include "SocketUN.hh"
-#include "baseTypes.hh"
 
 #if defined(RTIA_USE_TCP)
 	#include "SocketTCP.hh"
@@ -67,7 +65,7 @@
 #else
 	socklen_t socklen;
 #endif
-	
+
 	if((sock_connect=socket(AF_INET,SOCK_STREAM,0)) < 0)
 		error("socket");
 
@@ -79,11 +77,11 @@
 	// TEMPO : UNIX socket emulation with TCP/IP sockets
 	int tcpport;
 	if (RTIA_port>0) {
-		tcpport = RTIA_port; 
+		tcpport = RTIA_port;
 	} else {
 	    tcpport = getpid();
 	}
-	
+
 	// make sure it is contained in a short
 	if (tcpport > 65535)
 		throw RTIinternalError("TCP Port too big.");
@@ -171,7 +169,7 @@
 
 #if defined(RTIA_USE_TCP)
 	struct sockaddr_in nom_serveur;
-	int lg_nom;	
+	int lg_nom;
 #ifdef _WIN32
 	struct hostent *hptr = NULL;
 	assert(SocketTCP::winsockInitialized());
@@ -184,10 +182,10 @@
 sprintf( buffer, "%s.%d", NOM_FICHIER_SOCKET, Server_pid ) ;
 name = buffer ;
 
-while (Attempt < MAX_ATTEMPTS) 
+while (Attempt < MAX_ATTEMPTS)
 	{
 	pD->Out(pdInit, "Opening Client UNIX Socket.");
-	
+
 // TCP Socket case--------------------------------------------------
 #if defined(RTIA_USE_TCP)
 	if((_socket_un = socket(AF_INET, SOCK_STREAM, 0)) == -1)
@@ -207,7 +205,7 @@
 
 	lg_nom = sizeof(nom_serveur);
 	Result = ::connect(_socket_un,(sockaddr *)&nom_serveur, lg_nom);
-	
+
 	//pD->Out(pdInit, "Client: Connect returned %d.", Result);
 #else
 	if ((_socket_un = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
@@ -271,11 +269,11 @@
 //! Close the socket.
 SocketUN::~SocketUN()
 {
-if (_est_init_un) 
+if (_est_init_un)
 	{
 	#ifdef _WIN32
 		closesocket(_socket_un);
-		if(_est_serveur == RTI_TRUE)
+		if (_est_serveur)
 			closesocket(sock_connect);
 	#else
 		close(_socket_un);
@@ -283,7 +281,7 @@
 			close(sock_connect);
 		unlink(name.c_str());
 	#endif
-	
+
 	if (_est_serveur)
 		pD->Out(pdTerm, "Server: Closed all sockets.");
 	else
@@ -317,7 +315,7 @@
 
 pD->Out(pdTrace, "Beginning to send UN message...");
 
-while (total_sent < size) 
+while (total_sent < size)
 	{
 	#ifdef _WIN32
 		sent = ::send(_socket_un, (char *) buffer + total_sent, size - total_sent, 0);
@@ -325,17 +323,17 @@
 		sent = write(_socket_un, (char *) buffer + total_sent, size - total_sent);
 	#endif
 
-	if (sent > 0) 
+	if (sent > 0)
 		{
 		total_sent += sent ;
 		pD->Out(pdTrace, "Sent %ld bytes out of %ld.", total_sent, size);
 		}
-	else 
+	else
 		{
-		if (sent < 0) 
+		if (sent < 0)
 			{
 			pD->Out(pdExcept, "Error while sending on UN socket.");
-			
+
 			#ifdef _WIN32
 				if(WSAGetLastError() == WSAEINTR)
 			#else
@@ -344,14 +342,14 @@
 				{// Incoming Signal
 				if (HandlerType == stSignalInterrupt) throw NetworkSignal("");
 				else pD->Out(pdExcept, "EmettreUN ignoring signal interruption.");
-				}		
+				}
 			else // Other errors
 				{
 				perror("UN Socket(EmettreUN) : ");
 					throw NetworkError("Error while sending UN message.");
 			}	}
-			
-		if (sent == 0) 
+
+		if (sent == 0)
 			{
 			pD->Out(pdExcept, "No data could be sent, connection closed?.");
 			throw NetworkError("Could not send any data on UN socket.");
@@ -370,7 +368,7 @@
 
  smsg << "SocketUN::error <"
  	  << strerror(errno)
- 	  << "> msg = <" 	  
+ 	  << "> msg = <"
  	  << msg <<">";
  throw NetworkError(smsg.str().c_str());
 }
@@ -417,7 +415,7 @@
 
 pD->Out(pdTrace, "Beginning to receive U/W message...(Size  %ld)",Size);
 
-while (RBLength < Size) 
+while (RBLength < Size)
 	{
 	#ifdef _WIN32
 		#ifdef SOCKUN_BUFFER_LENGTH
@@ -442,7 +440,7 @@
 	if (nReceived < 0)
 		{
 		pD->Out(pdExcept, "Error while receiving on UN socket.");
-	
+
 		#ifdef _WIN32
 			if(WSAGetLastError() == WSAEINTR)
 		#else
@@ -454,19 +452,19 @@
 			else
 				pD->Out(pdExcept, "RecevoirUN ignoring signal interruption.");
 			}
-		else 
+		else
 			{// Other errors
 			perror("UN Socket(RecevoirUN) : ");
 			throw NetworkError("Error while receiving UN message.");
 			}
 		}
 
-	if (nReceived == 0) 
+	if (nReceived == 0)
 		{
 		pD->Out(pdExcept, "UN connection has been closed by peer.");
 		throw NetworkError("Connection closed by client.");
 		}
-	else if (nReceived > 0) 
+	else if (nReceived > 0)
 		{
 		RBLength += nReceived ;
 		RcvdBytesCount += nReceived ;
diff --exclude=CVS -Nru certi/libRTI/CMakeLists.txt certi.new/libRTI/CMakeLists.txt
--- certi/libRTI/CMakeLists.txt	2008-11-25 17:32:14.000000000 +0100
+++ certi.new/libRTI/CMakeLists.txt	2008-12-05 12:35:47.000000000 +0100
@@ -5,6 +5,7 @@
   RTIambassador.cc
   RTIambPrivateRefs.cc
   RTItypes.cc
+  HandleSets.cc
   )
   
 SET(RTI_LIB_INCLUDE
@@ -19,17 +20,18 @@
 
 #SOURCE_GROUP("RTI\\Header" FILES ${RTI_LIB_INCLUDE})
 
-ADD_LIBRARY(RTI-NG ${RTI_LIB_SRCS} ${RTI_LIB_INCLUDE})
-TARGET_LINK_LIBRARIES(RTI-NG CERTI)
+ADD_LIBRARY(RTI ${RTI_LIB_SRCS} ${RTI_LIB_INCLUDE})
+TARGET_LINK_LIBRARIES(RTI CERTI)
 
-SET_TARGET_PROPERTIES(RTI-NG PROPERTIES VERSION 1.0.0 SOVERSION 1)
+SET_TARGET_PROPERTIES(RTI PROPERTIES OUTPUT_NAME "RTI-NG")
+SET_TARGET_PROPERTIES(RTI PROPERTIES VERSION 1.0.0 SOVERSION 1)
 IF (MINGW)
-    SET_TARGET_PROPERTIES(RTI-NG PROPERTIES LINK_FLAGS "-Wl,--output-def,${LIBRARY_OUTPUT_PATH}/libRTI.def")
+    SET_TARGET_PROPERTIES(RTI PROPERTIES LINK_FLAGS "-Wl,--output-def,${LIBRARY_OUTPUT_PATH}/libRTI.def")
     INSTALL(FILES ${LIBRARY_OUTPUT_PATH}/libRTI.def
             DESTINATION lib)
 ENDIF (MINGW)
 
-INSTALL(TARGETS RTI-NG
+INSTALL(TARGETS RTI
     RUNTIME DESTINATION bin
     LIBRARY DESTINATION lib
     ARCHIVE DESTINATION lib)
diff --exclude=CVS -Nru certi/libRTI/HandleSets.cc certi.new/libRTI/HandleSets.cc
--- certi/libRTI/HandleSets.cc	1970-01-01 01:00:00.000000000 +0100
+++ certi.new/libRTI/HandleSets.cc	2008-12-05 17:05:19.000000000 +0100
@@ -0,0 +1,540 @@
+// ----------------------------------------------------------------------------
+// CERTI - HLA RunTime Infrastructure
+// Copyright (C) 2002-2006  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.
+//
+// This program is distributed in the hope that it will be useful, but
+// WITHOUT ANY WARRANTY ; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+// Lesser General Public License for more details.
+//
+// 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
+// ----------------------------------------------------------------------------
+
+#include "certi.hh"
+
+#include "HandleSets.hh"
+#include "GAV.hh"
+#include "PrettyDebug.hh"
+
+#include <algorithm>
+#include <string.h>
+
+using namespace certi ;
+
+namespace {
+
+static PrettyDebug D("LIBRTI", __FILE__);
+static PrettyDebug G("GENDOC",__FILE__);
+
+}
+
+// ----------------------------------------------------------------------------
+AttributeHandleValuePairSetImp::AttributeHandleValuePairSetImp(ULong size)
+{
+    _order = RECEIVE;
+    _transport = RELIABLE;
+
+    std::vector<AttributeHandleValuePair_t>::reserve(size);
+}
+
+AttributeHandleValuePairSetImp::AttributeHandleValuePairSetImp(const std::vector<AttributeHandleValuePair_t> &val)
+    : std::vector<AttributeHandleValuePair_t>(val)
+{
+    _order = RECEIVE;
+    _transport = RELIABLE;
+}
+
+AttributeHandleValuePairSetImp::~AttributeHandleValuePairSetImp()
+{
+}
+
+ULong AttributeHandleValuePairSetImp::size() const
+{
+    return std::vector<AttributeHandleValuePair_t>::size();
+}
+
+Handle AttributeHandleValuePairSetImp::getHandle(ULong i) const
+    throw (RTI::ArrayIndexOutOfBounds)
+{
+    if (i < size())
+        return operator[](i).first;
+    else
+        throw RTI::ArrayIndexOutOfBounds("");
+}
+
+ULong AttributeHandleValuePairSetImp::getValueLength(ULong i) const
+    throw (RTI::ArrayIndexOutOfBounds)
+{
+    if (i < size())
+        return operator[](i).second.size();
+    else
+        throw RTI::ArrayIndexOutOfBounds("");
+}
+
+void AttributeHandleValuePairSetImp::getValue(ULong i, char *buff, ULong &len) const
+    throw (RTI::ArrayIndexOutOfBounds)
+{
+    if (i < size()) {
+        const AttributeHandleValuePair_t& item = operator[](i);
+        len = item.second.size();
+        memcpy(buff, item.second.data(), len);
+    }
+    else
+        throw RTI::ArrayIndexOutOfBounds("");
+}
+
+char *AttributeHandleValuePairSetImp::getValuePointer(ULong i, ULong &len) const
+    throw (RTI::ArrayIndexOutOfBounds)
+{
+    if (i < size()) {
+        const AttributeHandleValuePair_t& item = operator[](i);
+        len = item.second.size();
+        return (char *)item.second.data();
+    }
+    else
+        throw RTI::ArrayIndexOutOfBounds("");
+}
+
+TransportType AttributeHandleValuePairSetImp::getTransportType(ULong) const
+    throw (RTI::InvalidHandleValuePairSetContext)
+{
+    return _transport;
+}
+
+OrderType AttributeHandleValuePairSetImp::getOrderType(ULong) const
+    throw (RTI::ArrayIndexOutOfBounds, RTI::InvalidHandleValuePairSetContext)
+{
+    return _order;
+}
+
+RTI::Region *AttributeHandleValuePairSetImp::getRegion(ULong) const
+    throw (RTI::ArrayIndexOutOfBounds, RTI::InvalidHandleValuePairSetContext)
+{
+    throw RTI::RTIinternalError("unimplemented function getRegion()");
+}
+
+void AttributeHandleValuePairSetImp::add(Handle h, const char *str, ULong len)
+    throw (RTI::ValueLengthExceeded, RTI::ValueCountExceeded)
+{
+    push_back(AttributeHandleValuePair_t(h, std::string(str, len)));
+}
+
+void AttributeHandleValuePairSetImp::remove(Handle h)
+    throw (RTI::ArrayIndexOutOfBounds)
+{
+    for (iterator pos = begin(); pos != end(); pos++) {
+        if (pos->first == h) {
+            std::vector<AttributeHandleValuePair_t>::erase(pos);
+            return;
+        }
+    }
+
+    throw RTI::ArrayIndexOutOfBounds("");
+}
+
+void AttributeHandleValuePairSetImp::moveFrom(const AttributeHandleValuePairSet &, ULong &)
+    throw (RTI::ValueCountExceeded, RTI::ArrayIndexOutOfBounds)
+{
+    throw RTI::RTIinternalError("unimplemented function moveFrom()");
+}
+
+void AttributeHandleValuePairSetImp::empty()
+{
+    std::vector<AttributeHandleValuePair_t>::clear();
+}
+
+ULong AttributeHandleValuePairSetImp::start() const
+{
+    // not implemented
+    return 0 ;
+}
+
+ULong AttributeHandleValuePairSetImp::valid(ULong i) const
+{
+    // not implemented
+    return 0 ;
+}
+
+ULong AttributeHandleValuePairSetImp::next(ULong i) const
+{
+    // not implemented
+    return 0 ;
+}
+
+const std::vector<AttributeHandleValuePair_t>&
+AttributeHandleValuePairSetImp::getAttributeHandleValuePairs() const
+{
+    return *this;
+}
+
+// ----------------------------------------------------------------------------
+AttributeHandleSetImp::AttributeHandleSetImp(ULong size)
+{
+    std::vector<AttributeHandle>::reserve(size);
+}
+
+AttributeHandleSetImp::AttributeHandleSetImp(const std::vector<AttributeHandle> &val)
+    : std::vector<AttributeHandle>(val)
+{
+}
+
+AttributeHandleSetImp::~AttributeHandleSetImp()
+{
+}
+
+ULong AttributeHandleSetImp::size() const
+{
+    return std::vector<AttributeHandle>::size();
+}
+
+AttributeHandle AttributeHandleSetImp::getHandle(ULong i) const
+    throw (RTI::ArrayIndexOutOfBounds)
+{
+    if (i < size())
+        return operator[](i);
+    else
+        throw RTI::ArrayIndexOutOfBounds("");
+}
+
+void AttributeHandleSetImp::add(AttributeHandle h)
+    throw (RTI::ArrayIndexOutOfBounds, RTI::AttributeNotDefined)
+{
+    std::vector<AttributeHandle>::push_back(h);
+}
+
+void AttributeHandleSetImp::remove(AttributeHandle h)
+    throw (RTI::AttributeNotDefined)
+{
+    iterator pos = std::find(begin(), end(), h);
+    if (pos != end())
+        std::vector<AttributeHandle>::erase(pos);
+    else
+        throw RTI::ArrayIndexOutOfBounds("");
+}
+
+void AttributeHandleSetImp::empty()
+{
+    std::vector<AttributeHandle>::clear();
+}
+
+RTI::Boolean AttributeHandleSetImp::isEmpty() const
+{
+    return RTI::Boolean(std::vector<AttributeHandle>::empty());
+}
+
+RTI::Boolean AttributeHandleSetImp::isMember(AttributeHandle h) const
+{
+    return RTI::Boolean(std::find(begin(), end(), h) != end());
+}
+
+const std::vector<AttributeHandle>&
+AttributeHandleSetImp::getAttributeHandles() const
+{
+    return *this;
+}
+
+// ----------------------------------------------------------------------------
+FederateHandleSetImp::FederateHandleSetImp(ULong size)
+{
+    std::vector<FederateHandle>::reserve(size);
+}
+
+FederateHandleSetImp::~FederateHandleSetImp()
+{
+}
+
+ULong FederateHandleSetImp::size() const
+{
+    return std::vector<FederateHandle>::size();
+}
+
+FederateHandle FederateHandleSetImp::getHandle(ULong i) const
+    throw (RTI::ArrayIndexOutOfBounds)
+{
+    if (i < size())
+        return operator[](i);
+    else
+        throw RTI::ArrayIndexOutOfBounds("");
+}
+
+void FederateHandleSetImp::add(FederateHandle h)
+    throw (RTI::ValueCountExceeded)
+{
+    std::vector<FederateHandle>::push_back(h);
+}
+
+void FederateHandleSetImp::remove(FederateHandle h)
+    throw (RTI::ArrayIndexOutOfBounds)
+{
+    iterator pos = std::find(begin(), end(), h);
+    if (pos != end())
+        std::vector<FederateHandle>::erase(pos);
+    else
+        throw RTI::ArrayIndexOutOfBounds("");
+}
+
+void FederateHandleSetImp::empty()
+{
+    std::vector<AttributeHandle>::clear();
+}
+
+RTI::Boolean FederateHandleSetImp::isMember(FederateHandle h) const
+{
+    return RTI::Boolean(std::find(begin(), end(), h) != end());
+}
+
+// ----------------------------------------------------------------------------
+ParameterHandleValuePairSetImp::ParameterHandleValuePairSetImp(ULong size)
+{
+    _order = RECEIVE;
+    _transport = RELIABLE;
+
+    std::vector<ParameterHandleValuePair_t>::reserve(size);
+}
+
+ParameterHandleValuePairSetImp::ParameterHandleValuePairSetImp(const std::vector<ParameterHandleValuePair_t> &val)
+    : std::vector<ParameterHandleValuePair_t>(val)
+{
+    _order = RECEIVE;
+    _transport = RELIABLE;
+}
+
+ParameterHandleValuePairSetImp::~ParameterHandleValuePairSetImp()
+{
+}
+
+ULong ParameterHandleValuePairSetImp::size() const
+{
+    return std::vector<ParameterHandleValuePair_t>::size();
+}
+
+Handle ParameterHandleValuePairSetImp::getHandle(ULong i) const
+    throw (RTI::ArrayIndexOutOfBounds)
+{
+    if (i < size())
+        return operator[](i).first;
+    else
+        throw RTI::ArrayIndexOutOfBounds("");
+}
+
+ULong ParameterHandleValuePairSetImp::getValueLength(ULong i) const
+    throw (RTI::ArrayIndexOutOfBounds)
+{
+    if (i < size())
+        return operator[](i).second.size();
+    else
+        throw RTI::ArrayIndexOutOfBounds("");
+}
+
+void ParameterHandleValuePairSetImp::getValue(ULong i, char *buff, ULong &len) const
+    throw (RTI::ArrayIndexOutOfBounds)
+{
+    if (i < size()) {
+        const ParameterHandleValuePair_t& item = operator[](i);
+        len = item.second.size();
+        memcpy(buff, item.second.data(), len);
+    }
+    else
+        throw RTI::ArrayIndexOutOfBounds("");
+}
+
+char *ParameterHandleValuePairSetImp::getValuePointer(ULong i, ULong &len) const
+    throw (RTI::ArrayIndexOutOfBounds)
+{
+    if (i < size()) {
+        const ParameterHandleValuePair_t& item = operator[](i);
+        len = item.second.size();
+        return (char *)item.second.data();
+    }
+    else
+        throw RTI::ArrayIndexOutOfBounds("");
+}
+
+TransportType ParameterHandleValuePairSetImp::getTransportType() const
+    throw (RTI::InvalidHandleValuePairSetContext)
+{
+    return _transport;
+}
+
+OrderType ParameterHandleValuePairSetImp::getOrderType() const
+    throw (RTI::InvalidHandleValuePairSetContext)
+{
+    return _order;
+}
+
+RTI::Region *ParameterHandleValuePairSetImp::getRegion() const
+    throw (RTI::InvalidHandleValuePairSetContext)
+{
+    throw RTI::RTIinternalError("unimplemented function getRegion()");
+}
+
+void ParameterHandleValuePairSetImp::add(Handle h, const char *str, ULong len)
+    throw (RTI::ValueLengthExceeded, RTI::ValueCountExceeded)
+{
+    push_back(ParameterHandleValuePair_t(h, std::string(str, len)));
+}
+
+void ParameterHandleValuePairSetImp::remove(Handle h)
+    throw (RTI::ArrayIndexOutOfBounds)
+{
+    for (iterator pos = begin(); pos != end(); pos++) {
+        if (pos->first == h) {
+            std::vector<ParameterHandleValuePair_t>::erase(pos);
+            return;
+        }
+    }
+
+    throw RTI::ArrayIndexOutOfBounds("");
+}
+
+void ParameterHandleValuePairSetImp::moveFrom(const ParameterHandleValuePairSet &, ULong &)
+    throw (RTI::ValueCountExceeded, RTI::ArrayIndexOutOfBounds)
+{
+    throw RTI::RTIinternalError("unimplemented function moveFrom()");
+}
+
+void ParameterHandleValuePairSetImp::empty()
+{
+    return std::vector<ParameterHandleValuePair_t>::clear();
+}
+
+ULong ParameterHandleValuePairSetImp::start() const
+{
+    // not implemented
+    return 0;
+}
+
+ULong ParameterHandleValuePairSetImp::valid(ULong i) const
+{
+    // not implemented
+    return 0;
+}
+
+ULong ParameterHandleValuePairSetImp::next(ULong i) const
+{
+    // not implemented
+    return 0;
+}
+
+const std::vector<ParameterHandleValuePair_t> &
+ParameterHandleValuePairSetImp::getParameterHandleValuePairs() const
+{
+    return *this;
+}
+
+// ----------------------------------------------------------------------------
+RTI::AttributeHandleValuePairSet *
+RTI::AttributeSetFactory::create(ULong size)
+    throw (MemoryExhausted, ValueCountExceeded, HandleValuePairMaximumExceeded)
+{
+    return new AttributeHandleValuePairSetImp(size);
+}
+
+// ----------------------------------------------------------------------------
+RTI::AttributeHandleSet *
+RTI::AttributeHandleSetFactory::create(ULong size)
+    throw (MemoryExhausted, ValueCountExceeded)
+{
+    return new AttributeHandleSetImp(size);
+}
+
+// ----------------------------------------------------------------------------
+RTI::FederateHandleSet *
+RTI::FederateHandleSetFactory::create(ULong size)
+    throw (MemoryExhausted, ValueCountExceeded)
+{
+    return new FederateHandleSetImp(size);
+}
+
+// ----------------------------------------------------------------------------
+RTI::ParameterHandleValuePairSet *
+RTI::ParameterSetFactory::create(ULong size)
+    throw (MemoryExhausted, ValueCountExceeded, HandleValuePairMaximumExceeded)
+{
+    return new ParameterHandleValuePairSetImp(size);
+}
+
+// ----------------------------------------------------------------------------
+RegionImp::RegionImp(RegionHandle h, SpaceHandle s, const std::vector<Extent> &ext)
+    : handle(h), space(s), coExtents(ext)
+{
+}
+
+RegionImp::~RegionImp()
+{
+}
+
+ULong RegionImp::getRangeLowerBound(ExtentIndex index, DimensionHandle dimension) const
+    throw (RTI::ArrayIndexOutOfBounds)
+{
+    if (index < extents.size())
+        return extents[index].getRangeLowerBound(dimension);
+    else
+        throw RTI::ArrayIndexOutOfBounds("Extent index above limit");
+}
+
+ULong RegionImp::getRangeUpperBound(ExtentIndex index, DimensionHandle dimension) const
+    throw (RTI::ArrayIndexOutOfBounds)
+{
+    if (index < extents.size())
+        return extents[index].getRangeUpperBound(dimension);
+    else
+        throw RTI::ArrayIndexOutOfBounds("Extent index above limit");
+}
+
+void RegionImp::setRangeLowerBound(ExtentIndex index, DimensionHandle dimension, ULong val)
+    throw (RTI::ArrayIndexOutOfBounds)
+{
+    if (index < extents.size())
+        extents[index].setRangeLowerBound(dimension, val);
+    else
+        throw RTI::ArrayIndexOutOfBounds("Extent index above limit");
+}
+
+void RegionImp::setRangeUpperBound(ExtentIndex index, DimensionHandle dimension, ULong val)
+    throw (RTI::ArrayIndexOutOfBounds)
+{
+    if (index < extents.size())
+        extents[index].setRangeUpperBound(dimension, val);
+    else
+        throw RTI::ArrayIndexOutOfBounds("Extent index above limit");
+}
+
+SpaceHandle RegionImp::getSpaceHandle() const
+    throw ()
+{
+    return space;
+}
+
+ULong RegionImp::getNumberOfExtents() const
+    throw ()
+{
+    return coExtents.size();
+}
+
+ULong RegionImp::getRangeLowerBoundNotificationLimit(ExtentIndex index, DimensionHandle dimension) const
+    throw (RTI::ArrayIndexOutOfBounds)
+{
+    if (index < coExtents.size())
+        return coExtents[index].getRangeLowerBound(dimension);
+    else
+        throw RTI::ArrayIndexOutOfBounds("Extent index above limit");
+}
+
+ULong RegionImp::getRangeUpperBoundNotificationLimit(ExtentIndex index, DimensionHandle dimension) const
+    throw (RTI::ArrayIndexOutOfBounds)
+{
+    if (index < coExtents.size())
+        return coExtents[index].getRangeUpperBound(dimension);
+    else
+        throw RTI::ArrayIndexOutOfBounds("Extent index above limit");
+}
+
+// $Id: RTItypes.cc,v 1.1 2008/11/25 16:32:14 gotthardp Exp $
diff --exclude=CVS -Nru certi/libRTI/HandleSets.hh certi.new/libRTI/HandleSets.hh
--- certi/libRTI/HandleSets.hh	1970-01-01 01:00:00.000000000 +0100
+++ certi.new/libRTI/HandleSets.hh	2008-12-05 17:06:13.000000000 +0100
@@ -0,0 +1,233 @@
+// HLA 1.3 Header "RTItypes.hh"
+// $Id: RTItypes.hh,v 3.18 2007/09/25 13:42:54 erk Exp $
+
+#ifndef _RTI_HANDLESETS_HH
+#define _RTI_HANDLESETS_HH
+
+#include "certi.hh"
+#include "Extent.hh"
+
+namespace certi {
+
+template<class I>
+struct cast
+{
+    template<class R>
+    const I& operator()(const R& imp)
+    {
+        try {
+            return dynamic_cast<const I&>(imp);
+        }
+        catch (...)
+        {
+            throw RTI::RTIinternalError("Incompatible object on input.");
+        }
+    }
+};
+
+typedef std::pair<AttributeHandle, AttributeValue_t> AttributeHandleValuePair_t;
+
+class RTI_EXPORT AttributeHandleValuePairSetImp
+    : public RTI::AttributeHandleValuePairSet, protected std::vector<AttributeHandleValuePair_t>
+{
+public:
+    AttributeHandleValuePairSetImp(ULong);
+    AttributeHandleValuePairSetImp(const std::vector<AttributeHandleValuePair_t> &);
+
+    virtual ~AttributeHandleValuePairSetImp();
+
+    virtual ULong size() const;
+
+    virtual Handle getHandle(ULong) const
+        throw (RTI::ArrayIndexOutOfBounds);
+
+    virtual ULong getValueLength(ULong) const
+        throw (RTI::ArrayIndexOutOfBounds);
+
+    virtual void getValue(ULong, char *, ULong &) const
+        throw (RTI::ArrayIndexOutOfBounds);
+
+    virtual char *getValuePointer(ULong, ULong &) const
+        throw (RTI::ArrayIndexOutOfBounds);
+
+    virtual TransportType getTransportType(ULong) const
+        throw (RTI::InvalidHandleValuePairSetContext);
+
+    virtual OrderType getOrderType(ULong) const
+        throw (RTI::ArrayIndexOutOfBounds, RTI::InvalidHandleValuePairSetContext);
+
+    virtual RTI::Region *getRegion(ULong) const
+        throw (RTI::ArrayIndexOutOfBounds, RTI::InvalidHandleValuePairSetContext);
+
+    virtual void add(Handle, const char *, ULong)
+        throw (RTI::ValueLengthExceeded, RTI::ValueCountExceeded);
+
+    virtual void remove(Handle h)
+        throw (RTI::ArrayIndexOutOfBounds);
+
+    virtual void moveFrom(const AttributeHandleValuePairSet &, ULong &)
+        throw (RTI::ValueCountExceeded, RTI::ArrayIndexOutOfBounds);
+
+    virtual void empty();
+
+    virtual ULong start() const;
+    virtual ULong valid(ULong i) const;
+    virtual ULong next(ULong i) const;
+
+    const std::vector<AttributeHandleValuePair_t>& getAttributeHandleValuePairs() const;
+
+protected:
+    OrderType _order ;
+    TransportType _transport ;
+};
+
+class RTI_EXPORT AttributeHandleSetImp
+    : public RTI::AttributeHandleSet, protected std::vector<AttributeHandle>
+{
+public:
+    AttributeHandleSetImp(ULong);
+    AttributeHandleSetImp(const std::vector<AttributeHandle> &);
+
+    virtual ~AttributeHandleSetImp();
+
+    virtual ULong size() const;
+
+    virtual AttributeHandle getHandle(ULong) const
+        throw (RTI::ArrayIndexOutOfBounds);
+
+    virtual void add(AttributeHandle)
+        throw (RTI::ArrayIndexOutOfBounds, RTI::AttributeNotDefined);
+
+    virtual void remove(AttributeHandle)
+        throw (RTI::AttributeNotDefined);
+
+    virtual void empty();
+
+    virtual RTI::Boolean isEmpty() const;
+    virtual RTI::Boolean isMember(AttributeHandle h) const;
+
+    const std::vector<AttributeHandle>& getAttributeHandles() const;
+};
+
+class RTI_EXPORT FederateHandleSetImp
+    : public RTI::FederateHandleSet, protected std::vector<FederateHandle>
+{
+public:
+    FederateHandleSetImp(ULong);
+    virtual ~FederateHandleSetImp();
+
+    virtual ULong size() const;
+
+    virtual FederateHandle getHandle(ULong) const
+        throw (RTI::ArrayIndexOutOfBounds);
+
+    virtual void add(FederateHandle)
+        throw (RTI::ValueCountExceeded);
+
+    virtual void remove(FederateHandle)
+        throw (RTI::ArrayIndexOutOfBounds);
+
+    virtual void empty();
+
+    virtual RTI::Boolean isMember(FederateHandle) const;
+};
+
+typedef std::pair<ParameterHandle, ParameterValue_t> ParameterHandleValuePair_t;
+
+class RTI_EXPORT ParameterHandleValuePairSetImp
+    : public RTI::ParameterHandleValuePairSet, protected std::vector<ParameterHandleValuePair_t>
+{
+public:
+    ParameterHandleValuePairSetImp(ULong);
+    ParameterHandleValuePairSetImp(const std::vector<ParameterHandleValuePair_t> &);
+    virtual ~ParameterHandleValuePairSetImp();
+
+    virtual ULong size() const;
+
+    virtual Handle getHandle(ULong) const
+        throw (RTI::ArrayIndexOutOfBounds);
+
+    virtual ULong getValueLength(ULong) const
+        throw (RTI::ArrayIndexOutOfBounds);
+
+    virtual void getValue(ULong, char *, ULong &) const
+        throw (RTI::ArrayIndexOutOfBounds);
+
+    virtual char *getValuePointer(ULong, ULong &) const
+        throw (RTI::ArrayIndexOutOfBounds);
+
+    virtual TransportType getTransportType() const
+        throw (RTI::InvalidHandleValuePairSetContext);
+
+    virtual OrderType getOrderType() const
+        throw (RTI::InvalidHandleValuePairSetContext);
+
+    virtual RTI::Region *getRegion() const
+        throw (RTI::InvalidHandleValuePairSetContext);
+
+    virtual void add(Handle, const char *, ULong)
+        throw (RTI::ValueLengthExceeded, RTI::ValueCountExceeded);
+
+    virtual void remove(Handle)
+        throw (RTI::ArrayIndexOutOfBounds);
+
+    virtual void moveFrom(const ParameterHandleValuePairSet &, ULong &)
+        throw (RTI::ValueCountExceeded, RTI::ArrayIndexOutOfBounds);
+
+    virtual void empty();
+
+    virtual ULong start() const;
+    virtual ULong valid(ULong i) const;
+    virtual ULong next(ULong i) const;
+
+    const std::vector<ParameterHandleValuePair_t>& getParameterHandleValuePairs() const;
+
+protected:
+    OrderType _order ;
+    TransportType _transport ;
+};
+
+
+class RTI_EXPORT RegionImp : public RTI::Region
+{
+public:
+    RegionImp(RegionHandle, SpaceHandle, const std::vector<Extent> &);
+    virtual ~RegionImp();
+
+    virtual ULong getRangeLowerBound(ExtentIndex, DimensionHandle) const
+        throw (RTI::ArrayIndexOutOfBounds);
+
+    virtual ULong getRangeUpperBound(ExtentIndex, DimensionHandle) const
+        throw (RTI::ArrayIndexOutOfBounds);
+
+    virtual void setRangeLowerBound(ExtentIndex, DimensionHandle, ULong)
+        throw (RTI::ArrayIndexOutOfBounds);
+
+    virtual void setRangeUpperBound(ExtentIndex, DimensionHandle, ULong)
+        throw (RTI::ArrayIndexOutOfBounds);
+
+    virtual SpaceHandle getSpaceHandle() const
+        throw ();
+
+    virtual ULong getNumberOfExtents() const
+        throw ();
+
+    virtual ULong getRangeLowerBoundNotificationLimit(ExtentIndex, DimensionHandle) const
+        throw (RTI::ArrayIndexOutOfBounds);
+
+    virtual ULong getRangeUpperBoundNotificationLimit(ExtentIndex, DimensionHandle) const
+        throw (RTI::ArrayIndexOutOfBounds);
+
+private:
+    RegionHandle handle;
+    SpaceHandle space;
+    std::vector<Extent> extents;
+
+    std::vector<Extent> coExtents;
+};
+
+}
+
+#endif // _RTI_HANDLESETS_HH
+
+// $Id: RTItypes.hh,v 3.18 2007/09/25 13:42:54 erk Exp $
diff --exclude=CVS -Nru certi/libRTI/RTIambassador.cc certi.new/libRTI/RTIambassador.cc
--- certi/libRTI/RTIambassador.cc	2008-11-21 14:41:52.000000000 +0100
+++ certi.new/libRTI/RTIambassador.cc	2008-12-05 18:27:42.000000000 +0100
@@ -26,6 +26,7 @@
 #include "certi.hh"
 
 #include "RTIambPrivateRefs.hh"
+#include "HandleSets.hh"
 
 #include "FedRegion.hh"
 #include "Message.hh"
@@ -74,7 +75,7 @@
 
 RTI::Handle
 get_handle(const RTI::Region &region)
-    throw (RegionNotKnown, RTIinternalError)
+    throw (RTI::RegionNotKnown, RTI::RTIinternalError)
 {
     try {
 	return dynamic_cast<const FedRegion &>(region).getHandle();
@@ -87,7 +88,7 @@
 
 char *
 hla_strdup(const std::string &s)
-    throw (RTIinternalError)
+    throw (RTI::RTIinternalError)
 {
     try {
         size_t len = s.length();
@@ -114,7 +115,7 @@
 */
 
 RTI::RTIambassador::RTIambassador()
-    throw (MemoryExhausted, RTIinternalError)
+    throw (RTI::MemoryExhausted, RTI::RTIinternalError)
 {
     G.Out(pdGendoc,"enter RTIambassador::RTIambassador");
     PrettyDebug::setFederateName( "Federate" );
@@ -156,7 +157,7 @@
 	         << GetLastError() <<"> "
 	         << "Cannot connect to RTIA.exe";		
 		//perror("CreateProcess");
-		 throw RTIinternalError( msg.str().c_str());
+		 throw RTI::RTIinternalError( msg.str().c_str());
 		}
     
    privateRefs->handle_RTIA = pi.hProcess;
@@ -175,7 +176,7 @@
     switch((privateRefs->pid_RTIA = fork())) {
       case -1: // fork failed.
         perror("fork");
-        throw RTIinternalError("fork failed in RTIambassador constructor");
+        throw RTI::RTIinternalError("fork failed in RTIambassador constructor");
         break ;
 
       case 0: // child process (RTIA).
@@ -184,7 +185,7 @@
             << strerror(errno)
             << endl
             << "Maybe RTIA is not in search PATH environment.";        
-        throw RTIinternalError(msg.str().c_str());
+        throw RTI::RTIinternalError(msg.str().c_str());
         
       default: // father process (Federe).
     	// We sleep before trying to connect to the socket
@@ -198,7 +199,7 @@
         {
            D.Out( pdError, "Cannot connect to RTIA. Abort." ) ;
            kill( privateRefs->pid_RTIA, SIGINT ) ;
-           throw RTIinternalError( "Cannot connect to RTIA" ) ;
+           throw RTI::RTIinternalError( "Cannot connect to RTIA" );
         };
         break ;
     }
@@ -214,7 +215,7 @@
 /*! When destructor is called, kill rtia process.
  */
 RTI::RTIambassador::~RTIambassador()
-    throw (RTIinternalError)
+    throw (RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -235,7 +236,7 @@
 RTI::RTIambassador::tick()
     throw (SpecifiedSaveLabelDoesNotExist,
            ConcurrentAccessAttempted,
-           RTIinternalError)
+           RTI::RTIinternalError)
 {
    __tick_kernel(RTI_FALSE, 0.0, 0.0);
    return RTI_FALSE;
@@ -250,9 +251,9 @@
  */
 RTI::Boolean
 RTI::RTIambassador::tick2()
-    throw (SpecifiedSaveLabelDoesNotExist,
-           ConcurrentAccessAttempted,
-           RTIinternalError)
+    throw (RTI::SpecifiedSaveLabelDoesNotExist,
+           RTI::ConcurrentAccessAttempted,
+           RTI::RTIinternalError)
 {
    __tick_kernel(RTI_FALSE, std::numeric_limits<double>::infinity(), 0.0);
    return RTI_FALSE;
@@ -267,9 +268,9 @@
  */
 RTI::Boolean
 RTI::RTIambassador::__tick_kernel(RTI::Boolean multiple, TickTime minimum, TickTime maximum)
-    throw (SpecifiedSaveLabelDoesNotExist,
-           ConcurrentAccessAttempted,
-           RTIinternalError)
+    throw (RTI::SpecifiedSaveLabelDoesNotExist,
+           RTI::ConcurrentAccessAttempted,
+           RTI::RTIinternalError)
 {
     Message vers_RTI, vers_Fed ;
 
@@ -286,7 +287,7 @@
         std::stringstream msg;
         msg << "NetworkError in tick() while sending TICK_REQUEST: " << e._reason;
 
-        throw RTIinternalError(msg.str().c_str());
+        throw RTI::RTIinternalError(msg.str().c_str());
     }
 
     // Read response(s) from the local RTIA until Message::TICK_REQUEST is received.
@@ -298,7 +299,7 @@
             std::stringstream msg;
             msg << "NetworkError in tick() while receiving response: " << e._reason;
 
-            throw RTIinternalError(msg.str().c_str());
+            throw RTI::RTIinternalError(msg.str().c_str());
         }
 
         //D.Mes( pdMessage, 'M', vers_Fed.type);
@@ -318,7 +319,7 @@
             // Otherwise, the RTI calls a FederateAmbassador service.
             privateRefs->callFederateAmbassador(&vers_Fed);
         }
-        catch (RTIinternalError) {
+        catch (RTI::RTIinternalError) {
             // RTIA awaits TICK_REQUEST_NEXT, terminate the tick() processing
             privateRefs->sendTickRequestStop();
             // ignore the response and re-throw the original exception
@@ -336,7 +337,7 @@
             std::stringstream msg;
             msg << "NetworkError in tick() while sending TICK_REQUEST_NEXT: " << e._reason;
 
-            throw RTIinternalError(msg.str().c_str());
+            throw RTI::RTIinternalError(msg.str().c_str());
         }
     } // while(1)
 }
@@ -350,8 +351,8 @@
  */
 RTI::Boolean
 RTI::RTIambassador::tick(TickTime minimum, TickTime maximum)
-    throw (SpecifiedSaveLabelDoesNotExist, ConcurrentAccessAttempted,
-           RTIinternalError)
+    throw (RTI::SpecifiedSaveLabelDoesNotExist, RTI::ConcurrentAccessAttempted,
+           RTI::RTIinternalError)
 {
     return __tick_kernel(RTI_TRUE, minimum, maximum);
 }
@@ -373,7 +374,7 @@
     throw (RTI::FederateNotExecutionMember, RTI::ConcurrentAccessAttempted,
            RTI::RegionNotKnown, RTI::RTIinternalError)
 {
-    throw UnimplementedService("");
+    throw RTI::RTIinternalError("unimplemented service getRegion");
 }
 
 // ----------------------------------------------------------------------------
@@ -458,9 +459,9 @@
     G.Out(pdGendoc,"enter RTIambassador::joinFederationExecution");
 
     if ( yourName == NULL || strlen(yourName) == 0 )
-        throw RTIinternalError("Incorrect or empty federate name");
+        throw RTI::RTIinternalError("Incorrect or empty federate name");
     if ( executionName == NULL || strlen(executionName) == 0 )
-        throw RTIinternalError("Incorrect or empty federation name");
+        throw RTI::RTIinternalError("Incorrect or empty federation name");
 
     privateRefs->fed_amb = (FederateAmbassador *) fedamb ;
 
@@ -477,11 +478,11 @@
 //! Resign Federation Execution.
 void
 RTI::RTIambassador::resignFederationExecution(ResignAction theAction)
-    throw (FederateOwnsAttributes,
-           FederateNotExecutionMember,
-           InvalidResignAction,
-           ConcurrentAccessAttempted,
-           RTIinternalError)
+    throw (RTI::FederateOwnsAttributes,
+           RTI::FederateNotExecutionMember,
+           RTI::InvalidResignAction,
+           RTI::ConcurrentAccessAttempted,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -507,11 +508,11 @@
 void
 RTI::RTIambassador::registerFederationSynchronizationPoint(const char *label,
                                                       const char *the_tag)
-    throw (FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -521,7 +522,7 @@
     req.setLabel(label);
     if ( the_tag == NULL )
        {
-       throw RTIinternalError ("Calling registerFederationSynchronizationPoint with Tag NULL");
+       throw RTI::RTIinternalError ("Calling registerFederationSynchronizationPoint with Tag NULL");
        }
     req.setTag(the_tag);
     // boolean false because without set of federates
@@ -557,7 +558,7 @@
     req.setLabel(label);
     if ( theTag == NULL )
        {
-       throw RTIinternalError ("Calling registerFederationSynchronizationPoint with Tag NULL");
+       throw RTI::RTIinternalError ("Calling registerFederationSynchronizationPoint with Tag NULL");
        }
     req.setTag(theTag);
     // boolean must be true because federate set exists but if size=0 (set empty)
@@ -588,12 +589,12 @@
 //! Synchronization Point Achieved
 void
 RTI::RTIambassador::synchronizationPointAchieved(const char *label)
-    throw (SynchronizationPointLabelWasNotAnnounced,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::SynchronizationPointLabelWasNotAnnounced,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -612,13 +613,13 @@
 void
 RTI::RTIambassador::requestFederationSave(const char *label,
                                      const FedTime& theTime)
-    throw (FederationTimeAlreadyPassed,
-           InvalidFederationTime,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::FederationTimeAlreadyPassed,
+           RTI::InvalidFederationTime,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -640,11 +641,11 @@
 //! Request Federation Save without time.
 void
 RTI::RTIambassador::requestFederationSave(const char *label)
-    throw (FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -666,11 +667,11 @@
 //! Federate Save Begun.
 void
 RTI::RTIambassador::federateSaveBegun()
-    throw (SaveNotInitiated,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::SaveNotInitiated,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -687,11 +688,11 @@
 //! Federate Save Complete.
 void
 RTI::RTIambassador::federateSaveComplete()
-    throw (SaveNotInitiated,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::SaveNotInitiated,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -707,11 +708,11 @@
 // Federate Save Not Complete.
 void
 RTI::RTIambassador::federateSaveNotComplete()
-    throw (SaveNotInitiated,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::SaveNotInitiated,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
 
     Message req, rep ;
@@ -795,7 +796,7 @@
 
     req.type = Message::PUBLISH_OBJECT_CLASS ;
     req.setObjectClass(theClass);
-    req.setAHS(attributeList);
+    req.setAHS(cast<AttributeHandleSetImp>()(attributeList).getAttributeHandles());
     G.Out(pdGendoc,"      ====>executeService PUBLISH_OBJECT_CLASS");
     privateRefs->executeService(&req, &rep);
     G.Out(pdGendoc,"exit  RTIambassador::publishObjectClass");
@@ -869,7 +870,7 @@
     G.Out(pdGendoc,"enter RTIambassador::subscribeObjectClassAttributes");
     req.type = Message::SUBSCRIBE_OBJECT_CLASS_ATTRIBUTES ;
     req.setObjectClass(theClass);
-    req.setAHS(attributeList);
+    req.setAHS(cast<AttributeHandleSetImp>()(attributeList).getAttributeHandles());
     req.setBoolean(active);
 
     privateRefs->executeService(&req, &rep);
@@ -980,15 +981,15 @@
                       const AttributeHandleValuePairSet& theAttributes,
                       const FedTime& theTime,
                       const char *theTag)
-    throw (ObjectNotKnown,
-           AttributeNotDefined,
-           AttributeNotOwned,
-           InvalidFederationTime,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::ObjectNotKnown,
+           RTI::AttributeNotDefined,
+           RTI::AttributeNotOwned,
+           RTI::InvalidFederationTime,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     G.Out(pdGendoc,"enter RTIambassador::updateAttributeValues with time");
     Message req, rep ;
@@ -998,10 +999,10 @@
     req.setFedTime(theTime);
     if ( theTag == NULL)
        {
-       throw RTIinternalError ("Calling updateAttributeValues with Tag NULL");
+       throw RTI::RTIinternalError ("Calling updateAttributeValues with Tag NULL");
        }
     req.setTag(theTag);
-    req.setAHVPS(theAttributes);
+    req.setAHVPS(cast<AttributeHandleValuePairSetImp>()(theAttributes).getAttributeHandleValuePairs());
     req.setBoolean(true);
 
     privateRefs->executeService(&req, &rep);
@@ -1034,10 +1035,10 @@
     req.setObject(the_object);
     if ( theTag == NULL)
        {
-       throw RTIinternalError ("Calling updateAttributeValues with Tag NULL");
+       throw RTI::RTIinternalError ("Calling updateAttributeValues with Tag NULL");
        }
     req.setTag(theTag);
-    req.setAHVPS(theAttributes);
+    req.setAHVPS(cast<AttributeHandleValuePairSetImp>()(theAttributes).getAttributeHandleValuePairs());
     req.setBoolean(false);
 
     privateRefs->executeService(&req, &rep);
@@ -1058,15 +1059,15 @@
                                const ParameterHandleValuePairSet& theParameters,
                                const FedTime& theTime,
                                const char *theTag)
-    throw (InteractionClassNotDefined,
-           InteractionClassNotPublished,
-           InteractionParameterNotDefined,
-           InvalidFederationTime,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::InteractionClassNotDefined,
+           RTI::InteractionClassNotPublished,
+           RTI::InteractionParameterNotDefined,
+           RTI::InvalidFederationTime,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -1075,10 +1076,10 @@
     req.setFedTime(theTime);
     if (theTag == NULL)
        {
-       throw RTIinternalError ("Calling sendInteraction with Tag NULL") ;
+       throw RTI::RTIinternalError ("Calling sendInteraction with Tag NULL") ;
        }
     req.setTag((std::string)theTag);
-    req.setPHVPS(theParameters);
+    req.setPHVPS(cast<ParameterHandleValuePairSetImp>()(theParameters).getParameterHandleValuePairs());
     req.setRegion(0);
     req.setBoolean(true);
 
@@ -1111,10 +1112,10 @@
     req.setInteractionClass(theInteraction);
     if (theTag == NULL)
        {
-       throw RTIinternalError ("Calling sendIntercation with Tag NULL") ;
+       throw RTI::RTIinternalError ("Calling sendIntercation with Tag NULL") ;
        }
     req.setTag((std::string)theTag);
-    req.setPHVPS(theParameters);
+    req.setPHVPS(cast<ParameterHandleValuePairSetImp>()(theParameters).getParameterHandleValuePairs());
     req.setRegion(0);
     req.setBoolean(false);
   
@@ -1133,14 +1134,14 @@
 RTI::RTIambassador::deleteObjectInstance(ObjectHandle theObject,
                                     const FedTime& theTime,
                                     const char *theTag)
-    throw (ObjectNotKnown,
-           DeletePrivilegeNotHeld,
-           InvalidFederationTime,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::ObjectNotKnown,
+           RTI::DeletePrivilegeNotHeld,
+           RTI::InvalidFederationTime,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -1149,7 +1150,7 @@
     req.setFedTime(theTime);
     if (theTag == NULL)
        {
-       throw RTIinternalError ("Calling deleteObjectInstance with Tag NULL") ;
+       throw RTI::RTIinternalError ("Calling deleteObjectInstance with Tag NULL") ;
        }
     req.setTag(theTag);
     req.setBoolean(true);
@@ -1177,7 +1178,7 @@
     req.setObject(theObject);
     if (theTag == NULL)
        {
-       throw RTIinternalError ("Calling deleteObjectInstance with Tag NULL") ;
+       throw RTI::RTIinternalError ("Calling deleteObjectInstance with Tag NULL") ;
        }
     req.setTag(theTag);
    
@@ -1194,7 +1195,7 @@
 	   RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember, 
 	   RTI::FederateOwnsAttributes, RTI::ObjectNotKnown)
 {
-    throw UnimplementedService("");
+    throw RTI::RTIinternalError("unimplemented service localDeleteObjectInstance");
     Message req, rep ;
 
     req.type = Message::LOCAL_DELETE_OBJECT_INSTANCE ;
@@ -1221,7 +1222,7 @@
     req.type = Message::CHANGE_ATTRIBUTE_TRANSPORTATION_TYPE ;
     req.setObject(theObject);
     req.setTransportation(theType);
-    req.setAHS(theAttributes);
+    req.setAHS(cast<AttributeHandleSetImp>()(theAttributes).getAttributeHandles());
 
     privateRefs->executeService(&req, &rep);
 }
@@ -1261,7 +1262,7 @@
     G.Out(pdGendoc,"enter RTIambassador::requestObjectAttributeValueUpdate");
     req.type = Message::REQUEST_OBJECT_ATTRIBUTE_VALUE_UPDATE ;
     req.setObject(theObject);
-    req.setAHS(ahs);
+    req.setAHS(cast<AttributeHandleSetImp>()(ahs).getAttributeHandles());
 
     privateRefs->executeService(&req, &rep);
     G.Out(pdGendoc,"exit  RTIambassador::requestObjectAttributeValueUpdate");
@@ -1282,7 +1283,7 @@
     G.Out(pdGendoc,"enter RTIambassador::requestClassAttributeValueUpdate");
     req.type = Message::REQUEST_CLASS_ATTRIBUTE_VALUE_UPDATE ;
     req.setObjectClass(theClass);
-    req.setAHS(attrs);
+    req.setAHS(cast<AttributeHandleSetImp>()(attrs).getAttributeHandles());
 
     privateRefs->executeService(&req, &rep);
     G.Out(pdGendoc,"exit  RTIambassador::requestClassAttributeValueUpdate");
@@ -1294,20 +1295,20 @@
 RTI::RTIambassador::
 unconditionalAttributeOwnershipDivestiture(ObjectHandle theObject,
                                            const AttributeHandleSet &attrs)
-    throw (ObjectNotKnown,
-           AttributeNotDefined,
-           AttributeNotOwned,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::ObjectNotKnown,
+           RTI::AttributeNotDefined,
+           RTI::AttributeNotOwned,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
     req.type = Message::UNCONDITIONAL_ATTRIBUTE_OWNERSHIP_DIVESTITURE ;
     req.setObject(theObject);
-    req.setAHS(attrs);
+    req.setAHS(cast<AttributeHandleSetImp>()(attrs).getAttributeHandles());
 
     privateRefs->executeService(&req, &rep);
 }
@@ -1319,15 +1320,15 @@
 negotiatedAttributeOwnershipDivestiture(ObjectHandle theObject,
                                         const AttributeHandleSet& attrs,
                                         const char *theTag)
-    throw (ObjectNotKnown,
-           AttributeNotDefined,
-           AttributeNotOwned,
-           AttributeAlreadyBeingDivested,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::ObjectNotKnown,
+           RTI::AttributeNotDefined,
+           RTI::AttributeNotOwned,
+           RTI::AttributeAlreadyBeingDivested,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -1335,10 +1336,10 @@
     req.setObject(theObject);
     if (theTag == NULL)
        {
-       throw RTIinternalError ("Calling negotiatedAttributeOwnershipDivestiture with Tag NULL") ;
+       throw RTI::RTIinternalError ("Calling negotiatedAttributeOwnershipDivestiture with Tag NULL") ;
        }
     req.setTag(theTag);
-    req.setAHS(attrs);
+    req.setAHS(cast<AttributeHandleSetImp>()(attrs).getAttributeHandles());
 
     privateRefs->executeService(&req, &rep);
 }
@@ -1350,16 +1351,16 @@
 attributeOwnershipAcquisition(ObjectHandle theObject,
                               const AttributeHandleSet& desiredAttributes,
                               const char *theTag)
-    throw (ObjectNotKnown,
-           ObjectClassNotPublished,
-           AttributeNotDefined,
-           AttributeNotPublished,
-           FederateOwnsAttributes,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::ObjectNotKnown,
+           RTI::ObjectClassNotPublished,
+           RTI::AttributeNotDefined,
+           RTI::AttributeNotPublished,
+           RTI::FederateOwnsAttributes,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -1367,40 +1368,40 @@
     req.setObject(theObject);
     if (theTag == NULL)
        {
-       throw RTIinternalError ("Calling attributeOwnershipAcquisition with Tag NULL") ;
+       throw RTI::RTIinternalError ("Calling attributeOwnershipAcquisition with Tag NULL") ;
        }
     req.setTag(theTag);
-    req.setAHS(desiredAttributes);
+    req.setAHS(cast<AttributeHandleSetImp>()(desiredAttributes).getAttributeHandles());
 
     privateRefs->executeService(&req, &rep);
 }
 
 // ----------------------------------------------------------------------------
 // Attribute Ownership Release Response
-AttributeHandleSet*
+RTI::AttributeHandleSet*
 RTI::RTIambassador::
 attributeOwnershipReleaseResponse(ObjectHandle theObject,
                                   const AttributeHandleSet& attrs)
-    throw (ObjectNotKnown,
-           AttributeNotDefined,
-           AttributeNotOwned,
-           FederateWasNotAskedToReleaseAttribute,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::ObjectNotKnown,
+           RTI::AttributeNotDefined,
+           RTI::AttributeNotOwned,
+           RTI::FederateWasNotAskedToReleaseAttribute,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
     req.type = Message::ATTRIBUTE_OWNERSHIP_RELEASE_RESPONSE ;
     req.setObject(theObject);
-    req.setAHS(attrs);
+    req.setAHS(cast<AttributeHandleSetImp>()(attrs).getAttributeHandles());
 
     privateRefs->executeService(&req, &rep);
 
     if (rep.getExceptionType() == e_NO_EXCEPTION) {
-        return rep.getAHS();
+        return new AttributeHandleSetImp(rep.getAHS());
     }
 
     return NULL ;
@@ -1412,21 +1413,21 @@
 RTI::RTIambassador::
 cancelNegotiatedAttributeOwnershipDivestiture(ObjectHandle theObject,
                                               const AttributeHandleSet& attrs)
-    throw (ObjectNotKnown,
-           AttributeNotDefined,
-           AttributeNotOwned,
-           AttributeDivestitureWasNotRequested,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::ObjectNotKnown,
+           RTI::AttributeNotDefined,
+           RTI::AttributeNotOwned,
+           RTI::AttributeDivestitureWasNotRequested,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
     req.type = Message::CANCEL_NEGOTIATED_ATTRIBUTE_OWNERSHIP_DIVESTITURE ;
     req.setObject(theObject);
-    req.setAHS(attrs);
+    req.setAHS(cast<AttributeHandleSetImp>()(attrs).getAttributeHandles());
 
     privateRefs->executeService(&req, &rep);
 }
@@ -1437,21 +1438,21 @@
 RTI::RTIambassador::
 cancelAttributeOwnershipAcquisition(ObjectHandle theObject,
                                     const AttributeHandleSet& attrs)
-    throw (ObjectNotKnown,
-           AttributeNotDefined,
-           AttributeAlreadyOwned,
-           AttributeAcquisitionWasNotRequested,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::ObjectNotKnown,
+           RTI::AttributeNotDefined,
+           RTI::AttributeAlreadyOwned,
+           RTI::AttributeAcquisitionWasNotRequested,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
     req.type = Message::CANCEL_ATTRIBUTE_OWNERSHIP_ACQUISITION ;
     req.setObject(theObject);
-    req.setAHS(attrs);
+    req.setAHS(cast<AttributeHandleSetImp>()(attrs).getAttributeHandles());
 
     privateRefs->executeService(&req, &rep);
 }
@@ -1462,23 +1463,23 @@
 RTI::RTIambassador::
 attributeOwnershipAcquisitionIfAvailable(ObjectHandle theObject,
                                          const AttributeHandleSet& desired)
-    throw (ObjectNotKnown,
-           ObjectClassNotPublished,
-           AttributeNotDefined,
-           AttributeNotPublished,
-           FederateOwnsAttributes,
-           AttributeAlreadyBeingAcquired,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::ObjectNotKnown,
+           RTI::ObjectClassNotPublished,
+           RTI::AttributeNotDefined,
+           RTI::AttributeNotPublished,
+           RTI::FederateOwnsAttributes,
+           RTI::AttributeAlreadyBeingAcquired,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
     req.type = Message::ATTRIBUTE_OWNERSHIP_ACQUISITION_IF_AVAILABLE ;
     req.setObject(theObject);
-    req.setAHS(desired);
+    req.setAHS(cast<AttributeHandleSetImp>()(desired).getAttributeHandles());
 
     privateRefs->executeService(&req, &rep);
 }
@@ -1508,13 +1509,13 @@
 RTI::Boolean
 RTI::RTIambassador::isAttributeOwnedByFederate(ObjectHandle theObject,
                                           AttributeHandle theAttribute)
-    throw (ObjectNotKnown,
-           AttributeNotDefined,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::ObjectNotKnown,
+           RTI::AttributeNotDefined,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -1565,14 +1566,14 @@
 // Enable Time Constrained
 void
 RTI::RTIambassador::enableTimeConstrained()
-    throw (TimeConstrainedAlreadyEnabled, //not implemented
-           EnableTimeConstrainedPending, //not implemented
-           TimeAdvanceAlreadyInProgress, //not implemented
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::TimeConstrainedAlreadyEnabled, //not implemented
+           RTI::EnableTimeConstrainedPending, //not implemented
+           RTI::TimeAdvanceAlreadyInProgress, //not implemented
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -1585,12 +1586,12 @@
 // Disable Time Constrained
 void
 RTI::RTIambassador::disableTimeConstrained()
-    throw (TimeConstrainedWasNotEnabled, //not implemented
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::TimeConstrainedWasNotEnabled, //not implemented
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -1603,16 +1604,16 @@
 // Time Advance Request
 void
 RTI::RTIambassador::timeAdvanceRequest(const FedTime& theTime)
-    throw (TimeAdvanceAlreadyInProgress,
-           FederationTimeAlreadyPassed,
-           InvalidFederationTime,
-           EnableTimeRegulationPending, //not implemented
-           EnableTimeConstrainedPending, //not implemented
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::TimeAdvanceAlreadyInProgress,
+           RTI::FederationTimeAlreadyPassed,
+           RTI::InvalidFederationTime,
+           RTI::EnableTimeRegulationPending, //not implemented
+           RTI::EnableTimeConstrainedPending, //not implemented
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -1643,16 +1644,16 @@
 // Next Event Request
 void
 RTI::RTIambassador::nextEventRequest(const FedTime& theTime)
-    throw (TimeAdvanceAlreadyInProgress,
-           FederationTimeAlreadyPassed,
-           InvalidFederationTime,
-           EnableTimeRegulationPending, //not implemented
-           EnableTimeConstrainedPending, //not implemented
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::TimeAdvanceAlreadyInProgress,
+           RTI::FederationTimeAlreadyPassed,
+           RTI::InvalidFederationTime,
+           RTI::EnableTimeRegulationPending, //not implemented
+           RTI::EnableTimeConstrainedPending, //not implemented
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -1682,18 +1683,18 @@
 // Flush Queue Request
 void
 RTI::RTIambassador::flushQueueRequest(const FedTime& theTime)
-    throw (TimeAdvanceAlreadyInProgress,
-           FederationTimeAlreadyPassed,
-           InvalidFederationTime,
-           EnableTimeRegulationPending, //not implemented
-           EnableTimeConstrainedPending, //not implemented
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::TimeAdvanceAlreadyInProgress,
+           RTI::FederationTimeAlreadyPassed,
+           RTI::InvalidFederationTime,
+           RTI::EnableTimeRegulationPending, //not implemented
+           RTI::EnableTimeConstrainedPending, //not implemented
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
-    throw RTIinternalError("Unimplemented Service flushQueueRequest");
+    throw RTI::RTIinternalError("Unimplemented Service flushQueueRequest");
     Message req, rep ;
 
     req.type = Message::FLUSH_QUEUE_REQUEST ;
@@ -1738,11 +1739,11 @@
 // Query LBTS
 void
 RTI::RTIambassador::queryLBTS(FedTime& theTime)
-    throw (FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -1756,11 +1757,11 @@
 // Query Federate Time
 void
 RTI::RTIambassador::queryFederateTime(FedTime& theTime)
-    throw (FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -1774,11 +1775,11 @@
 // Query Minimum Next Event Time
 void
 RTI::RTIambassador::queryMinNextEventTime(FedTime& theTime)
-    throw (FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -1786,7 +1787,6 @@
     privateRefs->executeService(&req, &rep);
 
     theTime = rep.getFedTime();
-
 }
 
 // ----------------------------------------------------------------------------
@@ -1809,11 +1809,11 @@
 // Query Lookahead
 void
 RTI::RTIambassador::queryLookahead(FedTime &theTime)
-    throw (FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -1825,7 +1825,7 @@
         ret = RTIfedTime((Double) rep.getFederationTimeDelta());
     }
     catch (std::bad_cast) {
-	throw RTIinternalError("theTime is not a RTIfedTime object");
+	throw RTI::RTIinternalError("theTime is not a RTIfedTime object");
     }
 }
 
@@ -1837,7 +1837,7 @@
 	   RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember, 
 	   RTI::InvalidRetractionHandle)
 {
-    throw RTIinternalError("Unimplemented Service retract");
+    throw RTI::RTIinternalError("Unimplemented Service retract");
     Message req, rep ;
 
     req.type = Message::RETRACT ;
@@ -1862,7 +1862,7 @@
     req.type = Message::CHANGE_ATTRIBUTE_ORDER_TYPE ;
     req.setObject(theObject);
     req.setOrdering(theType);
-    req.setAHS(attrs);
+    req.setAHS(cast<AttributeHandleSetImp>()(attrs).getAttributeHandles());
 
     privateRefs->executeService(&req, &rep);
 }
@@ -1894,20 +1894,20 @@
  */
 RTI::Region *
 RTI::RTIambassador::createRegion(SpaceHandle space, ULong nb_extents)
-    throw (SpaceNotDefined,
-           InvalidExtents,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::SpaceNotDefined,
+           RTI::InvalidExtents,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
     req.setType(Message::DDM_CREATE_REGION);
     req.setSpace(space);
     req.setNumber(nb_extents);
     privateRefs->executeService(&req, &rep);
-    Region *region = new FedRegion(rep.getRegion(), space,
+    RTI::Region *region = new RegionImp(rep.getRegion(), space,
 				   std::vector<Extent>(nb_extents,
 						       Extent(rep.getNumber())));
 
@@ -1922,13 +1922,13 @@
  */
 void
 RTI::RTIambassador::notifyAboutRegionModification(Region &r)
-    throw (RegionNotKnown,
-           InvalidExtents,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::RegionNotKnown,
+           RTI::InvalidExtents,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     try {
 	FedRegion &region = dynamic_cast<FedRegion &>(r);
@@ -1958,13 +1958,13 @@
  */
 void
 RTI::RTIambassador::deleteRegion(Region *region)
-    throw (RegionNotKnown,
-           RegionInUse,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::RegionNotKnown,
+           RTI::RegionInUse,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     if (region == 0) {
         throw RegionNotKnown("");
@@ -1992,18 +1992,18 @@
                                                 AttributeHandle attrs[],
                                                 Region *regions[],
                                                 ULong nb)
-    throw (ObjectClassNotDefined,
-           ObjectClassNotPublished,
-           AttributeNotDefined,
-           AttributeNotPublished,
-           RegionNotKnown,
-           InvalidRegionContext,
-           ObjectAlreadyRegistered,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::ObjectClassNotDefined,
+           RTI::ObjectClassNotPublished,
+           RTI::AttributeNotDefined,
+           RTI::AttributeNotPublished,
+           RTI::RegionNotKnown,
+           RTI::InvalidRegionContext,
+           RTI::ObjectAlreadyRegistered,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -2027,17 +2027,17 @@
                                                 AttributeHandle attrs[],
                                                 Region *regions[],
                                                 ULong nb)
-    throw (ObjectClassNotDefined,
-           ObjectClassNotPublished,
-           AttributeNotDefined,
-           AttributeNotPublished,
-           RegionNotKnown,
-           InvalidRegionContext,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::ObjectClassNotDefined,
+           RTI::ObjectClassNotPublished,
+           RTI::AttributeNotDefined,
+           RTI::AttributeNotPublished,
+           RTI::RegionNotKnown,
+           RTI::InvalidRegionContext,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -2063,15 +2063,15 @@
 RTI::RTIambassador::associateRegionForUpdates(Region &region,
                                          ObjectHandle object,
                                          const AttributeHandleSet &attributes)
-    throw (ObjectNotKnown,
-           AttributeNotDefined,
-           InvalidRegionContext,
-           RegionNotKnown,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::ObjectNotKnown,
+           RTI::AttributeNotDefined,
+           RTI::InvalidRegionContext,
+           RTI::RegionNotKnown,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     D[pdDebug] << "+ Associate Region for Updates" << endl ;
 
@@ -2080,7 +2080,7 @@
     req.type = Message::DDM_ASSOCIATE_REGION ;
     req.setObject(object);
     req.setRegion(get_handle(region));
-    req.setAHS(attributes);
+    req.setAHS(cast<AttributeHandleSetImp>()(attributes).getAttributeHandles());
 
     privateRefs->executeService(&req, &rep);
     D[pdDebug] << "- Associate Region for Updates" << endl ;
@@ -2096,14 +2096,14 @@
 void
 RTI::RTIambassador::unassociateRegionForUpdates(Region &region,
                                            ObjectHandle object)
-    throw (ObjectNotKnown,
-           InvalidRegionContext,
-           RegionNotKnown,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::ObjectNotKnown,
+           RTI::InvalidRegionContext,
+           RTI::RegionNotKnown,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     D[pdDebug] << "+ Unassociate Region for Updates" << endl ;
     Message req, rep ;
@@ -2130,15 +2130,15 @@
     Region &region,
     const AttributeHandleSet &attributes,
     Boolean passive)
-    throw (ObjectClassNotDefined,
-           AttributeNotDefined,
-           RegionNotKnown,
-           InvalidRegionContext,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::ObjectClassNotDefined,
+           RTI::AttributeNotDefined,
+           RTI::RegionNotKnown,
+           RTI::InvalidRegionContext,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     D[pdDebug] << "+ Subscribe Object Class Attributes with Region" << endl ;
     Message req, rep ;
@@ -2146,7 +2146,7 @@
     req.type = Message::DDM_SUBSCRIBE_ATTRIBUTES ;
     req.setObjectClass(object_class);
     req.setRegion(get_handle(region));
-    req.setAHS(attributes);
+    req.setAHS(cast<AttributeHandleSetImp>()(attributes).getAttributeHandles());
     req.setBoolean(passive);
 
     privateRefs->executeService(&req, &rep);
@@ -2162,14 +2162,14 @@
 void
 RTI::RTIambassador::unsubscribeObjectClassWithRegion(ObjectClassHandle object_class,
                                                 Region &region)
-    throw (ObjectClassNotDefined,
-           RegionNotKnown,
-           ObjectClassNotSubscribed,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::ObjectClassNotDefined,
+           RTI::RegionNotKnown,
+           RTI::ObjectClassNotSubscribed,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     D[pdDebug] << "+ Unsubscribe Object Class " << object_class
 	       << " with Region" << endl ;
@@ -2189,15 +2189,15 @@
 RTI::RTIambassador::subscribeInteractionClassWithRegion(InteractionClassHandle ic,
                                                    Region &region,
                                                    RTI::Boolean passive)
-    throw (InteractionClassNotDefined,
-           RegionNotKnown,
-           InvalidRegionContext,
-           FederateLoggingServiceCalls,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::InteractionClassNotDefined,
+           RTI::RegionNotKnown,
+           RTI::InvalidRegionContext,
+           RTI::FederateLoggingServiceCalls,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -2214,14 +2214,14 @@
 void
 RTI::RTIambassador::unsubscribeInteractionClassWithRegion(InteractionClassHandle ic,
                                                      Region &region)
-    throw (InteractionClassNotDefined,
-           InteractionClassNotSubscribed,
-           RegionNotKnown,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::InteractionClassNotDefined,
+           RTI::InteractionClassNotSubscribed,
+           RTI::RegionNotKnown,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -2240,27 +2240,27 @@
                                          const FedTime &time,
                                          const char *tag,
                                          const Region &region)
-    throw (InteractionClassNotDefined,
-           InteractionClassNotPublished,
-           InteractionParameterNotDefined,
-           InvalidFederationTime,
-           RegionNotKnown,
-           InvalidRegionContext,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::InteractionClassNotDefined,
+           RTI::InteractionClassNotPublished,
+           RTI::InteractionParameterNotDefined,
+           RTI::InvalidFederationTime,
+           RTI::RegionNotKnown,
+           RTI::InvalidRegionContext,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
     req.setType(Message::SEND_INTERACTION);
     req.setInteractionClass(interaction);
-    req.setPHVPS(par);
+    req.setPHVPS(cast<ParameterHandleValuePairSetImp>()(par).getParameterHandleValuePairs());
     req.setFedTime(time);
     if ( tag == NULL )
        {
-       throw RTIinternalError ("Calling sendInteractionWithRegion with Tag NULL");
+       throw RTI::RTIinternalError ("Calling sendInteractionWithRegion with Tag NULL");
        }
     req.setTag(tag);
     req.setRegion(get_handle(region));
@@ -2276,25 +2276,25 @@
                                          const ParameterHandleValuePairSet &par,
                                          const char *tag,
                                          const Region &region)
-    throw (InteractionClassNotDefined,
-           InteractionClassNotPublished,
-           InteractionParameterNotDefined,
-           RegionNotKnown,
-           InvalidRegionContext,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           SaveInProgress,
-           RestoreInProgress,
-           RTIinternalError)
+    throw (RTI::InteractionClassNotDefined,
+           RTI::InteractionClassNotPublished,
+           RTI::InteractionParameterNotDefined,
+           RTI::RegionNotKnown,
+           RTI::InvalidRegionContext,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::SaveInProgress,
+           RTI::RestoreInProgress,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
     req.setType(Message::SEND_INTERACTION);
     req.setInteractionClass(interaction);
-    req.setPHVPS(par);
+    req.setPHVPS(cast<ParameterHandleValuePairSetImp>()(par).getParameterHandleValuePairs());
     if ( tag == NULL )
        {
-       throw RTIinternalError ("Calling sendInteractionWithRegion with Tag NULL");
+       throw RTI::RTIinternalError ("Calling sendInteractionWithRegion with Tag NULL");
        }
     req.setTag(tag);
     req.setRegion(get_handle(region));
@@ -2312,11 +2312,11 @@
 	   RTI::ConcurrentAccessAttempted, RTI::FederateNotExecutionMember, 
 	   RTI::RegionNotKnown, RTI::AttributeNotDefined, RTI::ObjectClassNotDefined)
 {
-    throw UnimplementedService("");
+    throw RTI::RTIinternalError("unimplemented service requestClassAttributeValueUpdateWithRegion");
 
     Message req, rep ;
     req.setType(Message::DDM_REQUEST_UPDATE);
-    req.setAHS(attrs);
+    req.setAHS(cast<AttributeHandleSetImp>()(attrs).getAttributeHandles());
     req.setRegion(get_handle(region));
     privateRefs->executeService(&req, &rep);    
 }
@@ -2327,10 +2327,10 @@
  */
 ObjectClassHandle
 RTI::RTIambassador::getObjectClassHandle(const char *theName)
-    throw (NameNotFound,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           RTIinternalError)
+    throw (RTI::NameNotFound,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -2353,10 +2353,10 @@
 */
 char *
 RTI::RTIambassador::getObjectClassName(ObjectClassHandle handle)
-    throw (ObjectClassNotDefined,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           RTIinternalError)
+    throw (RTI::ObjectClassNotDefined,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
     req.type = Message::GET_OBJECT_CLASS_NAME ;
@@ -2373,12 +2373,11 @@
 AttributeHandle
 RTI::RTIambassador::getAttributeHandle(const char *theName,
                                   ObjectClassHandle whichClass)
-    throw (ObjectClassNotDefined,
-           NameNotFound,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           RTIinternalError)
-
+    throw (RTI::ObjectClassNotDefined,
+           RTI::NameNotFound,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::RTIinternalError)
 {
     G.Out(pdGendoc,"enter RTI::RTIambassador::getAttributeHandle");
     Message req, rep ;
@@ -2399,11 +2398,11 @@
 char *
 RTI::RTIambassador::getAttributeName(AttributeHandle theHandle,
                                 ObjectClassHandle whichClass)
-    throw (ObjectClassNotDefined,
-           AttributeNotDefined,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           RTIinternalError)
+    throw (RTI::ObjectClassNotDefined,
+           RTI::AttributeNotDefined,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
     req.type = Message::GET_ATTRIBUTE_NAME ;
@@ -2417,10 +2416,10 @@
 // Get Interaction Class Handle
 InteractionClassHandle
 RTI::RTIambassador::getInteractionClassHandle(const char *theName)
-    throw (NameNotFound,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           RTIinternalError)
+    throw (RTI::NameNotFound,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -2436,10 +2435,10 @@
 // Get Interaction Class Name
 char *
 RTI::RTIambassador::getInteractionClassName(InteractionClassHandle theHandle)
-    throw (InteractionClassNotDefined,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           RTIinternalError)
+    throw (RTI::InteractionClassNotDefined,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -2456,11 +2455,11 @@
 ParameterHandle
 RTI::RTIambassador::getParameterHandle(const char *theName,
                                   InteractionClassHandle whichClass)
-    throw (InteractionClassNotDefined,
-           NameNotFound,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           RTIinternalError)
+    throw (RTI::InteractionClassNotDefined,
+           RTI::NameNotFound,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -2478,11 +2477,11 @@
 char *
 RTI::RTIambassador::getParameterName(ParameterHandle theHandle,
                                 InteractionClassHandle whichClass)
-    throw (InteractionClassNotDefined,
-           InteractionParameterNotDefined,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           RTIinternalError)
+    throw (RTI::InteractionClassNotDefined,
+           RTI::InteractionParameterNotDefined,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
 
@@ -2535,10 +2534,10 @@
  */
 SpaceHandle
 RTI::RTIambassador::getRoutingSpaceHandle(const char *rs_name)
-    throw (NameNotFound,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           RTIinternalError)
+    throw (RTI::NameNotFound,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::RTIinternalError)
 {
     D[pdDebug] << "Get routing space handle: " << rs_name << endl ;
     Message req, rep ;
@@ -2554,10 +2553,10 @@
  */
 char *
 RTI::RTIambassador::getRoutingSpaceName(SpaceHandle handle)
-    throw (SpaceNotDefined,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           RTIinternalError)
+    throw (RTI::SpaceNotDefined,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
     req.type = Message::GET_SPACE_NAME ;
@@ -2574,11 +2573,11 @@
 DimensionHandle
 RTI::RTIambassador::getDimensionHandle(const char *dimension,
                                   SpaceHandle space)
-    throw (SpaceNotDefined,
-           NameNotFound,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           RTIinternalError)
+    throw (RTI::SpaceNotDefined,
+           RTI::NameNotFound,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
     req.type = Message::GET_DIMENSION_HANDLE ;
@@ -2596,11 +2595,11 @@
 char *
 RTI::RTIambassador::getDimensionName(DimensionHandle dimension,
                                 SpaceHandle space)
-    throw (SpaceNotDefined,
-           DimensionNotDefined,
-           FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-           RTIinternalError)
+    throw (RTI::SpaceNotDefined,
+           RTI::DimensionNotDefined,
+           RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
     req.type = Message::GET_DIMENSION_NAME ;
@@ -2619,11 +2618,11 @@
 SpaceHandle
 RTI::RTIambassador::getAttributeRoutingSpaceHandle(AttributeHandle attribute,
                                               ObjectClassHandle object_class)
-    throw (ObjectClassNotDefined,
-	   AttributeNotDefined,
-           FederateNotExecutionMember,
-	   ConcurrentAccessAttempted,
-           RTIinternalError)
+    throw (RTI::ObjectClassNotDefined,
+	   RTI::AttributeNotDefined,
+           RTI::FederateNotExecutionMember,
+	   RTI::ConcurrentAccessAttempted,
+           RTI::RTIinternalError)
 {
     Message req, rep ;
     req.type = Message::GET_ATTRIBUTE_SPACE_HANDLE ;
@@ -2654,10 +2653,10 @@
  */
 SpaceHandle
 RTI::RTIambassador::getInteractionRoutingSpaceHandle(InteractionClassHandle inter)
-    throw (InteractionClassNotDefined,
-	   FederateNotExecutionMember,
-           ConcurrentAccessAttempted,
-	   RTIinternalError)
+    throw (RTI::InteractionClassNotDefined,
+	   RTI::FederateNotExecutionMember,
+           RTI::ConcurrentAccessAttempted,
+	   RTI::RTIinternalError)
 {
     Message req, rep ;
     req.type = Message::GET_INTERACTION_SPACE_HANDLE ;
diff --exclude=CVS -Nru certi/libRTI/RTIambPrivateRefs.cc certi.new/libRTI/RTIambPrivateRefs.cc
--- certi/libRTI/RTIambPrivateRefs.cc	2008-11-06 15:28:58.000000000 +0100
+++ certi.new/libRTI/RTIambPrivateRefs.cc	2008-12-05 18:23:46.000000000 +0100
@@ -24,6 +24,7 @@
 
 #include <config.h>
 #include "RTIambPrivateRefs.hh"
+#include "HandleSets.hh"
 #include "PrettyDebug.hh"
 #include <sstream>
 
@@ -48,11 +49,11 @@
 
 // ----------------------------------------------------------------------------
 void
-RTIambPrivateRefs::leave(const char *msg) throw (RTIinternalError)
+RTIambPrivateRefs::leave(const char *msg) throw (RTI::RTIinternalError)
 {
 	std::stringstream smsg;
 	smsg << "RTI called leave because <" <<msg<<">"; 
-	throw RTIinternalError(smsg.str().c_str());   
+    throw RTI::RTIinternalError(smsg.str().c_str());
 }
 
 // ----------------------------------------------------------------------------
@@ -68,7 +69,7 @@
     }
     catch (NetworkError) {
         std::cerr << "libRTI: exception: NetworkError (write)" << std::endl ;
-        throw RTIinternalError("libRTI: Network Write Error");
+        throw RTI::RTIinternalError("libRTI: Network Write Error");
     }
 
     D.Out(pdDebug, "waiting RTIA reply.");
@@ -79,7 +80,7 @@
     }
     catch (NetworkError) {
         std::cerr << "libRTI: exception: NetworkError (read)" << std::endl ;
-        throw RTIinternalError("libRTI: Network Read Error waiting RTI reply");
+        throw RTI::RTIinternalError("libRTI: Network Read Error waiting RTI reply");
     }
 
     D.Out(pdDebug, "RTIA reply received.");
@@ -87,7 +88,7 @@
 
     if (rep->type != req->type) {
         std::cout << "LibRTI: Assertion failed: rep->type != req->type" << std::endl ;
-        throw RTIinternalError("RTIambPrivateRefs::executeService: "
+        throw RTI::RTIinternalError("RTIambPrivateRefs::executeService: "
                                "rep->type != req->type");
     }
 
@@ -113,7 +114,7 @@
     }
     catch (NetworkError) {
         std::cerr << "libRTI: exception: NetworkError (write)" << std::endl ;
-        throw RTIinternalError("libRTI: Network Write Error");
+        throw RTI::RTIinternalError("libRTI: Network Write Error");
     }
 
     try {
@@ -121,7 +122,7 @@
     }
     catch (NetworkError) {
         std::cerr << "libRTI: exception: NetworkError (read)" << std::endl ;
-        throw RTIinternalError("libRTI: Network Read Error waiting RTI reply");
+        throw RTI::RTIinternalError("libRTI: Network Read Error waiting RTI reply");
     }
 
     // ignore the response, ignore exceptions
@@ -145,162 +146,162 @@
 
       case e_ArrayIndexOutOfBounds: {
           D.Out(pdExcept, "Throwing e_ArrayIndexOutOfBounds exception.");
-          throw ArrayIndexOutOfBounds(msg->getExceptionReason());
+          throw RTI::ArrayIndexOutOfBounds(msg->getExceptionReason());
       } break ;
 
       case e_AsynchronousDeliveryAlreadyEnabled: {
           D.Out(pdExcept, "Throwing e_AsynchronousDeliveryAlreadyEnabled exception.");
-          throw AsynchronousDeliveryAlreadyEnabled(msg->getExceptionReason());
+          throw RTI::AsynchronousDeliveryAlreadyEnabled(msg->getExceptionReason());
       } break ;
 
       case e_AsynchronousDeliveryAlreadyDisabled: {
           D.Out(pdExcept, "Throwing e_AsynchronousDeliveryAlreadyDisabled exception.");
-          throw AsynchronousDeliveryAlreadyDisabled(msg->getExceptionReason());
+          throw RTI::AsynchronousDeliveryAlreadyDisabled(msg->getExceptionReason());
       } break ;
 
       case e_AttributeAlreadyOwned: {
           D.Out(pdExcept, "Throwing e_AttributeAlreadyOwned exception.");
-          throw AttributeAlreadyOwned(msg->getExceptionReason());
+          throw RTI::AttributeAlreadyOwned(msg->getExceptionReason());
       } break ;
 
       case e_AttributeAlreadyBeingAcquired: {
           D.Out(pdExcept,
 		"Throwing e_AttributeAlreadyBeingAcquired exception.");
-          throw AttributeAlreadyBeingAcquired(msg->getExceptionReason());
+          throw RTI::AttributeAlreadyBeingAcquired(msg->getExceptionReason());
       } break ;
 
       case e_AttributeAlreadyBeingDivested: {
           D.Out(pdExcept,
 		"Throwing e_AttributeAlreadyBeingDivested exception.");
-          throw AttributeAlreadyBeingDivested(msg->getExceptionReason());
+          throw RTI::AttributeAlreadyBeingDivested(msg->getExceptionReason());
       } break ;
 
       case e_AttributeDivestitureWasNotRequested: {
           D.Out(pdExcept,
                 "Throwing e_AttributeDivestitureWasNotRequested exception.");
-          throw AttributeDivestitureWasNotRequested(msg->getExceptionReason());
+          throw RTI::AttributeDivestitureWasNotRequested(msg->getExceptionReason());
       } break ;
 
       case e_AttributeAcquisitionWasNotRequested: {
           D.Out(pdExcept,
                 "Throwing e_AttributeAcquisitionWasNotRequested exception.");
-          throw AttributeAcquisitionWasNotRequested(msg->getExceptionReason());
+          throw RTI::AttributeAcquisitionWasNotRequested(msg->getExceptionReason());
       } break ;
 
       case e_AttributeNotDefined: {
           D.Out(pdExcept, "Throwing e_AttributeNotDefined exception.");
-          throw AttributeNotDefined(msg->getExceptionReason());
+          throw RTI::AttributeNotDefined(msg->getExceptionReason());
       } break ;
 
       case e_AttributeNotKnown: {
           D.Out(pdExcept, "Throwing e_AttributeNotKnown exception.");
-          throw AttributeNotKnown(msg->getExceptionReason());
+          throw RTI::AttributeNotKnown(msg->getExceptionReason());
       } break ;
 
       case e_AttributeNotOwned: {
           D.Out(pdExcept, "Throwing e_AttributeNotOwned exception.");
-          throw AttributeNotOwned(msg->getExceptionReason());
+          throw RTI::AttributeNotOwned(msg->getExceptionReason());
       } break ;
 
       case e_AttributeNotPublished: {
           D.Out(pdExcept, "Throwing e_AttributeNotPublished exception.");
-          throw AttributeNotPublished(msg->getExceptionReason());
+          throw RTI::AttributeNotPublished(msg->getExceptionReason());
       } break ;
 
       case e_AttributeNotSubscribed: {
           D.Out(pdExcept, "Throwing e_AttributeNotSubscribed exception.");
-          throw AttributeNotSubscribed(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_ConcurrentAccessAttempted: {
           D.Out(pdExcept, "Throwing e_ConcurrentAccessAttempted exception.");
-          throw ConcurrentAccessAttempted(msg->getExceptionReason());
+          throw RTI::ConcurrentAccessAttempted(msg->getExceptionReason());
       } break ;
 
       case e_CouldNotDiscover: {
           D.Out(pdExcept, "Throwing e_CouldNotDiscover exception.");
-          throw CouldNotDiscover(msg->getExceptionReason());
+          throw RTI::CouldNotDiscover(msg->getExceptionReason());
       } break ;
 
       case e_CouldNotOpenFED: {
           D.Out(pdExcept, "Throwing e_CouldNotOpenFED exception.");
-          throw CouldNotOpenFED(msg->getExceptionReason());
+          throw RTI::CouldNotOpenFED(msg->getExceptionReason());
       } break ;
 
       case e_CouldNotOpenRID: {
           D.Out(pdExcept, "Throwing e_CouldNotOpenRID exception.");
-          throw CouldNotOpenRID(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_CouldNotRestore: {
           D.Out(pdExcept, "Throwing e_CouldNotRestore exception.");
-          throw CouldNotRestore(msg->getExceptionReason());
+          throw RTI::CouldNotRestore(msg->getExceptionReason());
       } break ;
 
       case e_DeletePrivilegeNotHeld: {
           D.Out(pdExcept, "Throwing e_DeletePrivilegeNotHeld exception.");
-          throw DeletePrivilegeNotHeld(msg->getExceptionReason());
+          throw RTI::DeletePrivilegeNotHeld(msg->getExceptionReason());
       } break ;
 
       case e_ErrorReadingRID: {
           D.Out(pdExcept, "Throwing e_ErrorReadingRID exception.");
-          throw ErrorReadingRID(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_ErrorReadingFED: {
           D.Out(pdExcept, "Throwing e_ErrorReadingFED exception.");
-          throw ErrorReadingFED(msg->getExceptionReason());
+          throw RTI::ErrorReadingFED(msg->getExceptionReason());
       } break ;
 
       case e_EventNotKnown: {
           D.Out(pdExcept, "Throwing e_EventNotKnown exception.");
-          throw EventNotKnown(msg->getExceptionReason());
+          throw RTI::EventNotKnown(msg->getExceptionReason());
       } break ;
 
       case e_FederateAlreadyPaused: {
           D.Out(pdExcept, "Throwing e_FederateAlreadyPaused exception.");
-          throw FederateAlreadyPaused(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_FederateAlreadyExecutionMember: {
           D.Out(pdExcept,
 		"Throwing e_FederateAlreadyExecutionMember exception.");
-          throw FederateAlreadyExecutionMember(msg->getExceptionReason());
+          throw RTI::FederateAlreadyExecutionMember(msg->getExceptionReason());
       } break ;
 
       case e_FederateDoesNotExist: {
           D.Out(pdExcept, "Throwing e_FederateDoesNotExist exception.");
-          throw FederateDoesNotExist(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_FederateInternalError: {
           D.Out(pdExcept, "Throwing e_FederateInternalError exception.");
-          throw FederateInternalError(msg->getExceptionReason());
+          throw RTI::FederateInternalError(msg->getExceptionReason());
       } break ;
 
       case e_FederateNameAlreadyInUse: {
           D.Out(pdExcept, "Throwing e_FederateNameAlreadyInUse exception.");
-          throw FederateNameAlreadyInUse(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_FederateNotExecutionMember: {
           D.Out(pdExcept, "Throwing e_FederateNotExecutionMember exception.");
-          throw FederateNotExecutionMember(msg->getExceptionReason());
+          throw RTI::FederateNotExecutionMember(msg->getExceptionReason());
       } break ;
 
       case e_FederateNotPaused: {
           D.Out(pdExcept, "Throwing e_FederateNotPaused exception.");
-          throw FederateNotPaused(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_FederateOwnsAttributes: {
           D.Out(pdExcept, "Throwing e_FederateOwnsAttributes exception.");
-          throw FederateOwnsAttributes(msg->getExceptionReason());
+          throw RTI::FederateOwnsAttributes(msg->getExceptionReason());
       } break ;
 
       case e_FederatesCurrentlyJoined: {
           D.Out(pdExcept, "Throwing e_FederatesCurrentlyJoined exception.");
-          throw FederatesCurrentlyJoined(msg->getExceptionReason());
+          throw RTI::FederatesCurrentlyJoined(msg->getExceptionReason());
       } break ;
 
       case e_FederateWasNotAskedToReleaseAttribute: {
@@ -308,266 +309,265 @@
                 "Throwing e_FederateWasNotAskedToReleaseAttribute exception.");
           D.Out(pdDebug,
                 "Throwing e_FederateWasNotAskedToReleaseAttribute exception.");
-          throw
-	      FederateWasNotAskedToReleaseAttribute(msg->getExceptionReason());
+          throw RTI::FederateWasNotAskedToReleaseAttribute(msg->getExceptionReason());
       } break ;
 
       case e_FederationAlreadyPaused: {
           D.Out(pdExcept, "Throwing e_FederationAlreadyPaused exception.");
-          throw FederationAlreadyPaused(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_FederationExecutionAlreadyExists: {
           D.Out(pdExcept, "Throwing e_FederationExecutionAlreadyExists excep.");
-          throw FederationExecutionAlreadyExists(msg->getExceptionReason());
+          throw RTI::FederationExecutionAlreadyExists(msg->getExceptionReason());
       } break ;
 
       case e_FederationExecutionDoesNotExist: {
           D.Out(pdExcept, "Throwing e_FederationExecutionDoesNotExist except.");
-          throw FederationExecutionDoesNotExist(msg->getExceptionReason());
+          throw RTI::FederationExecutionDoesNotExist(msg->getExceptionReason());
       } break ;
 
       case e_FederationNotPaused: {
           D.Out(pdExcept, "Throwing e_FederationNotPaused exception.");
-          throw FederationNotPaused(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_FederationTimeAlreadyPassed: {
           D.Out(pdExcept, "Throwing e_FederationTimeAlreadyPassed exception.");
-          throw FederationTimeAlreadyPassed(msg->getExceptionReason());
+          throw RTI::FederationTimeAlreadyPassed(msg->getExceptionReason());
       } break ;
 
       case e_FederateNotPublishing: {
           D.Out(pdExcept, "Throwing e_FederateNotPublishing exception.");
-          throw FederateNotPublishing(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_FederateNotSubscribing: {
           D.Out(pdExcept, "Throwing e_FederateNotSubscribing exception.");
-          throw FederateNotSubscribing(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_RegionNotKnown: {
           D.Out(pdExcept, "Throwing e_RegionNotKnown exception.");
-          throw RegionNotKnown(msg->getExceptionReason());
+          throw RTI::RegionNotKnown(msg->getExceptionReason());
       } break ;
 
       case e_IDsupplyExhausted: {
           D.Out(pdExcept, "Throwing e_IDsupplyExhausted exception.");
-          throw IDsupplyExhausted(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_InteractionClassNotDefined: {
           D.Out(pdExcept, "Throwing e_InteractionClassNotDefined exception.");
-          throw InteractionClassNotDefined(msg->getExceptionReason());
+          throw RTI::InteractionClassNotDefined(msg->getExceptionReason());
       } break ;
 
       case e_InteractionClassNotKnown: {
           D.Out(pdExcept, "Throwing e_InteractionClassNotKnown exception.");
-          throw InteractionClassNotKnown(msg->getExceptionReason());
+          throw RTI::InteractionClassNotKnown(msg->getExceptionReason());
       } break ;
 
       case e_InteractionClassNotPublished: {
           D.Out(pdExcept, "Throwing e_InteractionClassNotPublished exception.");
-          throw InteractionClassNotPublished(msg->getExceptionReason());
+          throw RTI::InteractionClassNotPublished(msg->getExceptionReason());
       } break ;
 
       case e_InteractionParameterNotDefined: {
           D.Out(pdExcept,
 		"Throwing e_InteractionParameterNotDefined exception.");
-          throw InteractionParameterNotDefined(msg->getExceptionReason());
+          throw RTI::InteractionParameterNotDefined(msg->getExceptionReason());
       } break ;
 
       case e_InteractionParameterNotKnown: {
           D.Out(pdExcept, "Throwing e_InteractionParameterNotKnown exception.");
-          throw InteractionParameterNotKnown(msg->getExceptionReason());
+          throw RTI::InteractionParameterNotKnown(msg->getExceptionReason());
       } break ;
 
       case e_InvalidDivestitureCondition: {
           D.Out(pdExcept, "Throwing e_InvalidDivestitureCondition exception.");
-          throw InvalidDivestitureCondition(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_InvalidExtents: {
           D.Out(pdExcept, "Throwing e_InvalidExtents exception.");
-          throw InvalidExtents(msg->getExceptionReason());
+          throw RTI::InvalidExtents(msg->getExceptionReason());
       } break ;
 
       case e_InvalidFederationTime: {
           D.Out(pdExcept, "Throwing e_InvalidFederationTime exception.");
-          throw InvalidFederationTime(msg->getExceptionReason());
+          throw RTI::InvalidFederationTime(msg->getExceptionReason());
       } break ;
 
       case e_InvalidFederationTimeDelta: {
           D.Out(pdExcept, "Throwing e_InvalidFederationTimeDelta exception.");
-          throw InvalidFederationTimeDelta(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_InvalidObjectHandle: {
           D.Out(pdExcept, "Throwing e_InvalidObjectHandle exception.");
-          throw InvalidObjectHandle(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_InvalidOrderingHandle: {
           D.Out(pdExcept, "Throwing e_InvalidOrderingHandle exception.");
-          throw InvalidOrderingHandle(msg->getExceptionReason());
+          throw RTI::InvalidOrderingHandle(msg->getExceptionReason());
       } break ;
 
       case e_InvalidResignAction: {
           D.Out(pdExcept, "Throwing e_InvalidResignAction exception.");
-          throw InvalidResignAction(msg->getExceptionReason());
+          throw RTI::InvalidResignAction(msg->getExceptionReason());
       } break ;
 
       case e_InvalidRetractionHandle: {
           D.Out(pdExcept, "Throwing e_InvalidRetractionHandle exception.");
-          throw InvalidRetractionHandle(msg->getExceptionReason());
+          throw RTI::InvalidRetractionHandle(msg->getExceptionReason());
       } break ;
 
       case e_InvalidRoutingSpace: {
           D.Out(pdExcept, "Throwing e_InvalidRoutingSpace exception.");
-          throw InvalidRoutingSpace(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_InvalidTransportationHandle: {
           D.Out(pdExcept, "Throwing e_InvalidTransportationHandle exception.");
-          throw InvalidTransportationHandle(msg->getExceptionReason());
+          throw RTI::InvalidTransportationHandle(msg->getExceptionReason());
       } break ;
 
       case e_MemoryExhausted: {
           D.Out(pdExcept, "Throwing e_MemoryExhausted exception.");
-          throw MemoryExhausted(msg->getExceptionReason());
+          throw RTI::MemoryExhausted(msg->getExceptionReason());
       } break ;
 
       case e_NameNotFound: {
           D.Out(pdExcept, "Throwing e_NameNotFound exception.");
-          throw NameNotFound(msg->getExceptionReason());
+          throw RTI::NameNotFound(msg->getExceptionReason());
       } break ;
 
       case e_NoPauseRequested: {
           D.Out(pdExcept, "Throwing e_NoPauseRequested exception.");
-          throw NoPauseRequested(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_NoResumeRequested: {
           D.Out(pdExcept, "Throwing e_NoResumeRequested exception.");
-          throw NoResumeRequested(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_ObjectClassNotDefined: {
           D.Out(pdExcept, "Throwing e_ObjectClassNotDefined exception.");
-          throw ObjectClassNotDefined(msg->getExceptionReason());
+          throw RTI::ObjectClassNotDefined(msg->getExceptionReason());
       } break ;
 
       case e_ObjectClassNotKnown: {
           D.Out(pdExcept, "Throwing e_ObjectClassNotKnown exception.");
-          throw ObjectClassNotKnown(msg->getExceptionReason());
+          throw RTI::ObjectClassNotKnown(msg->getExceptionReason());
       } break ;
 
       case e_ObjectClassNotPublished: {
           D.Out(pdExcept, "Throwing e_ObjectClassNotPublished exception.");
-          throw ObjectClassNotPublished(msg->getExceptionReason());
+          throw RTI::ObjectClassNotPublished(msg->getExceptionReason());
       } break ;
 
       case e_ObjectClassNotSubscribed: {
           D.Out(pdExcept, "Throwing e_ObjectClassNotSubscribed exception.");
-          throw ObjectClassNotSubscribed(msg->getExceptionReason());
+          throw RTI::ObjectClassNotSubscribed(msg->getExceptionReason());
       } break ;
 
       case e_ObjectNotKnown: {
           D.Out(pdExcept, "Throwing e_ObjectNotKnown exception.");
-          throw ObjectNotKnown(msg->getExceptionReason());
+          throw RTI::ObjectNotKnown(msg->getExceptionReason());
       } break ;
 
       case e_ObjectAlreadyRegistered: {
           D.Out(pdExcept, "Throwing e_ObjectAlreadyRegistered exception.");
-          throw ObjectAlreadyRegistered(msg->getExceptionReason());
+          throw RTI::ObjectAlreadyRegistered(msg->getExceptionReason());
       } break ;
 
       case e_RestoreInProgress: {
           D.Out(pdExcept, "Throwing e_RestoreInProgress exception.");
-          throw RestoreInProgress(msg->getExceptionReason());
+          throw RTI::RestoreInProgress(msg->getExceptionReason());
       } break ;
 
       case e_RestoreNotRequested: {
           D.Out(pdExcept, "Throwing e_RestoreNotRequested exception.");
-          throw RestoreNotRequested(msg->getExceptionReason());
+          throw RTI::RestoreNotRequested(msg->getExceptionReason());
       } break ;
 
       case e_RTIinternalError: {
           D.Out(pdExcept, "Throwing e_RTIinternalError exception.");
-          throw RTIinternalError(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_SpaceNotDefined: {
           D.Out(pdExcept, "Throwing e_SpaceNotDefined exception.");
-          throw SpaceNotDefined(msg->getExceptionReason());
+          throw RTI::SpaceNotDefined(msg->getExceptionReason());
       } break ;
 
       case e_SaveInProgress: {
           D.Out(pdExcept, "Throwing e_SaveInProgress exception.");
-          throw SaveInProgress(msg->getExceptionReason());
+          throw RTI::SaveInProgress(msg->getExceptionReason());
       } break ;
 
       case e_SaveNotInitiated: {
           D.Out(pdExcept, "Throwing e_SaveNotInitiated exception.");
-          throw SaveNotInitiated(msg->getExceptionReason());
+          throw RTI::SaveNotInitiated(msg->getExceptionReason());
       } break ;
 
       case e_SecurityError: {
           D.Out(pdExcept, "Throwing e_SecurityError exception.");
-          throw SecurityError(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_SpecifiedSaveLabelDoesNotExist: {
           D.Out(pdExcept,
 		"Throwing e_SpecifiedSaveLabelDoesNotExist exception.");
-          throw SpecifiedSaveLabelDoesNotExist(msg->getExceptionReason());
+          throw RTI::SpecifiedSaveLabelDoesNotExist(msg->getExceptionReason());
       } break ;
 
       case e_TimeAdvanceAlreadyInProgress: {
           D.Out(pdExcept, "Throwing e_TimeAdvanceAlreadyInProgress exception.");
-          throw TimeAdvanceAlreadyInProgress(msg->getExceptionReason());
+          throw RTI::TimeAdvanceAlreadyInProgress(msg->getExceptionReason());
       } break ;
 
       case e_TimeAdvanceWasNotInProgress: {
           D.Out(pdExcept, "Throwing e_TimeAdvanceWasNotInProgress exception.");
-          throw TimeAdvanceWasNotInProgress(msg->getExceptionReason());
+          throw RTI::TimeAdvanceWasNotInProgress(msg->getExceptionReason());
       } break ;
 
       case e_TooManyIDsRequested: {
           D.Out(pdExcept, "Throwing e_TooManyIDsRequested exception.");
-          throw TooManyIDsRequested(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_UnableToPerformSave: {
           D.Out(pdExcept, "Throwing e_UnableToPerformSave exception.");
-          throw UnableToPerformSave(msg->getExceptionReason());
+          throw RTI::UnableToPerformSave(msg->getExceptionReason());
       } break ;
 
       case e_UnimplementedService: {
           D.Out(pdExcept, "Throwing e_UnimplementedService exception.");
-          throw UnimplementedService(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_UnknownLabel: {
           D.Out(pdExcept, "Throwing e_UnknownLabel exception.");
-          throw UnknownLabel(msg->getExceptionReason());
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
 
       case e_ValueCountExceeded: {
           D.Out(pdExcept, "Throwing e_ValueCountExceeded exception.");
-          throw ValueCountExceeded(msg->getExceptionReason());
+          throw RTI::ValueCountExceeded(msg->getExceptionReason());
       } break ;
 
       case e_ValueLengthExceeded: {
           D.Out(pdExcept, "Throwing e_ValueLengthExceeded exception.");
-          throw ValueLengthExceeded(msg->getExceptionReason());
+          throw RTI::ValueLengthExceeded(msg->getExceptionReason());
       } break ;
 
       default: {
           D.Out(pdExcept, "Throwing unknown exception !");
-          std::cout << "LibRTI: Receiving unknown exception." << std::endl ;
-          throw RTIinternalError(msg->getExceptionReason());
+          std::cout << "LibRTI: Receiving unknown RTI exception." << std::endl;
+          throw RTI::RTIinternalError(msg->getExceptionReason());
       } break ;
     }
 }
@@ -576,12 +576,12 @@
     catch (Exception &e) { \
         std::stringstream msg; \
         msg << "Error in " << service << ": " << e._name << "[" << e._reason << "]"; \
-        throw RTIinternalError(msg.str().c_str()); \
+        throw RTI::RTIinternalError(msg.str().c_str()); \
     }
 
 void
 RTIambPrivateRefs::callFederateAmbassador(Message *msg)
-    throw (RTIinternalError)
+    throw (RTI::RTIinternalError)
 {
     switch (msg->type) {
 
@@ -706,7 +706,9 @@
       case Message::REFLECT_ATTRIBUTE_VALUES:
         try {
             G.Out(pdGendoc,"          tick_kernel call to reflectAttributeValues");
-            RTI::AttributeHandleValuePairSet *attributes = msg->getAHVPS();
+            RTI::AttributeHandleValuePairSet *attributes =
+                new AttributeHandleValuePairSetImp(msg->getAHVPS());
+
             if (msg->getBoolean())
                fed_amb->reflectAttributeValues(msg->getObject(),
                                                *attributes,
@@ -724,7 +726,9 @@
 
       case Message::RECEIVE_INTERACTION:
         try {
-            RTI::ParameterHandleValuePairSet *parameters = msg->getPHVPS();
+            RTI::ParameterHandleValuePairSet *parameters =
+                new ParameterHandleValuePairSetImp(msg->getPHVPS());
+
             if (msg->getBoolean())
                 fed_amb->receiveInteraction(
                                         msg->getInteractionClass(),
@@ -763,7 +767,8 @@
 
       case Message::PROVIDE_ATTRIBUTE_VALUE_UPDATE:
         try {
-            AttributeHandleSet *attributeSet = msg->getAHS();
+            RTI::AttributeHandleSet *attributeSet =
+                new AttributeHandleSetImp(msg->getAHS());
 
             fed_amb->provideAttributeValueUpdate(msg->getObject(),*attributeSet);
             delete attributeSet ;
@@ -777,7 +782,8 @@
 
       case Message::REQUEST_ATTRIBUTE_OWNERSHIP_ASSUMPTION:
         try {
-            AttributeHandleSet *attributeSet = msg->getAHS();
+            RTI::AttributeHandleSet *attributeSet =
+                new AttributeHandleSetImp(msg->getAHS());
 
             fed_amb->
                 requestAttributeOwnershipAssumption(msg->getObject(),
@@ -790,7 +796,8 @@
 
       case Message::REQUEST_ATTRIBUTE_OWNERSHIP_RELEASE:
         try {
-            AttributeHandleSet *attributeSet = msg->getAHS();
+            RTI::AttributeHandleSet *attributeSet =
+                new AttributeHandleSetImp(msg->getAHS());
 
             fed_amb->requestAttributeOwnershipRelease(
                 msg->getObject(),
@@ -804,7 +811,8 @@
 
       case Message::ATTRIBUTE_OWNERSHIP_UNAVAILABLE:
         try {
-            AttributeHandleSet *attributeSet = msg->getAHS();
+            RTI::AttributeHandleSet *attributeSet =
+                new AttributeHandleSetImp(msg->getAHS());
 
             fed_amb->attributeOwnershipUnavailable(msg->getObject(),
                                                        *attributeSet);
@@ -816,7 +824,8 @@
 
       case Message::ATTRIBUTE_OWNERSHIP_ACQUISITION_NOTIFICATION:
         try {
-            AttributeHandleSet *attributeSet = msg->getAHS();
+            RTI::AttributeHandleSet *attributeSet =
+                new AttributeHandleSetImp(msg->getAHS());
 
             fed_amb->attributeOwnershipAcquisitionNotification(
                 msg->getObject(),
@@ -829,7 +838,8 @@
 
       case Message::ATTRIBUTE_OWNERSHIP_DIVESTITURE_NOTIFICATION:
         try {
-            AttributeHandleSet *attributeSet = msg->getAHS();
+            RTI::AttributeHandleSet *attributeSet =
+                new AttributeHandleSetImp(msg->getAHS());
 
             fed_amb->attributeOwnershipDivestitureNotification(
                 msg->getObject(),
@@ -842,7 +852,8 @@
 
       case Message::CONFIRM_ATTRIBUTE_OWNERSHIP_ACQUISITION_CANCELLATION:
         try {
-            AttributeHandleSet *attributeSet = msg->getAHS();
+            RTI::AttributeHandleSet *attributeSet =
+                new AttributeHandleSetImp(msg->getAHS());
 
             fed_amb->confirmAttributeOwnershipAcquisitionCancellation(
                 msg->getObject(),
diff --exclude=CVS -Nru certi/libRTI/RTIambPrivateRefs.hh certi.new/libRTI/RTIambPrivateRefs.hh
--- certi/libRTI/RTIambPrivateRefs.hh	2008-11-06 15:28:58.000000000 +0100
+++ certi.new/libRTI/RTIambPrivateRefs.hh	2008-12-05 18:03:20.000000000 +0100
@@ -38,8 +38,8 @@
     void processException(Message *);
     void executeService(Message *requete, Message *reponse);
     void sendTickRequestStop();
-    void callFederateAmbassador(Message *msg) throw (RTIinternalError);
-    void leave(const char *msg) throw (RTIinternalError);
+    void callFederateAmbassador(Message *msg) throw (RTI::RTIinternalError);
+    void leave(const char *msg) throw (RTI::RTIinternalError);
 
 	#ifdef _WIN32
 	  HANDLE	handle_RTIA;
diff --exclude=CVS -Nru certi/libRTI/RTItypes.cc certi.new/libRTI/RTItypes.cc
--- certi/libRTI/RTItypes.cc	2008-11-25 17:32:14.000000000 +0100
+++ certi.new/libRTI/RTItypes.cc	2008-11-26 19:32:27.000000000 +0100
@@ -17,7 +17,7 @@
 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 // ----------------------------------------------------------------------------
 
-#include "GAV.hh"
+#include "HandleSets.hh"
 #include "Exception.hh"
 #include "PrettyDebug.hh"
 #include <assert.h>
@@ -271,45 +271,4 @@
     return os<<(*ex);
 }
 
-// ----------------------------------------------------------------------------
-RTI::AttributeHandleValuePairSet *
-RTI::AttributeSetFactory::create(ULong)
-    throw (MemoryExhausted, ValueCountExceeded, HandleValuePairMaximumExceeded)
-{
-    AttributeHandleValuePairSetImp *ahvps ;
-    ahvps = new AttributeHandleValuePairSetImp ;
-    ahvps->_order = RECEIVE ;
-    ahvps->_transport = RELIABLE ;
-    return (AttributeHandleValuePairSet *) ahvps ;
-}
-
-// ----------------------------------------------------------------------------
-RTI::AttributeHandleSet *
-RTI::AttributeHandleSetFactory::create(ULong)
-    throw (MemoryExhausted, ValueCountExceeded)
-{
-    return new AttributeHandleSetImp();
-}
-
-// ----------------------------------------------------------------------------
-RTI::FederateHandleSet *
-RTI::FederateHandleSetFactory::create(ULong)
-    throw (MemoryExhausted, ValueCountExceeded)
-{
-    return ((FederateHandleSet *) new FederateHandleSetImp());
-}
-
-// ----------------------------------------------------------------------------
-RTI::ParameterHandleValuePairSet *
-RTI::ParameterSetFactory::create(ULong size)
-    throw (MemoryExhausted, ValueCountExceeded, HandleValuePairMaximumExceeded)
-{
-    ParameterHandleValuePairSetImp *phvps ;
-    phvps = new ParameterHandleValuePairSetImp(size);
-
-    phvps->_order = RECEIVE ;
-    phvps->_transport = RELIABLE ;
-    return (ParameterHandleValuePairSet *) phvps ;
-}
-
 // $Id: RTItypes.cc,v 1.1 2008/11/25 16:32:14 gotthardp Exp $
diff --exclude=CVS -Nru certi/RTIA/CMakeLists.txt certi.new/RTIA/CMakeLists.txt
--- certi/RTIA/CMakeLists.txt	2008-11-25 17:32:13.000000000 +0100
+++ certi.new/RTIA/CMakeLists.txt	2008-12-05 12:35:08.000000000 +0100
@@ -20,7 +20,7 @@
   )
 
 ADD_EXECUTABLE(rtia ${rtia_SRCS})
-TARGET_LINK_LIBRARIES(rtia CERTI RTI-NG FedTime)
+TARGET_LINK_LIBRARIES(rtia CERTI RTI FedTime)
 
 INSTALL(TARGETS rtia 
     RUNTIME DESTINATION bin
diff --exclude=CVS -Nru certi/RTIA/main.cc certi.new/RTIA/main.cc
--- certi/RTIA/main.cc	2008-11-10 14:19:01.000000000 +0100
+++ certi.new/RTIA/main.cc	2008-12-05 12:10:22.000000000 +0100
@@ -90,7 +90,7 @@
 			        cerr << "RTIA:: RTIA has thrown " << e._name << " exception." << endl;
 			        cerr.flush();
                         }
-			if (e._reason) {
+			if (!e._reason.empty()) {
                                 if (! normal_end) {
 				      cerr << "RTIA:: Reason: " << e._reason << endl;
 				      cerr.flush();
@@ -105,7 +105,7 @@
 	} catch (Exception &e) {
                 if (! normal_end) {
 		      cerr << "RTIA:: RTIA has thrown " << e._name << " exception." << endl;
-		      if (e._reason) {
+		      if (!e._reason.empty()) {
 		 	  cerr << "RTIA:: Reason: " << e._reason << endl;
 		      }
                 }
diff --exclude=CVS -Nru certi/RTIA/OwnershipManagement.cc certi.new/RTIA/OwnershipManagement.cc
--- certi/RTIA/OwnershipManagement.cc	2008-06-12 09:39:50.000000000 +0200
+++ certi.new/RTIA/OwnershipManagement.cc	2008-12-05 12:12:07.000000000 +0100
@@ -319,7 +319,7 @@
 
     if (e == e_NO_EXCEPTION) {
         AttributeHandleSet *AttributeSet ;
-        AttributeSet = RTI::AttributeHandleSetFactory::create(rep->handleArraySize);
+        AttributeSet = new AttributeHandleSet(rep->handleArraySize);
 
         for (int i = 0 ; i < rep->handleArraySize ; i++) {
             AttributeSet->add(rep->handleArray[i]);
diff --exclude=CVS -Nru certi/RTIA/RTIA_federate.cc certi.new/RTIA/RTIA_federate.cc
--- certi/RTIA/RTIA_federate.cc	2008-11-21 13:45:24.000000000 +0100
+++ certi.new/RTIA/RTIA_federate.cc	2008-12-05 12:18:03.000000000 +0100
@@ -1441,7 +1441,7 @@
     }
     catch (RTIinternalError &e) {
         cout << "RTIA sends InternalError to Fed., " ;
-        if (e._reason != NULL)
+        if (!e._reason.empty())
             cout << "reason : " << e._reason << endl ;
         else
             cout << "no reason given." << endl ;
diff --exclude=CVS -Nru certi/RTIG/CMakeLists.txt certi.new/RTIG/CMakeLists.txt
--- certi/RTIG/CMakeLists.txt	2008-11-25 17:32:13.000000000 +0100
+++ certi.new/RTIG/CMakeLists.txt	2008-12-05 12:35:19.000000000 +0100
@@ -13,7 +13,7 @@
   )
 
 ADD_EXECUTABLE(rtig ${rtig_SRCS})
-TARGET_LINK_LIBRARIES(rtig CERTI RTI-NG FedTime)
+TARGET_LINK_LIBRARIES(rtig CERTI RTI FedTime)
 
 INSTALL(TARGETS rtig 
     RUNTIME DESTINATION bin
diff --exclude=CVS -Nru certi/RTIG/Federate.hh certi.new/RTIG/Federate.hh
--- certi/RTIG/Federate.hh	2008-11-21 14:41:52.000000000 +0100
+++ certi.new/RTIG/Federate.hh	2008-11-26 18:05:47.000000000 +0100
@@ -23,6 +23,7 @@
 #define CERTI_RTIG_FEDERATE_HH
 
 #include "certi.hh"
+#include "Exception.hh"
 
 #include <vector>
 #include <string>
diff --exclude=CVS -Nru certi/RTIG/Federation.hh certi.new/RTIG/Federation.hh
--- certi/RTIG/Federation.hh	2008-11-20 19:21:55.000000000 +0100
+++ certi.new/RTIG/Federation.hh	2008-11-26 18:09:02.000000000 +0100
@@ -27,6 +27,7 @@
 #include "Federate.hh"
 #include "RootObject.hh"
 #include "LBTS.hh"
+#include "GAV.hh"
 #include "SecurityServer.hh"
 #include "HandleManager.hh"
 #include "certi.hh"
diff --exclude=CVS -Nru certi/RTIG/RTIG.cc certi.new/RTIG/RTIG.cc
--- certi/RTIG/RTIG.cc	2008-11-20 19:21:56.000000000 +0100
+++ certi.new/RTIG/RTIG.cc	2008-11-26 18:37:19.000000000 +0100
@@ -510,8 +510,8 @@
 				} while (link->isDataReady());
 			}
 		catch (NetworkError &e) {
-			if (e._reason != NULL)
-			D.Out(pdExcept, "Catching Network Error, reason : %s", e._reason);
+			if (!e._reason.empty())
+			D.Out(pdExcept, "Catching Network Error, reason : %s", e._reason.c_str());
 			else
 			D.Out(pdExcept, "Catching Network Error, no reason string.");
 			cout << "RTIG dropping client connection " << link->returnSocket()
@@ -539,7 +539,7 @@
         socketServer.open();
     }
     catch (RTIinternalError &e) {
-        D.Out(pdExcept, "Error while accepting new connection : %s.", e._reason);
+        D.Out(pdExcept, "Error while accepting new connection : %s.", e._reason.c_str());
     }
 
     D.Out(pdInit, "Accepting new connection.");
@@ -579,7 +579,7 @@
     // This macro is used to copy any non null exception reason
     // string into our buffer(used for Audit purpose).
 
-#define CPY_NOT_NULL(A) { if (A._reason != NULL)strcpy(buffer, A._reason); }
+#define CPY_NOT_NULL(A) { if (!A._reason.empty())strcpy(buffer, A._reason.c_str()); }
 
     buffer[0] = 0 ;
 
@@ -912,10 +912,10 @@
         rep->exception = e_RestoreNotRequested ;
     }
     catch (RTIinternalError &e) {
-        if (e._reason == NULL)
+        if (e._reason.empty())
             D.Out(pdExcept, "Catching \"%s\" exception.", e._name);
         else
-            D.Out(pdExcept, "Catching \"%s\" exception: %s.", e._name, e._reason);
+            D.Out(pdExcept, "Catching \"%s\" exception: %s.", e._name, e._reason.c_str());
         CPY_NOT_NULL(e);
         rep->exception = e_RTIinternalError ;
     }
diff --exclude=CVS -Nru certi/test/Billard/CMakeLists.txt certi.new/test/Billard/CMakeLists.txt
--- certi/test/Billard/CMakeLists.txt	2008-11-25 17:32:14.000000000 +0100
+++ certi.new/test/Billard/CMakeLists.txt	2008-12-05 12:36:30.000000000 +0100
@@ -22,7 +22,7 @@
   )
 
 ADD_EXECUTABLE(billard ${billard_SRCS})
-TARGET_LINK_LIBRARIES(billard graph RTI-NG FedTime)
+TARGET_LINK_LIBRARIES(billard graph RTI FedTime)
 
 IF (X11_FOUND)
   TARGET_LINK_LIBRARIES(billard ${X11_LIBRARIES})
diff --exclude=CVS -Nru certi/test/utility/CMakeLists.txt certi.new/test/utility/CMakeLists.txt
--- certi/test/utility/CMakeLists.txt	2008-11-25 17:32:14.000000000 +0100
+++ certi.new/test/utility/CMakeLists.txt	2008-12-05 12:36:49.000000000 +0100
@@ -8,7 +8,7 @@
 
 ADD_EXECUTABLE(CertiUtilTests ${CertiUtil_SRCS})
 
-TARGET_LINK_LIBRARIES(CertiUtilTests CERTI RTI-NG FedTime)
+TARGET_LINK_LIBRARIES(CertiUtilTests CERTI RTI FedTime)
 
 INSTALL(TARGETS CertiUtilTests
     RUNTIME DESTINATION bin
