//-----------------------------------------------------------------
//
// METHOD:
// void Country::Update( const AttributeHandleValuePairSet& theAttributes )
//
// PURPOSE:
// Update the new attribute values. If this is being called
// then this object is either a remote object that was
// discovered or it has some attributes that are owned by
// another federate.
//
// Note: This version does not implement any ownership
// transfer - the above was a generic statement.
//
// RETURN VALUES:
// None.
//
// HISTORY:
// 1) Created 11/6/96
// 2) Updated to RTI 1.3 3/26/98
//
//-----------------------------------------------------------------
void Country::Update( const RTI::AttributeHandleValuePairSet& theAttributes )
{
RTI::AttributeHandle attrHandle;
RTI::ULong valueLength;
// We need to iterate through the AttributeHandleValuePairSet
// to extract each AttributeHandleValuePair. Based on the type
// specified ( the value returned by getHandle() ) we need to
// extract the data from the buffer that is returned by
// getValue().
for ( unsigned int i = 0; i < theAttributes.size(); i++ )
{
attrHandle = theAttributes.getHandle( i );
if ( attrHandle == Country::GetPopulationRtiId() )
{
// When we run this over multiple platforms we will have
// a problem with different endian-ness of platforms. Either
// we need to encode the data using something like XDR or
// provide another mechanism.
double population;
theAttributes.getValue( i, (char*)&population, valueLength );
#if defined(_X86_) || defined(i386)
long x = ntohl(*(long*)&population);
*(long*)&population = ntohl(* (((long*)&population) + 1));
*(((long*)&population)+1) = x;
#elif defined(__alpha)
double x;
cvt_ftof(&population, CVT_IEEE_T, &x, CVT_BIG_ENDIAN_IEEE_T, 0);
population = x;
#endif // __alpha
SetPopulation( (double)population );
}
else if ( attrHandle == Country::GetNameRtiId() )
{
// Same as above goes here...
char name[ 1024 ];
theAttributes.getValue( i, (char*)name, valueLength );
SetName( (const char*)name );
}
}
}
//------------------------------------------------------------------------------
// reflectAttributeValues() -- (Input support)
// Called by our FederateAmbassador to update the attribute values for
// this object instance. (Also handles the network to host byte swapping)
//------------------------------------------------------------------------------
void Nib::reflectAttributeValues(const RTI::AttributeHandleValuePairSet& theAttrs)
{
NetIO* netIO = static_cast<NetIO*>(getNetIO());
if (netIO != nullptr && baseEntity != nullptr) {
// PhysicalEntity pointer
PhysicalEntity* physicalEntity = dynamic_cast<PhysicalEntity*>(baseEntity);
RTI::ULong length;
char netBuffer[1000];
for (RTI::ULong j = 0; j < theAttrs.size(); j++ ) {
// get the attribute's handle and data (network byte order)
RTI::AttributeHandle theAttr = theAttrs.getHandle(j);
theAttrs.getValue(j, netBuffer, length);
// Process the attribute
switch ( netIO->findAttributeIndex(theAttr) ) {
// Update Federate ID
case NetIO::ENTITY_IDENTIFIER_AI : {
EntityIdentifierStruct* net = reinterpret_cast<EntityIdentifierStruct*>(&netBuffer);
base::NetHandler::fromNetOrder(&baseEntity->entityIdentifier.federateIdentifier.applicationID, net->federateIdentifier.applicationID );
base::NetHandler::fromNetOrder(&baseEntity->entityIdentifier.federateIdentifier.siteID, net->federateIdentifier.siteID );
base::NetHandler::fromNetOrder(&baseEntity->entityIdentifier.entityNumber, net->entityNumber );
setAttributeUpdateRequiredFlag(NetIO::ENTITY_IDENTIFIER_AI, true);
}
break;
// Update Entity Type
case NetIO::ENTITY_TYPE_AI : {
EntityTypeStruct* net = reinterpret_cast<EntityTypeStruct*>(&netBuffer);
// All bytes except for country
baseEntity->entityType = *net;
base::NetHandler::fromNetOrder(&baseEntity->entityType.countryCode, net->countryCode );
setAttributeUpdateRequiredFlag(NetIO::ENTITY_TYPE_AI, true);
}
break;
// Update Spatial
case NetIO::SPATIAL_AI : {
// NIB's base entity structure pointers
SpatialStruct* spatial = &(baseEntity->spatial);
SpatialRVStruct* spatialRvw = &(baseEntity->spatialRvw);
WorldLocationStruct* worldLocation = &spatialRvw->worldLocation;
OrientationStruct* orientation = &spatialRvw->orientation;
VelocityVectorStruct* velocityVector = &spatialRvw->velocityVector;
AccelerationVectorStruct* accelerationVector = &spatialRvw->accelerationVector;
AngularVelocityVectorStruct* angularVelocity = &spatialRvw->angularVelocity;
// Net buffer component pointers
SpatialStruct* netSpatial = reinterpret_cast<SpatialStruct*>(&netBuffer[0]);
WorldLocationStruct* netWorldLocation = nullptr;
OrientationStruct* netOrientation = nullptr;
VelocityVectorStruct* netVelocityVector = nullptr;
AccelerationVectorStruct* netAccelerationVector = nullptr;
AngularVelocityVectorStruct* netAngularVelocity = nullptr;
// Dead reckoning
spatial->deadReckoningAlgorithm = netSpatial->deadReckoningAlgorithm;
// find network components based on dead reckoning algorithm
// (and set the isFrozen flag)
switch (spatial->deadReckoningAlgorithm) {
case DRM_STATIC : {
SpatialStaticStruct* netSpatialStatic = reinterpret_cast<SpatialStaticStruct*>(&netBuffer[sizeof(SpatialStruct)]);
spatialRvw->isFrozen = netSpatialStatic->isFrozen;
netWorldLocation = &netSpatialStatic->worldLocation;
netOrientation = &netSpatialStatic->orientation;
}
break;
case DRM_FPW : {
SpatialFPStruct* netSpatialFpw = reinterpret_cast<SpatialFPStruct*>(&netBuffer[sizeof(SpatialStruct)]);
spatialRvw->isFrozen = netSpatialFpw->isFrozen;
netWorldLocation = &netSpatialFpw->worldLocation;
netOrientation = &netSpatialFpw->orientation;
netVelocityVector = &netSpatialFpw->velocityVector;
}
break;
case DRM_RPW : {
SpatialRPStruct* netSpatialRpw = reinterpret_cast<SpatialRPStruct*>(&netBuffer[sizeof(SpatialStruct)]);
spatialRvw->isFrozen = netSpatialRpw->isFrozen;
netWorldLocation = &netSpatialRpw->worldLocation;
netOrientation = &netSpatialRpw->orientation;
netVelocityVector = &netSpatialRpw->velocityVector;
netAngularVelocity = &netSpatialRpw->angularVelocity;
}
break;
case DRM_RVW : {
SpatialRVStruct* netSpatialRvw = reinterpret_cast<SpatialRVStruct*>(&netBuffer[sizeof(SpatialStruct)]);
spatialRvw->isFrozen = netSpatialRvw->isFrozen;
netWorldLocation = &netSpatialRvw->worldLocation;
netOrientation = &netSpatialRvw->orientation;
netVelocityVector = &netSpatialRvw->velocityVector;
netAccelerationVector = &netSpatialRvw->accelerationVector;
netAngularVelocity = &netSpatialRvw->angularVelocity;
}
break;
case DRM_FVW : {
SpatialFVStruct* netSpatialFvw = reinterpret_cast<SpatialFVStruct*>(&netBuffer[sizeof(SpatialStruct)]);
spatialRvw->isFrozen = netSpatialFvw->isFrozen;
netWorldLocation = &netSpatialFvw->worldLocation;
netOrientation = &netSpatialFvw->orientation;
netVelocityVector = &netSpatialFvw->velocityVector;
netAccelerationVector = &netSpatialFvw->accelerationVector;
}
break;
} // end dead rec switch
if (netWorldLocation != nullptr) {
base::NetHandler::fromNetOrder(&worldLocation->x, netWorldLocation->x);
base::NetHandler::fromNetOrder(&worldLocation->y, netWorldLocation->y);
base::NetHandler::fromNetOrder(&worldLocation->z, netWorldLocation->z);
}
else {
worldLocation->x = 0;
worldLocation->y = 0;
worldLocation->z = 0;
}
if (netOrientation != nullptr) {
base::NetHandler::fromNetOrder(&orientation->phi, netOrientation->phi);
base::NetHandler::fromNetOrder(&orientation->theta, netOrientation->theta);
base::NetHandler::fromNetOrder(&orientation->psi, netOrientation->psi);
}
else {
orientation->phi = 0;
orientation->theta = 0;
orientation->psi = 0;
}
if (netVelocityVector != nullptr) {
base::NetHandler::fromNetOrder(&velocityVector->xVelocity, netVelocityVector->xVelocity);
base::NetHandler::fromNetOrder(&velocityVector->yVelocity, netVelocityVector->yVelocity);
base::NetHandler::fromNetOrder(&velocityVector->zVelocity, netVelocityVector->zVelocity);
}
else {
velocityVector->xVelocity = 0;
velocityVector->yVelocity = 0;
velocityVector->zVelocity = 0;
}
if (netAccelerationVector != nullptr) {
base::NetHandler::fromNetOrder(&accelerationVector->xAcceleration, netAccelerationVector->xAcceleration);
base::NetHandler::fromNetOrder(&accelerationVector->yAcceleration, netAccelerationVector->yAcceleration);
base::NetHandler::fromNetOrder(&accelerationVector->zAcceleration, netAccelerationVector->zAcceleration);
}
else {
accelerationVector->xAcceleration = 0;
accelerationVector->yAcceleration = 0;
accelerationVector->zAcceleration = 0;
}
if (netAngularVelocity != nullptr) {
base::NetHandler::fromNetOrder(&angularVelocity->xAngularVelocity, netAngularVelocity->xAngularVelocity);
base::NetHandler::fromNetOrder(&angularVelocity->yAngularVelocity, netAngularVelocity->yAngularVelocity);
base::NetHandler::fromNetOrder(&angularVelocity->zAngularVelocity, netAngularVelocity->zAngularVelocity);
}
else {
angularVelocity->xAngularVelocity = 0;
angularVelocity->yAngularVelocity = 0;
angularVelocity->zAngularVelocity = 0;
}
setAttributeUpdateRequiredFlag(NetIO::SPATIAL_AI, true);
}
break;
case NetIO::FORCE_IDENTIFIER_AI : {
unsigned char* net = reinterpret_cast<unsigned char*>(&netBuffer);
physicalEntity->forceIdentifier = ForceIdentifierEnum8( *net );
//std::cout << "Recv force: " << physicalEntity->forceIdentifier << std::endl;;
setAttributeUpdateRequiredFlag(NetIO::FORCE_IDENTIFIER_AI, true);
}
break;
} // end -- process attribute switch
} // end -- for each attribute pair
// Update the basic NIB state data with this new data
entityState2Nib();
}
}
