/* may return null */
in_result
in_messageDeserializerRead(
in_messageDeserializer _this,
v_topic topic,
os_boolean isBigEndian,
v_message* object)
{
in_result result = IN_RESULT_OK;
in_messageTransformer transformer = in_messageTransformer(_this);
c_object displacedMessage;
c_type messageType;
assert(_this);
assert(in_messageDeserializerIsValid(_this));
assert(object);
assert(topic);
if (topic)
{
/* work around, replace cdrLength in transformer by ->length */
in_messageTransformerSetCdrLength(transformer, (os_ushort) (transformer->length));
if (_requiresSwap(isBigEndian)) {
in_messageTransformerSetCopyKind(transformer, IN_MESSAGE_TRANSFORMER_CM_KIND_SWAP);
} else {
in_messageTransformerSetCopyKind(transformer, IN_MESSAGE_TRANSFORMER_CM_KIND_COPY);
}
messageType = v_topicMessageType(topic);
if (c_typeIsRef(messageType))
{
*object = v_topicMessageNew(topic);
if(*object == NULL)
{
result = IN_RESULT_OUT_OF_MEMORY;
} else
{
displacedMessage = v_topicData(topic, *object);
in_messageDeserializerReadType(_this, v_topicDataType(topic),
displacedMessage);
}
} else
{
assert(FALSE);
result = IN_RESULT_ERROR;
*object = NULL;
}
} else
{
*object = NULL;
}
return result;
}
v_message v_participantCreateCandMCommand(v_participant participant)
{
v_message msg;
v_kernel kernel;
v_topic topic;
assert(participant != NULL);
assert(C_TYPECHECK(participant,v_participant));
kernel = v_objectKernel(participant);
topic = v_builtinTopicLookup(kernel->builtin, V_C_AND_M_COMMAND_ID);
msg = v_topicMessageNew(topic);
return msg;
}
static v_message
createUnregisterMessage(
v_group group,
v_message message)
{
c_array messageKeyList;
c_long i, nrOfKeys;
v_message unregisterMessage;
assert(!v_stateTest(v_nodeState(message), L_UNREGISTER));
/* Create new message objec */
unregisterMessage = v_topicMessageNew
(group->topic);
/* Copy keyvalues to unregistermessage */
messageKeyList = v_topicMessageKeyList(v_groupTopic(group));
nrOfKeys = c_arraySize(messageKeyList);
for (i=0;i<nrOfKeys;i++) {
c_fieldAssign (messageKeyList[i],
unregisterMessage,
c_fieldValue(messageKeyList[i],message));
}
/* Set instance & writer GID */
unregisterMessage->writerGID =
message->writerGID;
unregisterMessage->writerInstanceGID =
message->writerInstanceGID;
/* Copy messageQos */
c_keep (message->qos);
unregisterMessage->qos = message->qos;
/* Set nodestate to unregister */
v_nodeState(unregisterMessage) = L_UNREGISTER;
unregisterMessage->writeTime = v_timeGet();
#ifndef _NAT_
unregisterMessage->allocTime = unregisterMessage->writeTime;
#endif
return unregisterMessage;
}
void
cmx_writerUnregisterCopy(
v_entity entity,
c_voidp args)
{
v_writer kw;
v_message message;
void *to;
sd_serializer ser;
sd_serializedData data;
sd_validationResult valResult;
struct cmx_writerArg *arg;
arg = (struct cmx_writerArg *)args;
kw = v_writer(entity);
message = v_topicMessageNew(kw->topic);
to = C_DISPLACE(message,v_topicDataOffset(kw->topic));
ser = sd_serializerXMLNewTyped(v_topicDataType(kw->topic));
data = sd_serializerFromString(ser, arg->result);
sd_serializerDeserializeIntoValidated(ser, data, to);
valResult = sd_serializerLastValidationResult(ser);
if(valResult != SD_VAL_SUCCESS){
OS_REPORT_2(OS_ERROR, CM_XML_CONTEXT, 0,
"Unregister of userdata failed.\nReason: %s\nError: %s\n",
sd_serializerLastValidationMessage(ser),
sd_serializerLastValidationLocation(ser));
arg->success = CMX_RESULT_FAILED;
} else {
arg->success = CMX_RESULT_OK;
}
sd_serializedDataFree(data);
sd_serializerFree(ser);
/* Note that the last param of v_writerWriteDispose is NULL,
performance can be improved if the instance is provided. */
v_writerUnregister(kw,message,v_timeGet(),NULL);
c_free(message);
}
u_instanceHandle
u_instanceHandleFix(
u_instanceHandle _this,
v_collection reader)
{
u_instanceHandleTranslator translator;
struct v_publicationInfo *data;
v_topic topic;
v_message message;
v_public instance;
translator.handle = _this;
if (translator.lid.lifecycleId & HANDLE_GLOBAL_MASK) {
/* Is a GID therefore fix handle by lookup. */
while (v_objectKind(v_entity(reader)) == K_QUERY ||
v_objectKind(v_entity(reader)) == K_DATAREADERQUERY ||
v_objectKind(v_entity(reader)) == K_DATAVIEWQUERY) {
/* If the entity derives from a query entity it can be cast to a v_query */
reader = v_querySource(v_query(reader));
}
while (v_objectKind(v_entity(reader)) == K_DATAVIEW) {
reader = v_collection(v_dataViewGetReader(v_dataView(reader)));
}
topic = v_dataReaderGetTopic(v_dataReader(reader));
message = v_topicMessageNew(topic);
data = (c_voidp)C_DISPLACE(message, v_topicDataOffset(topic));
data->key = u_instanceHandleToGID(_this);
instance = (v_public)v_dataReaderLookupInstance(v_dataReader(reader),
message);
translator.handle = u_instanceHandleNew(instance);
c_free(instance);
c_free(topic);
c_free(message);
}
return translator.handle;
}
static in_result
in_ddsiStreamReaderImplProcessAppdefDataPayloadNoData(
in_ddsiStreamReaderImpl _this,
in_ddsiSubmessageData submessage,
in_connectivityPeerWriter peerWriter,
v_message *messageObject)
{
v_topic topic;
in_result result;
c_type messageType;
c_octet* keyHash;
assert(peerWriter);
assert(messageObject);
assert(submessage);
*messageObject = NULL;
topic = lookupTopic(_this, peerWriter);
if(topic)
{
messageType = v_topicMessageType(topic);
if (c_typeIsRef(messageType))
{
*messageObject = v_topicMessageNew(topic);
if(*messageObject)
{
(*messageObject)->sequenceNumber = (submessage->writerSN.low);
(*messageObject)->writerGID = in_connectivityPeerWriterGetGid(
peerWriter);
(*messageObject)->allocTime = _this->receiver.haveTimestamp ?
_this->receiver.timestamp : C_TIME_ZERO;
(*messageObject)->writeTime = _this->receiver.haveTimestamp ?
_this->receiver.timestamp : C_TIME_ZERO;
/* WriterInstanceGID unused in kernel, so not necessary to fill it*/
(*messageObject)->writerInstanceGID.systemId =
(*messageObject)->writerGID.systemId;
(*messageObject)->writerInstanceGID.localId = 0;
(*messageObject)->writerInstanceGID.serial = 0;
(*messageObject)->qos = in_messageQos_new(peerWriter,
c_getBase(topic));
result = in_ddsiParameterListGetPidKeyHash(
&(submessage->inlineQos), &keyHash);
if(result == IN_RESULT_OK)
{
result = in_ddsiStreamReaderImplDerializePayloadByKeyHash(
_this, submessage, peerWriter, topic, messageObject,
keyHash);
os_free(keyHash);
if(result == IN_RESULT_OK)
{
result = in_ddsiParameterListGetPidStatusInfo(
&(submessage->inlineQos),
&(v_messageState(*messageObject)));
} else
{
IN_REPORT_WARNING(IN_SPOT, "Unable to copy key values in message.");
}
} else
{
IN_REPORT_WARNING(IN_SPOT, "Found DATA submessage without serializedPayload and no PID_KEY_HASH inlineQos.");
result = IN_RESULT_ERROR;
}
} else
{
result = IN_RESULT_OUT_OF_MEMORY;
}
} else
{
result = IN_RESULT_ERROR;
}
c_free(topic);
} else
{
result = IN_RESULT_ERROR;
}
return result;
}
