/*
* Encodes the symbol list close. Returns success if
* encoding succeeds or failure if encoding fails.
* pCommand - the ChannelCommand to send an item close to
* pReactorChannel - The channel to send an item close to
* msgBuf - The message buffer to encode the item close into
* streamId - The stream id of the symbol list
*
* This function is only used within the Symbol List Handler
* and each handler has its own implementation, although much is similar
*/
static RsslRet encodeSymbolListClose(ChannelCommand *pCommand, RsslReactorChannel* pReactorChannel, RsslBuffer* msgBuf, RsslInt32 streamId)
{
RsslRet ret = 0;
RsslCloseMsg msg = RSSL_INIT_CLOSE_MSG;
RsslEncodeIterator encodeIter;
/* clear encode iterator */
rsslClearEncodeIterator(&encodeIter);
/* set-up message */
msg.msgBase.msgClass = RSSL_MC_CLOSE;
msg.msgBase.streamId = streamId;
msg.msgBase.domainType = RSSL_DMT_SYMBOL_LIST;
msg.msgBase.containerType = RSSL_DT_NO_DATA;
/* encode message */
if((ret = rsslSetEncodeIteratorBuffer(&encodeIter, msgBuf)) < RSSL_RET_SUCCESS)
{
printf("rsslSetEncodeIteratorBuffer() failed with return code: %d\n", ret);
return ret;
}
rsslSetEncodeIteratorRWFVersion(&encodeIter, pReactorChannel->majorVersion, pReactorChannel->minorVersion);
if ((ret = rsslEncodeMsg(&encodeIter, (RsslMsg*)&msg)) < RSSL_RET_SUCCESS)
{
printf("rsslEncodeMsg() failed with return code: %d\n", ret);
return ret;
}
msgBuf->length = rsslGetEncodedBufferLength(&encodeIter);
return RSSL_RET_SUCCESS;
}
void encodeStatusMsg( RsslUInt8 domainType, RsslInt32 streamId, RsslBuffer* pRsslBuffer )
{
RsslEncodeIterator eIter;
RsslStatusMsg statusMsg;
rsslClearEncodeIterator( &eIter );
rsslClearStatusMsg( &statusMsg );
statusMsg.flags |= RSSL_STMF_HAS_STATE;
statusMsg.state.code = RSSL_SC_NONE;
statusMsg.state.dataState = RSSL_DATA_SUSPECT;
statusMsg.state.streamState = RSSL_STREAM_CLOSED;
statusMsg.state.text.data = (char*)"Closed";
statusMsg.state.text.length = 6;
statusMsg.msgBase.domainType = domainType;
statusMsg.msgBase.streamId = streamId;
statusMsg.msgBase.containerType = RSSL_DT_NO_DATA;
rsslSetEncodeIteratorBuffer( &eIter, pRsslBuffer );
rsslSetEncodeIteratorRWFVersion( &eIter, RSSL_RWF_MAJOR_VERSION, RSSL_RWF_MINOR_VERSION );
rsslEncodeMsg( &eIter, (RsslMsg*)&statusMsg );
pRsslBuffer->length = rsslGetEncodedBufferLength( &eIter );
}
/*
* Encodes the symbol list request. Returns success if
* encoding succeeds or failure if encoding fails.
* pCommand - the ChannelCommand to send an item request to
* msgBuf - The message buffer to encode the item request into
* pRequest - Item request structure
*
* This function is only used within the Symbol List Handler
* and each handler has its own implementation, although much is similar
*/
static RsslRet encodeSymbolListRequest(ChannelCommand *pCommand, RsslBuffer* msgBuf, ItemRequest *pRequest)
{
RsslRet ret = 0;
RsslRequestMsg msg = RSSL_INIT_REQUEST_MSG;
RsslEncodeIterator encodeIter;
/* clear encode iterator*/
rsslClearEncodeIterator(&encodeIter);
/*set-up message*/
msg.msgBase.msgClass = RSSL_MC_REQUEST;
msg.msgBase.streamId = pRequest->streamId;
msg.msgBase.domainType = RSSL_DMT_SYMBOL_LIST;
msg.msgBase.containerType = RSSL_DT_NO_DATA;
if (snapshotRequest)
{
msg.flags = RSSL_RQMF_HAS_QOS | RSSL_RQMF_HAS_PRIORITY;
}
else
{
msg.flags = RSSL_RQMF_HAS_QOS | RSSL_RQMF_STREAMING | RSSL_RQMF_HAS_PRIORITY;
}
msg.priorityClass = 1;
msg.priorityCount = 1;
/*copy the QoS information*/
rsslCopyQos(&(msg.qos), &pCommand->qos);
/*specify msgKey members*/
msg.msgBase.msgKey.flags = RSSL_MKF_HAS_NAME_TYPE | RSSL_MKF_HAS_NAME | RSSL_MKF_HAS_SERVICE_ID;
msg.msgBase.msgKey.nameType = RDM_INSTRUMENT_NAME_TYPE_RIC;
msg.msgBase.msgKey.serviceId = (RsslUInt16)pCommand->serviceId;
/*if the user specified the SL name on the command line, add it to the request */
msg.msgBase.msgKey.name = pCommand->symbolListRequest.itemName;
/* encode message*/
if((ret = rsslSetEncodeIteratorBuffer(&encodeIter, msgBuf)) < RSSL_RET_SUCCESS)
{
printf("rsslEncodeIteratorBuffer() failed with return code: %d\n", ret);
return ret;
}
rsslSetEncodeIteratorRWFVersion(&encodeIter, pCommand->reactorChannel->majorVersion, pCommand->reactorChannel->minorVersion);
if ((ret = rsslEncodeMsg(&encodeIter, (RsslMsg*)&msg)) < RSSL_RET_SUCCESS)
{
printf("rsslEncodeMsgInit() failed with return code: %d\n", ret);
return ret;
}
msgBuf->length = rsslGetEncodedBufferLength(&encodeIter);
return RSSL_RET_SUCCESS;
}
RsslRet UPAProvider::EncodeAck(RsslChannel* chnl, RsslBuffer* ackBuf, RsslPostMsg *postMsg, RsslUInt8 nakCode, char *text)
{
RsslRet ret = 0;
RsslAckMsg ackMsg = RSSL_INIT_ACK_MSG;
RsslEncodeIterator encodeIter;
/* clear encode iterator */
rsslClearEncodeIterator(&encodeIter);
/* set-up message */
ackMsg.msgBase.msgClass = RSSL_MC_ACK;
ackMsg.msgBase.streamId = postMsg->msgBase.streamId;
ackMsg.msgBase.domainType = postMsg->msgBase.domainType;
ackMsg.msgBase.containerType = RSSL_DT_NO_DATA;
ackMsg.flags = RSSL_AKMF_NONE;
ackMsg.nakCode = nakCode;
ackMsg.ackId = postMsg->postId;
ackMsg.seqNum = postMsg->seqNum;
if (nakCode != RSSL_NAKC_NONE)
ackMsg.flags |= RSSL_AKMF_HAS_NAK_CODE;
if (postMsg->flags & RSSL_PSMF_HAS_SEQ_NUM)
ackMsg.flags |= RSSL_AKMF_HAS_SEQ_NUM;
if (text != NULL)
{
ackMsg.flags |= RSSL_AKMF_HAS_TEXT;
ackMsg.text.data = text;
ackMsg.text.length = (RsslUInt32)strlen(text);
}
/* encode message */
rsslSetEncodeIteratorBuffer(&encodeIter, ackBuf);
rsslSetEncodeIteratorRWFVersion(&encodeIter, chnl->majorVersion, chnl->minorVersion);
if ((ret = rsslEncodeMsg(&encodeIter, (RsslMsg*)&ackMsg)) < RSSL_RET_SUCCESS)
{
t42log_error("UPAProvider::EncodeAck - rsslEncodeMsg() of ackMsg failed with return code: %d\n", ret);
return ret;
}
ackBuf->length = rsslGetEncodedBufferLength(&encodeIter);
return RSSL_RET_SUCCESS;
}
/*
* Encodes the not supported status. Returns success if
* encoding succeeds or failure if encoding fails.
* chnl - The channel to send not supported status message to
* requestMsg - The partially decoded request message
* msgBuf - The message buffer to encode the not supported status into
*/
RsslRet encodeNotSupportedStatus(RsslReactorChannel* chnl, RsslMsg* requestMsg, RsslBuffer* msgBuf)
{
RsslRet ret = 0;
RsslStatusMsg msg = RSSL_INIT_STATUS_MSG;
char stateText[MAX_MSG_SIZE];
RsslEncodeIterator encodeIter;
/* clear encode iterator */
rsslClearEncodeIterator(&encodeIter);
/* set-up message */
msg.msgBase.msgClass = RSSL_MC_STATUS;
msg.msgBase.streamId = requestMsg->msgBase.streamId;
msg.msgBase.domainType = requestMsg->msgBase.domainType;
msg.msgBase.containerType = RSSL_DT_NO_DATA;
msg.flags = RSSL_STMF_HAS_STATE;
msg.state.streamState = RSSL_STREAM_CLOSED;
msg.state.dataState = RSSL_DATA_SUSPECT;
msg.state.code = RSSL_SC_USAGE_ERROR;
sprintf(stateText, "Request rejected for stream id %d - domain type %d is not supported", requestMsg->msgBase.streamId, requestMsg->msgBase.domainType);
msg.state.text.data = stateText;
msg.state.text.length = (RsslUInt32)strlen(stateText) + 1;
/* encode message */
if((ret = rsslSetEncodeIteratorBuffer(&encodeIter, msgBuf)) < RSSL_RET_SUCCESS)
{
printf("rsslSetEncodeIteratorBuffer() failed with return code: %d\n", ret);
return ret;
}
rsslSetEncodeIteratorRWFVersion(&encodeIter, chnl->majorVersion, chnl->minorVersion);
if ((ret = rsslEncodeMsg(&encodeIter, (RsslMsg*)&msg)) < RSSL_RET_SUCCESS)
{
printf("rsslEncodeMsg() failed with return code: %d\n", ret);
return ret;
}
msgBuf->length = rsslGetEncodedBufferLength(&encodeIter);
return RSSL_RET_SUCCESS;
}
RsslRet encodeItemCloseStatus(RsslChannel* chnl, ItemInfo* itemInfo, RsslBuffer* msgBuf, RsslInt32 streamId)
{
RsslRet ret = 0;
RsslStatusMsg msg = RSSL_INIT_STATUS_MSG;
char stateText[128];
RsslEncodeIterator encodeIter;
/* clear encode iterator */
rsslClearEncodeIterator(&encodeIter);
/* set-up message */
msg.msgBase.msgClass = RSSL_MC_STATUS;
msg.msgBase.streamId = streamId;
msg.msgBase.domainType = itemInfo->attributes.domainType;
msg.msgBase.containerType = RSSL_DT_NO_DATA;
msg.flags = RSSL_STMF_HAS_STATE;
msg.state.streamState = RSSL_STREAM_CLOSED;
msg.state.dataState = RSSL_DATA_SUSPECT;
msg.state.code = RSSL_SC_NONE;
snprintf(stateText, 128, "Stream closed" );
msg.state.text.data = stateText;
msg.state.text.length = (RsslUInt32)strlen(stateText);
/* encode message */
rsslSetEncodeIteratorBuffer(&encodeIter, msgBuf);
rsslSetEncodeIteratorRWFVersion(&encodeIter, chnl->majorVersion, chnl->minorVersion);
if ((ret = rsslEncodeMsg(&encodeIter, (RsslMsg*)&msg)) < RSSL_RET_SUCCESS)
{
printf("rsslEncodeMsg() failed with return code: %d\n", ret);
return ret;
}
msgBuf->length = rsslGetEncodedBufferLength(&encodeIter);
return RSSL_RET_SUCCESS;
}
RsslRet encodeItemRequestReject(RsslChannel* chnl, RsslInt32 streamId, ItemRejectReason reason, RsslBuffer* msgBuf, RsslUInt8 domainType)
{
RsslRet ret = 0;
RsslStatusMsg msg = RSSL_INIT_STATUS_MSG;
char stateText[128];
RsslEncodeIterator encodeIter;
/* clear encode iterator */
rsslClearEncodeIterator(&encodeIter);
/* set-up message */
msg.msgBase.msgClass = RSSL_MC_STATUS;
msg.msgBase.streamId = streamId;
msg.msgBase.domainType = domainType;
msg.msgBase.containerType = RSSL_DT_NO_DATA;
msg.flags = RSSL_STMF_HAS_STATE;
msg.state.streamState = RSSL_STREAM_CLOSED_RECOVER;
msg.state.dataState = RSSL_DATA_SUSPECT;
switch (reason)
{
case ITEM_COUNT_REACHED:
msg.state.code = RSSL_SC_TOO_MANY_ITEMS;
snprintf(stateText, 128, "Item request rejected for stream id %d - item count reached for this channel", streamId);
msg.state.text.data = stateText;
msg.state.text.length = (RsslUInt32)strlen(stateText) + 1;
break;
case INVALID_SERVICE_ID:
msg.state.code = RSSL_SC_USAGE_ERROR;
msg.state.streamState = RSSL_STREAM_CLOSED;
snprintf(stateText, 128, "Item request rejected for stream id %d - service id invalid", streamId);
msg.state.text.data = stateText;
msg.state.text.length = (RsslUInt32)strlen(stateText) + 1;
break;
case QOS_NOT_SUPPORTED:
msg.state.code = RSSL_SC_USAGE_ERROR;
msg.state.streamState = RSSL_STREAM_CLOSED;
snprintf(stateText, 128, "Item request rejected for stream id %d - QoS not supported", streamId);
msg.state.text.data = stateText;
msg.state.text.length = (RsslUInt32)strlen(stateText) + 1;
break;
case ITEM_ALREADY_OPENED:
msg.state.code = RSSL_SC_ALREADY_OPEN;
snprintf(stateText, 128, "Item request rejected for stream id %d - item already open with exact same key on another stream", streamId);
msg.state.text.data = stateText;
msg.state.text.length = (RsslUInt32)strlen(stateText) + 1;
break;
case STREAM_ALREADY_IN_USE:
msg.state.code = RSSL_SC_USAGE_ERROR;
snprintf(stateText, 128, "Item request rejected for stream id %d - stream already in use with a different key", streamId);
msg.state.text.data = stateText;
msg.state.text.length = (RsslUInt32)strlen(stateText) + 1;
break;
case DOMAIN_NOT_SUPPORTED:
msg.state.code = RSSL_SC_USAGE_ERROR;
msg.state.streamState = RSSL_STREAM_CLOSED;
snprintf(stateText, 128, "Item request rejected for stream id %d - this provider does not support domain %u", streamId, domainType);
msg.state.text.data = stateText;
msg.state.text.length = (RsslUInt32)strlen(stateText) + 1;
break;
default:
break;
}
/* encode message */
rsslSetEncodeIteratorBuffer(&encodeIter, msgBuf);
rsslSetEncodeIteratorRWFVersion(&encodeIter, chnl->majorVersion, chnl->minorVersion);
if ((ret = rsslEncodeMsg(&encodeIter, (RsslMsg*)&msg)) < RSSL_RET_SUCCESS)
{
printf("rsslEncodeMsg() failed with return code: %d\n", ret);
return ret;
}
msgBuf->length = rsslGetEncodedBufferLength(&encodeIter);
return RSSL_RET_SUCCESS;
}
RsslRet snapshotSessionRequestItems(SnapshotSession *pSession)
{
RsslUInt32 i;
RsslEncodeIterator encodeIter;
RsslRequestMsg requestMsg;
RsslBuffer *pBuffer;
RsslError rsslError;
RsslRet ret;
for (i = 0; i < itemList.itemCount; ++i)
{
Item *pItem = &itemList.items[i];
if (!(pBuffer = rsslGetBuffer(pSession->pRsslChannel, 128, RSSL_FALSE, &rsslError)))
{
printf("<%s> rsslGetBuffer() failed while sending item request: %d (%s -- %s).\n\n",
pSession->name,
rsslError.rsslErrorId, rsslRetCodeToString(rsslError.rsslErrorId), rsslError.text);
return ret;
}
rsslClearRequestMsg(&requestMsg);
requestMsg.flags = RSSL_RQMF_HAS_QOS;
requestMsg.msgBase.streamId = pItem->snapshotServerStreamId;
requestMsg.msgBase.domainType = pItem->domainType;
requestMsg.msgBase.containerType = RSSL_DT_NO_DATA;
requestMsg.qos.rate = RSSL_QOS_RATE_TICK_BY_TICK;
requestMsg.qos.timeliness = RSSL_QOS_TIME_REALTIME;
/* This system uses the real-time feed's stream ID as the name. */
requestMsg.msgBase.msgKey.flags = RSSL_MKF_HAS_SERVICE_ID | RSSL_MKF_HAS_IDENTIFIER;
requestMsg.msgBase.msgKey.identifier = pItem->feedStreamId;
requestMsg.msgBase.msgKey.serviceId = exampleConfig.serviceId;
rsslClearEncodeIterator(&encodeIter);
rsslSetEncodeIteratorRWFVersion(&encodeIter, pSession->pRsslChannel->majorVersion,
pSession->pRsslChannel->minorVersion);
rsslSetEncodeIteratorBuffer(&encodeIter, pBuffer);
if ((ret = rsslEncodeMsg(&encodeIter, (RsslMsg*)&requestMsg)) != RSSL_RET_SUCCESS)
{
printf("<%s> rsslEncodeMsg() failed while sending item request: %d (%s).\n\n",
pSession->name,
ret, rsslRetCodeToString(ret));
rsslReleaseBuffer(pBuffer, &rsslError);
return ret;
}
pBuffer->length = rsslGetEncodedBufferLength(&encodeIter);
/* Write the message. */
if ((ret = snapshotSessionWrite(pSession, pBuffer)) != RSSL_RET_SUCCESS)
return ret;
printf("<%s> Sent request for item %s, %s on stream %d.\n\n",
pSession->name, pItem->symbolName,
rsslDomainTypeToString(pItem->domainType), pItem->snapshotServerStreamId);
}
return RSSL_RET_SUCCESS;
}
static RsslRet reflectPostMsg(ProviderThread *pProvThread, RsslDecodeIterator *pIter, ProviderSession *pProvSession, RsslPostMsg *pPostMsg)
{
RsslRet ret;
RsslChannel *pChannel = pProvSession->pChannelInfo->pChannel;
RsslMsg msgToReflect;
RsslEncodeIterator eIter;
switch(pPostMsg->msgBase.containerType)
{
case RSSL_DT_MSG:
if ((ret = rsslDecodeMsg(pIter, &msgToReflect)) != RSSL_RET_SUCCESS)
return ret;
break;
default:
/* It's a container(e.g. field list). Add an update header for reflecting. */
rsslClearUpdateMsg(&msgToReflect.updateMsg);
msgToReflect.updateMsg.msgBase.containerType = pPostMsg->msgBase.containerType;
msgToReflect.updateMsg.msgBase.domainType = pPostMsg->msgBase.domainType;
msgToReflect.updateMsg.msgBase.encDataBody = pPostMsg->msgBase.encDataBody;
break;
}
/* get a buffer for the response */
if (rtrUnlikely((ret = getItemMsgBuffer(pProvThread, pProvSession, 128 + msgToReflect.msgBase.encDataBody.length))
< RSSL_RET_SUCCESS))
return ret;
/* Add the post user info from the post message to the nested message and re-encode. */
rsslClearEncodeIterator(&eIter);
rsslSetEncodeIteratorRWFVersion(&eIter, pChannel->majorVersion, pChannel->minorVersion);
rsslSetEncodeIteratorBuffer(&eIter, pProvSession->pWritingBuffer);
/* Add stream ID of PostMsg to nested message. */
msgToReflect.msgBase.streamId = pPostMsg->msgBase.streamId;
/* Add PostUserInfo of PostMsg to nested message. */
switch(msgToReflect.msgBase.msgClass)
{
case RSSL_MC_REFRESH:
msgToReflect.refreshMsg.postUserInfo = pPostMsg->postUserInfo;
msgToReflect.refreshMsg.flags |= RSSL_RFMF_HAS_POST_USER_INFO;
msgToReflect.refreshMsg.flags &= ~RSSL_RFMF_SOLICITED;
break;
case RSSL_MC_UPDATE:
msgToReflect.updateMsg.postUserInfo = pPostMsg->postUserInfo;
msgToReflect.updateMsg.flags |= RSSL_UPMF_HAS_POST_USER_INFO;
break;
case RSSL_MC_STATUS:
msgToReflect.statusMsg.postUserInfo = pPostMsg->postUserInfo;
msgToReflect.statusMsg.flags |= RSSL_STMF_HAS_POST_USER_INFO;
break;
default:
printf("Error: Unhandled message class in post: %s(%u)\n",
rsslMsgClassToString(msgToReflect.msgBase.msgClass),
msgToReflect.msgBase.msgClass);
return RSSL_RET_FAILURE;
}
/* Other header members & data body should be properly set, so re-encode. */
if (ret = rsslEncodeMsg(&eIter, &msgToReflect) != RSSL_RET_SUCCESS)
return ret;
pProvSession->pWritingBuffer->length = rsslGetEncodedBufferLength(&eIter);
return sendItemMsgBuffer(pProvThread, pProvSession, RSSL_FALSE);
}
void encodeRefreshMsg( RsslUInt8 domainType, RsslInt32 streamId, RsslBuffer* pRsslBuffer )
{
RsslEncodeIterator eIter;
RsslRefreshMsg refreshMsg;
RsslFieldList fList;
RsslFieldEntry fEntry;
RsslBuffer payload;
char payloadBuffer[1024];
RsslUInt value;
RsslReal real;
RsslDate date;
RsslTime time;
payload.data = &payloadBuffer[0];
payload.length = 1024;
rsslClearEncodeIterator( &eIter );
rsslClearRefreshMsg( &refreshMsg );
rsslClearFieldList( &fList );
rsslClearFieldEntry( &fEntry );
refreshMsg.flags |= RSSL_RFMF_CLEAR_CACHE | RSSL_RFMF_HAS_MSG_KEY | RSSL_RFMF_REFRESH_COMPLETE;
refreshMsg.state.code = RSSL_SC_NONE;
refreshMsg.state.dataState = RSSL_DATA_OK;
refreshMsg.state.streamState = RSSL_STREAM_OPEN;
refreshMsg.state.text.data = (char*)"RefreshComplete";
refreshMsg.state.text.length = 15;
refreshMsg.msgBase.domainType = domainType;
refreshMsg.msgBase.streamId = streamId;
refreshMsg.msgBase.msgKey.flags |= RSSL_MKF_HAS_NAME | RSSL_MKF_HAS_SERVICE_ID;
refreshMsg.msgBase.msgKey.name.data = (char*)"item";
refreshMsg.msgBase.msgKey.name.length = 4;
refreshMsg.msgBase.msgKey.serviceId = 1;
if ( domainType = RSSL_DMT_MARKET_PRICE )
{
refreshMsg.msgBase.containerType = RSSL_DT_FIELD_LIST;
rsslSetEncodeIteratorBuffer( &eIter, &payload );
rsslSetEncodeIteratorRWFVersion( &eIter, RSSL_RWF_MAJOR_VERSION, RSSL_RWF_MINOR_VERSION );
fList.flags |= RSSL_FLF_HAS_STANDARD_DATA | RSSL_FLF_HAS_FIELD_LIST_INFO;
fList.fieldListNum = 1;
fList.dictionaryId = 1;
rsslEncodeFieldListInit( &eIter, &fList, 0, 0 );
fEntry.dataType = RSSL_DT_UINT;
fEntry.fieldId = 1;
value = 1;
rsslEncodeFieldEntry( &eIter, &fEntry, (void*)&value );
fEntry.dataType = RSSL_DT_REAL;
fEntry.fieldId = 6;
real.isBlank = RSSL_FALSE;
real.hint = RSSL_RH_EXPONENT_2;
real.value = 11;
rsslEncodeFieldEntry( &eIter, &fEntry, (void*)&real );
fEntry.dataType = RSSL_DT_DATE;
fEntry.fieldId = 16;
rsslClearDate(&date);
date.day = 7;
date.month = 11;
date.year = 1999;
rsslEncodeFieldEntry( &eIter, &fEntry, (void*)&date );
fEntry.dataType = RSSL_DT_TIME;
fEntry.fieldId = 18;
rsslClearTime(&time);
time.hour = 02;
time.minute = 03;
time.second = 04;
time.millisecond = 005;
rsslEncodeFieldEntry( &eIter, &fEntry, (void*)&time );
rsslEncodeFieldListComplete( &eIter, RSSL_TRUE );
payload.length = rsslGetEncodedBufferLength( &eIter );
refreshMsg.msgBase.encDataBody = payload;
rsslClearEncodeIterator( &eIter );
rsslSetEncodeIteratorBuffer( &eIter, pRsslBuffer );
rsslSetEncodeIteratorRWFVersion( &eIter, RSSL_RWF_MAJOR_VERSION, RSSL_RWF_MINOR_VERSION );
rsslEncodeMsg( &eIter, (RsslMsg*)&refreshMsg );
pRsslBuffer->length = rsslGetEncodedBufferLength( &eIter );
}
else if ( domainType = RSSL_DMT_MARKET_BY_ORDER )
{
refreshMsg.msgBase.containerType = RSSL_DT_MAP;
rsslSetEncodeIteratorBuffer( &eIter, &payload );
rsslSetEncodeIteratorRWFVersion( &eIter, RSSL_RWF_MAJOR_VERSION, RSSL_RWF_MINOR_VERSION );
}
else
{
}
}
void encodeUpdateMsg( RsslUInt8 domainType, RsslInt32 streamId, RsslBuffer* pRsslBuffer )
{
RsslEncodeIterator eIter;
RsslUpdateMsg updateMsg;
RsslFieldList fList;
RsslFieldEntry fEntry;
RsslBuffer payload;
char payloadBuffer[1024];
RsslUInt value;
RsslReal real;
RsslDate date;
RsslTime time;
payload.data = &payloadBuffer[0];
payload.length = 1024;
rsslClearEncodeIterator( &eIter );
rsslClearUpdateMsg( &updateMsg );
rsslClearFieldList( &fList );
rsslClearFieldEntry( &fEntry );
updateMsg.flags |= RSSL_UPMF_DO_NOT_CONFLATE;
updateMsg.msgBase.domainType = domainType;
updateMsg.msgBase.streamId = streamId;
if ( domainType = RSSL_DMT_MARKET_PRICE )
{
updateMsg.msgBase.containerType = RSSL_DT_FIELD_LIST;
rsslSetEncodeIteratorBuffer( &eIter, &payload );
rsslSetEncodeIteratorRWFVersion( &eIter, RSSL_RWF_MAJOR_VERSION, RSSL_RWF_MINOR_VERSION );
fList.flags |= RSSL_FLF_HAS_STANDARD_DATA | RSSL_FLF_HAS_FIELD_LIST_INFO;
fList.fieldListNum = 1;
fList.dictionaryId = 1;
rsslEncodeFieldListInit( &eIter, &fList, 0, 0 );
fEntry.dataType = RSSL_DT_UINT;
fEntry.fieldId = 1;
value = 1;
rsslEncodeFieldEntry( &eIter, &fEntry, (void*)&value );
fEntry.dataType = RSSL_DT_REAL;
fEntry.fieldId = 6;
real.isBlank = RSSL_FALSE;
real.hint = RSSL_RH_EXPONENT_2;
real.value = 11;
rsslEncodeFieldEntry( &eIter, &fEntry, (void*)&real );
fEntry.dataType = RSSL_DT_DATE;
fEntry.fieldId = 16;
rsslClearDate(&date);
date.day = 7;
date.month = 11;
date.year = 1999;
rsslEncodeFieldEntry( &eIter, &fEntry, (void*)&date );
fEntry.dataType = RSSL_DT_TIME;
fEntry.fieldId = 18;
rsslClearTime(&time);
time.hour = 02;
time.minute = 03;
time.second = 04;
time.millisecond = 005;
rsslEncodeFieldEntry( &eIter, &fEntry, (void*)&time );
rsslEncodeFieldListComplete( &eIter, RSSL_TRUE );
payload.length = rsslGetEncodedBufferLength( &eIter );
updateMsg.msgBase.encDataBody = payload;
rsslClearEncodeIterator( &eIter );
rsslSetEncodeIteratorBuffer( &eIter, pRsslBuffer );
rsslSetEncodeIteratorRWFVersion( &eIter, RSSL_RWF_MAJOR_VERSION, RSSL_RWF_MINOR_VERSION );
rsslEncodeMsg( &eIter, (RsslMsg*)&updateMsg );
pRsslBuffer->length = rsslGetEncodedBufferLength( &eIter );
}
else if ( domainType = RSSL_DMT_MARKET_BY_ORDER )
{
updateMsg.msgBase.containerType = RSSL_DT_MAP;
rsslSetEncodeIteratorBuffer( &eIter, &payload );
rsslSetEncodeIteratorRWFVersion( &eIter, RSSL_RWF_MAJOR_VERSION, RSSL_RWF_MINOR_VERSION );
updateMsg.msgBase.encDataBody = payload;
rsslClearEncodeIterator( &eIter );
rsslSetEncodeIteratorBuffer( &eIter, &payload );
rsslSetEncodeIteratorRWFVersion( &eIter, RSSL_RWF_MAJOR_VERSION, RSSL_RWF_MINOR_VERSION );
rsslEncodeMsg( &eIter, (RsslMsg*)&updateMsg );
pRsslBuffer->length = rsslGetEncodedBufferLength( &eIter );
}
else
{
}
}
