/* assuming pEncFieldList RsslBuffer contains the pre-encoded payload with data and length populated */
RsslRet getPreEncodedRsslFieldListBuffer(RsslBuffer *pEncUInt)
{
RsslRet retVal; //used to store and check the return value from the function calls
RsslUInt8 majorVersion = RSSL_RWF_MAJOR_VERSION; //This should be initialized to the MAJOR version of RWF being encoded
RsslUInt8 minorVersion = RSSL_RWF_MINOR_VERSION; // This should be initialized to the MINOR version of RWF being encoded
/* create and clear iterator to prepare for encoding */
RsslEncodeIterator encodeIter;
rsslClearEncodeIterator(&encodeIter);
/* associate buffer and iterator, code assumes that (&encDecBuffer)->data points to
sufficient memory and (&encDecBuffer)->length indicates number of bytes available in
pBuffer->data */
if ((retVal = rsslSetEncodeIteratorBuffer(&encodeIter, pEncUInt)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslSetEncodeIteratorBuffer(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
/* set proper protocol version information on iterator, this can typically be obtained from
the RsslChannel associated with the connection once it becomes active */
if ((retVal = rsslSetEncodeIteratorRWFVersion(&encodeIter, majorVersion, minorVersion)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslSetEncodeIteratorRWFVersion(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
if ((retVal = exampleEncodeFieldList(&encodeIter)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with exampleEncodeFieldList(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
//this is important!
/* When encoding is complete, set the pEncUInt->length to the number of bytes Encoded */
pEncUInt->length = rsslGetEncodedBufferLength(&encodeIter);
return RSSL_RET_SUCCESS;
}
/* This function encodes a map which contains nested field lists */
RsslRet exampleEncodeMap(RsslEncodeIterator *encIter)
{
/* use this to store and check return codes */
RsslRet retVal;
RsslBool success = RSSL_TRUE;
/* create and initialize our map structure */
RsslMap rsslMap = RSSL_INIT_MAP;
/* populate map structure prior to call to rsslEncodeMapInit */
/* NOTE: the key names used for this example may not correspond to actual name values */
/* indicate that summary data and a total count hint will be encoded */
rsslMap.flags = RSSL_MPF_HAS_SUMMARY_DATA | RSSL_MPF_HAS_TOTAL_COUNT_HINT;
/* populate maps keyPrimitiveType and containerType */
rsslMap.containerType = RSSL_DT_FIELD_LIST;
rsslMap.keyPrimitiveType = RSSL_DT_UINT;
/* populate total count hint with approximate expected entry count */
rsslMap.totalCountHint = 3;
/* begin encoding of map - assumes that the RsslEncodeIterator pointed by the encIter pointer is already populated with
buffer and version information, store return value to determine success or failure */
/* expect summary data of approx. 256 bytes, no set definition data */
if ((retVal = rsslEncodeMapInit(encIter, &rsslMap, 256, 0 )) < RSSL_RET_SUCCESS)
{
/* error condition - switch our success value to false so we can roll back */
success = RSSL_FALSE;
/* print out message with return value string, value, and text */
printf("Error %s (%d) encountered with rsslEncodeMapInit(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
}
else
{
/* mapInit encoding was successful */
/* create a single RsslMapEntry and RsslFieldList and reuse for each entry */
RsslMapEntry mapEntry = RSSL_INIT_MAP_ENTRY;
RsslUInt entryKeyUInt = 0;
/* create a buffer for uInt and field list to encode into -
This buffer can come from anywhere (stack allocated, malloc/new heap allocated). Typically, for performance, the transport layer can provide
a pool of buffers for use and reuse that avoids the constant allocation/deallocation penalty.
For this example I am stack allocating the buffer */
char buf[10] = ""; //10 bytes is large enough for UInt encoding
char buf2[500] = ""; //500 bytes is large enough for RsslFieldList encoding
/* create a RsslBuffer to set the buffer into */
RsslBuffer encDecBuffer, encDecBuffer2;
RsslBuffer *pEncUInt = 0, *pEncFieldList = 0;
/* set the data members to encDecBuffer buf and the length I created */
encDecBuffer.data = buf;
encDecBuffer.length = 10;
encDecBuffer2.data = buf2;
encDecBuffer2.length = 500;
printf("\tRsslMap Header Encoded\n");
/* encode expected summary data, init for this was done by rsslEncodeMapInit
- this type should match rsslMap.containerType */
{
printf("\tEncoding Summary Data\n");
/* now encode nested container using its own specific encode functions */
/* begin encoding of field list - using same encIterator as map list */
if ((retVal = exampleEncodeFieldList(encIter)) < RSSL_RET_SUCCESS)
{
/* error condition - switch our success value to false so we can roll back */
success = RSSL_FALSE;
printf("<%s:%d> Error encoding field list.\n", __FILE__, __LINE__);
printf("Error %s (%d) encountered with exampleEncodeFieldList(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
}
printf("\tSummary Data Encoding Complete\n");
}
/* complete encoding of summary data. If any field list encoding failed, success is false */
if ((retVal = rsslEncodeMapSummaryDataComplete(encIter, success)) < RSSL_RET_SUCCESS)
{
/* error condition - switch our success value to false so we can roll back */
success = RSSL_FALSE;
printf("Error %s (%d) encountered with rsslEncodeMapSummaryDataComplete(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
}
/* FIRST Map Entry: encode entry from non pre-encoded data and key. Approx. encoded length unknown */
mapEntry.action = RSSL_MPEA_UPDATE_ENTRY;
entryKeyUInt = 1;
if ((retVal = rsslEncodeMapEntryInit(encIter, &mapEntry, &entryKeyUInt, 0)) < RSSL_RET_SUCCESS)
{
/* error condition - switch our success value to false so we can roll back */
success = RSSL_FALSE;
printf("Error %s (%d) encountered with rsslEncodeMapEntryInit(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
}
else
/* encode contained field list - this type should match rsslMap.containerType */
{
printf("\tEncoding Map Entry (key: " RTR_LLU ") from non pre-encoded data and key\n", entryKeyUInt);
/* now encode nested container using its own specific encode functions */
/* clear, then begin encoding of field list - using same encIterator as map */
if ((retVal = exampleEncodeFieldList(encIter)) < RSSL_RET_SUCCESS)
{
/* error condition - switch our success value to false so we can roll back */
success = RSSL_FALSE;
printf("<%s:%d> Error encoding field list.\n", __FILE__, __LINE__);
printf("Error %s (%d) encountered with exampleEncodeFieldList(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
}
}
if ((retVal = rsslEncodeMapEntryComplete(encIter, success)) < RSSL_RET_SUCCESS)
{
/* error condition - switch our success value to false so we can roll back */
success = RSSL_FALSE;
printf("Error %s (%d) encountered with rsslEncodeMapEntryComplete(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
}
printf("\tMap Entry (key: " RTR_LLU ") Encoding Complete\n", entryKeyUInt);
/* SECOND Map Entry: encode entry from pre-encoded buffer containing an encoded RsslFieldList */
/* because we are re-populating all values on RsslMapEntry, there is no need to clear it */
mapEntry.action = RSSL_MPEA_ADD_ENTRY;
entryKeyUInt = 2;
printf("\tEncoding Map Entry (key: 2) from pre-encoded buffer\n");
/* assuming pEncUInt RsslBuffer contains the pre-encoded key with length and data properly populated */
if ((retVal = getPreEncodedRsslUIntBuffer(&encDecBuffer, entryKeyUInt)) < RSSL_RET_SUCCESS)
{
/* error condition - switch our success value to false so we can roll back */
success = RSSL_FALSE;
printf("Error %s (%d) encountered with getPreEncodedRsslUIntBuffer(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
}
pEncUInt = &encDecBuffer;
mapEntry.encKey.length = pEncUInt->length;
mapEntry.encKey.data = pEncUInt->data;
/* assuming pEncFieldList RsslBuffer contains the pre-encoded payload with data and length populated */
if ((retVal = getPreEncodedRsslFieldListBuffer(&encDecBuffer2)) < RSSL_RET_SUCCESS)
{
/* error condition - switch our success value to false so we can roll back */
success = RSSL_FALSE;
printf("Error %s (%d) encountered with getPreEncodedRsslFieldListBuffer(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
}
pEncFieldList = &encDecBuffer2;
mapEntry.encData.length = pEncFieldList->length;
mapEntry.encData.data = pEncFieldList->data;
/* void* parameter is passed in as NULL because pre-encoded key is set on RsslMapEntry itself */
if ((retVal = rsslEncodeMapEntry(encIter, &mapEntry, NULL)) < RSSL_RET_SUCCESS)
{
/* error condition - switch our success value to false so we can roll back */
success = RSSL_FALSE;
printf("Error %s (%d) encountered with rsslEncodeMapEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
}
printf("\tMap Entry (key: " RTR_LLU ") Encoding Complete\n", entryKeyUInt);
/* THIRD Map Entry: encode entry with delete action. Delete actions have no payload */
/* need to ensure that RsslMapEntry is appropriatley cleared
* - clearing will ensure that encData and encKey are properly emptied */
rsslClearMapEntry(&mapEntry);
mapEntry.action = RSSL_MPEA_DELETE_ENTRY;
entryKeyUInt = 3;
printf("\tEncoding Map Entry (key: " RTR_LLU ") with delete action with no payload\n", entryKeyUInt);
/* void* parameter is passed in as pointer to key primitive value. encData is empty for delete */
if ((retVal = rsslEncodeMapEntry(encIter, &mapEntry, &entryKeyUInt)) < RSSL_RET_SUCCESS)
{
/* error condition - switch our success value to false so we can roll back */
success = RSSL_FALSE;
printf("Error %s (%d) encountered with rsslEncodeMapEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
}
printf("\tMap Entry (key: " RTR_LLU ") Encoding Complete\n", entryKeyUInt);
}
/* complete map encoding. If success parameter is true, this will finalize encoding.
If success parameter is false, this will roll back encoding prior to rsslEncodeMapInit */
if ((retVal = rsslEncodeMapComplete(encIter, success)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslEncodeMapEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
printf("\tRsslMap Encoding Complete\n");
return RSSL_RET_SUCCESS;
}
/* decodes the simple map that is encoded above */
RsslRet exampleDecodeMap(RsslDecodeIterator *decIter)
{
/* used to store and check return codes */
RsslRet retVal;
/* create our map to decode into */
RsslMap rsslMap = RSSL_INIT_MAP;
/* decode contents into the map structure */
/* decode our map header */
if ((retVal = rsslDecodeMap(decIter, &rsslMap)) >= RSSL_RET_SUCCESS)
{
/* create primitive value to have key decoded into and a single map entry to reuse */
RsslUInt rsslUInt = 0;
RsslMapEntry mapEntry = RSSL_INIT_MAP_ENTRY;
printf("\tRsslMap Header Decoded: TotalCountHint: %d\n", rsslMap.totalCountHint);
/* if summary data is present, invoking decoder for that type (instead of DecodeEntry)
indicates to UPA that user wants to decode summary data */
if (rsslMap.flags & RSSL_MPF_HAS_SUMMARY_DATA)
{
/* summary data is present. Its type should be that of rsslMap.containerType */
printf("\tDecoding Summary Data\n");
/* Continue decoding field entries. See example in Section 11.3.1 */
/* decode the field list */
if ((retVal = exampleDecodeFieldList(decIter)) < RSSL_RET_SUCCESS)
{
printf("<%s:%d> Error decoding nested field list.\n", __FILE__, __LINE__);
printf("Error %s (%d) encountered with exampleEncodeFieldList(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
printf("\tSummary Data Decoding Complete\n");
}
/* decode each map entry, passing in pointer to keyPrimitiveType decodes mapEntry key as well */
while ((retVal = rsslDecodeMapEntry(decIter, &mapEntry, &rsslUInt)) != RSSL_RET_END_OF_CONTAINER)
{
if (retVal < RSSL_RET_SUCCESS)
{
/* decoding failure tends to be unrecoverable */
printf("Error %s (%d) encountered with rsslDecodeMapEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
else
{
/* Continue decoding field entries. */
printf("\tDecoding Map Entry (key: " RTR_LLU ")\n", rsslUInt);
/* Delete actions have no payload and we need to avoid decoding FieldList for this situation */
if (mapEntry.action != RSSL_MPEA_DELETE_ENTRY)
{
if ((retVal = exampleDecodeFieldList(decIter)) < RSSL_RET_SUCCESS)
{
printf("<%s:%d> Error decoding nested field list.\n", __FILE__, __LINE__);
printf("Error %s (%d) encountered with exampleEncodeFieldList(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
}
else
{
printf("\tMap Entry (key: " RTR_LLU ") delete actions have no payload to decode\n", rsslUInt);
}
printf("\tMap Entry (key: " RTR_LLU ") Decoding Complete\n", rsslUInt);
}
}
}
else
{
/* decoding failure tends to be unrecoverable */
printf("Error %s (%d) encountered with rsslDecodeMap(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
printf("\tRsslMap Decoding Complete\n");
return RSSL_RET_SUCCESS;
}
static RsslRet processSymbolListResponse(SnapshotSession* pSession, RsslMsg* msg, RsslDecodeIterator* dIter)
{
RsslRet ret = 0;
RsslMsgKey* key = 0;
RsslMap rsslMap;
RsslMapEntry mapEntry;
RsslVector rsslVector;
RsslVectorEntry vectorEntry;
char tempData[1024];
char mapKeyData[32];
RsslBuffer tempBuffer;
RsslBuffer fidBufferValue;
RsslLocalFieldSetDefDb fieldSetDefDb;
RsslLocalElementSetDefDb elemSetDefDb;
RsslElementList elemList;
RsslElementEntry elemEntry;
RsslFieldEntry fieldEntry;
RsslFieldList fieldList;
RsslBuffer stringBuf;
char data[24];
tempBuffer.data = tempData;
tempBuffer.length = 1024;
switch(msg->msgBase.msgClass)
{
case RSSL_MC_REFRESH:
printf("\n<%s> Received symbol list refresh.\n\n", pSession->name);
case RSSL_MC_UPDATE:
/* decode symbol list response */
/* get key*/
key = (RsslMsgKey *)rsslGetMsgKey(msg);
if(msg->msgBase.msgClass == RSSL_MC_REFRESH)
{
rsslStateToString(&tempBuffer, &msg->refreshMsg.state);
printf("%.*s\n", tempBuffer.length, tempBuffer.data);
}
rsslClearMap(&rsslMap);
if ((ret = rsslDecodeMap(dIter, &rsslMap)) != RSSL_RET_SUCCESS)
{
printf("<%s> rsslDecodeMap() failed with return code: %d\n", pSession->name, ret);
return RSSL_RET_FAILURE;
}
if (rsslMap.flags & RSSL_MPF_HAS_SET_DEFS)
{
/* must ensure it is the correct type - if map contents are element list, this is a field set definition db */
if (rsslMap.containerType == RSSL_DT_FIELD_LIST)
{
rsslClearLocalFieldSetDefDb(&fieldSetDefDb);
if ((ret = rsslDecodeLocalFieldSetDefDb(dIter, &fieldSetDefDb)) < RSSL_RET_SUCCESS)
{
/* decoding failures tend to be unrecoverable */
printf("<%s> Error %s (%d) encountered with rsslDecodeLocalElementSetDefDb(). Error Text: %s\n",
pSession->name,
rsslRetCodeToString(ret), ret, rsslRetCodeInfo(ret));
return ret;
}
}
}
/* decode the map */
while ((ret = rsslDecodeMapEntry(dIter, &mapEntry, mapKeyData)) != RSSL_RET_END_OF_CONTAINER)
{
if(ret != RSSL_RET_SUCCESS)
{
printf("<%s> rsslDecodeMapEntry() failed with return code: %d\n", pSession->name, ret);
return RSSL_RET_FAILURE;
}
stringBuf.data = data;
stringBuf.length = 24;
rsslPrimitiveToString(&mapKeyData,rsslMap.keyPrimitiveType,&stringBuf);
printf("\nID: %s, ", stringBuf.data);
pSession->symbolListEntry[SymbolListCounter] = (SymbolListEntry*)malloc(sizeof(SymbolListEntry));
pSession->symbolListEntry[SymbolListCounter]->id = atoi(stringBuf.data);
if ((ret = rsslDecodeFieldList(dIter, &fieldList, &fieldSetDefDb)) != RSSL_RET_SUCCESS)
{
printf("<%s> rsslDecodeMap() failed with return code: %d\n", pSession->name, ret);
return RSSL_RET_FAILURE;
}
/* The following fields are needed to uniquely identify a symbol on the realtime and gap fill streams:
FID Name Type
3422 Provider Symbol RMTES_STRING
8746 Provider Symbol 2 RMTES_STRING
32639 Multicast channel(RT) Vector of Element Lists
32640 Multicast Channel(Gapfill) Vector of Element Lists
*/
while ((ret = rsslDecodeFieldEntry(dIter, &fieldEntry)) != RSSL_RET_END_OF_CONTAINER)
{
if (ret != RSSL_RET_SUCCESS)
{
printf("<%s> rsslDecodeFieldEntry() failed with return code: %d\n", pSession->name, ret);
return RSSL_RET_FAILURE;
}
if(fieldEntry.fieldId == 8746)
{
if ((ret = rsslDecodeBuffer(dIter, &fidBufferValue)) == RSSL_RET_SUCCESS)
{
//snprintf(&pSession->symbolListEntry[SymbolListCounter]->name[0], 128, "%.*s", fidBufferValue.length, fidBufferValue.data);
printf("SYMBOL2: %s", fidBufferValue.data);
}
else if (ret != RSSL_RET_BLANK_DATA)
{
printf("<%s> Error: %s (%d) encountered with rsslDecodeBuffer(). Error Text: %s\n",
pSession->name,
rsslRetCodeToString(ret), ret, rsslRetCodeInfo(ret));
return ret;
}
}
else if (fieldEntry.fieldId == 3422)
{
if ((ret = rsslDecodeBuffer(dIter, &fidBufferValue)) == RSSL_RET_SUCCESS)
{
snprintf(&pSession->symbolListEntry[SymbolListCounter]->name[0], 128, "%.*s", fidBufferValue.length, fidBufferValue.data);
printf("SYMBOL: %s", pSession->symbolListEntry[SymbolListCounter]->name);
}
else if (ret != RSSL_RET_BLANK_DATA)
{
printf("<%s> Error: %s (%d) encountered with rsslDecodeBuffer(). Error Text: %s\n",
pSession->name,
rsslRetCodeToString(ret), ret, rsslRetCodeInfo(ret));
return ret;
}
}
else if (fieldEntry.fieldId == 32639)
{
int countStreamingChan = 0;
rsslClearVector(&rsslVector);
if ((ret = rsslDecodeVector(dIter, &rsslVector)) != RSSL_RET_SUCCESS)
{
printf("<%s> rsslDecodeVector() failed with return code: %d\n", pSession->name, ret);
return RSSL_RET_FAILURE;
}
if (rsslVector.flags & RSSL_VTF_HAS_SET_DEFS)
{
/* must ensure it is the correct type - if map contents are element list, this is a field set definition db */
if (rsslVector.containerType == RSSL_DT_ELEMENT_LIST)
{
rsslClearLocalElementSetDefDb(&elemSetDefDb);
if ((ret = rsslDecodeLocalElementSetDefDb(dIter, &elemSetDefDb)) < RSSL_RET_SUCCESS)
{
/* decoding failures tend to be unrecoverable */
printf("<%s> Error %s (%d) encountered with rsslDecodeLocalElementSetDefDb(). Error Text: %s\n",
pSession->name,
rsslRetCodeToString(ret), ret, rsslRetCodeInfo(ret));
return ret;
}
}
}
/* decode the vector */
while ((ret = rsslDecodeVectorEntry(dIter, &vectorEntry)) != RSSL_RET_END_OF_CONTAINER)
{
if(ret != RSSL_RET_SUCCESS)
{
printf("<%s> rsslDecodeVectorEntry() failed with return code: %d\n", pSession->name, ret);
return RSSL_RET_FAILURE;
}
rsslClearElementList(&elemList);
if ((ret = rsslDecodeElementList(dIter, &elemList, &elemSetDefDb)) != RSSL_RET_SUCCESS)
{
printf("<%s> rsslDecodeElementList() failed with return code: %d\n", pSession->name, ret);
return RSSL_RET_FAILURE;
}
while ((ret = rsslDecodeElementEntry(dIter, &elemEntry)) != RSSL_RET_END_OF_CONTAINER)
{
if (ret != RSSL_RET_SUCCESS)
{
printf("<%s> rsslDecodeElementEntry() failed with return code: %d\n", pSession->name, ret);
return RSSL_RET_FAILURE;
}
if (rsslBufferIsEqual(&elemEntry.name, &RSSL_ENAME_CHANNEL_ID))
{
if ((ret = rsslDecodeUInt(dIter, &pSession->symbolListEntry[SymbolListCounter]->streamingChannels[countStreamingChan].channelId)) == RSSL_RET_SUCCESS)
{
printf(" StreamingChanId: %d", pSession->symbolListEntry[SymbolListCounter]->streamingChannels[countStreamingChan].channelId);
}
else
{
printf("<%s> Error: %s (%d) encountered with rsslDecodeUInt(). Error Text: %s\n",
pSession->name,
rsslRetCodeToString(ret), ret, rsslRetCodeInfo(ret));
return ret;
}
}
else if (rsslBufferIsEqual(&elemEntry.name, &RSSL_ENAME_DOMAIN))
{
if ((ret = rsslDecodeUInt(dIter, &pSession->symbolListEntry[SymbolListCounter]->streamingChannels[countStreamingChan].domain)) == RSSL_RET_SUCCESS)
{
printf(" StreamingChanDom: %d", pSession->symbolListEntry[SymbolListCounter]->streamingChannels[countStreamingChan].domain);
}
else
{
printf("<%s> Error: %s (%d) encountered with rsslDecodeUInt(). Error Text: %s\n",
pSession->name,
rsslRetCodeToString(ret), ret, rsslRetCodeInfo(ret));
return ret;
}
}
}
countStreamingChan++;
}
}
else if (fieldEntry.fieldId == 32640)
{
int countGapChan = 0;
rsslClearVector(&rsslVector);
if ((ret = rsslDecodeVector(dIter, &rsslVector)) != RSSL_RET_SUCCESS)
{
printf("<%s> rsslDecodeVector() failed with return code: %d\n", pSession->name, ret);
return RSSL_RET_FAILURE;
}
if (rsslVector.flags & RSSL_VTF_HAS_SET_DEFS)
{
/* must ensure it is the correct type - if map contents are element list, this is a field set definition db */
if (rsslVector.containerType == RSSL_DT_ELEMENT_LIST)
{
rsslClearLocalElementSetDefDb(&elemSetDefDb);
if ((ret = rsslDecodeLocalElementSetDefDb(dIter, &elemSetDefDb)) < RSSL_RET_SUCCESS)
{
/* decoding failures tend to be unrecoverable */
printf("<%s> Error %s (%d) encountered with rsslDecodeLocalElementSetDefDb(). Error Text: %s\n",
pSession->name,
rsslRetCodeToString(ret), ret, rsslRetCodeInfo(ret));
return ret;
}
}
}
/* decode the vector */
while ((ret = rsslDecodeVectorEntry(dIter, &vectorEntry)) != RSSL_RET_END_OF_CONTAINER)
{
if(ret != RSSL_RET_SUCCESS)
{
printf("<%s> rsslDecodeVectorEntry() failed with return code: %d\n", pSession->name, ret);
return RSSL_RET_FAILURE;
}
rsslClearElementList(&elemList);
if ((ret = rsslDecodeElementList(dIter, &elemList, &elemSetDefDb)) != RSSL_RET_SUCCESS)
{
printf("<%s> rsslDecodeElementList() failed with return code: %d\n", pSession->name, ret);
return RSSL_RET_FAILURE;
}
while ((ret = rsslDecodeElementEntry(dIter, &elemEntry)) != RSSL_RET_END_OF_CONTAINER)
{
if (ret != RSSL_RET_SUCCESS)
{
printf("<%s> rsslDecodeElementEntry() failed with return code: %d\n", pSession->name, ret);
return RSSL_RET_FAILURE;
}
if (rsslBufferIsEqual(&elemEntry.name, &RSSL_ENAME_CHANNEL_ID))
{
if ((ret = rsslDecodeUInt(dIter, &pSession->symbolListEntry[SymbolListCounter]->gapChannels[countGapChan].channelId)) == RSSL_RET_SUCCESS)
{
printf(" GapChanId: %d", pSession->symbolListEntry[SymbolListCounter]->gapChannels[countGapChan].channelId);
}
else
{
printf("<%s> Error: %s (%d) encountered with rsslDecodeUInt(). Error Text: %s\n",
pSession->name,
rsslRetCodeToString(ret), ret, rsslRetCodeInfo(ret));
return ret;
}
}
else if (rsslBufferIsEqual(&elemEntry.name, &RSSL_ENAME_DOMAIN))
{
if ((ret = rsslDecodeUInt(dIter, &pSession->symbolListEntry[SymbolListCounter]->gapChannels[countGapChan].domain)) == RSSL_RET_SUCCESS)
{
printf(" GapChanlDom: %d", pSession->symbolListEntry[SymbolListCounter]->gapChannels[countGapChan].domain);
}
else
{
printf("<%s> Error: %s (%d) encountered with rsslDecodeUInt(). Error Text: %s\n",
pSession->name,
rsslRetCodeToString(ret), ret, rsslRetCodeInfo(ret));
return ret;
}
}
}
}
countGapChan++;
}
}
SymbolListCounter++;
}
break;
case RSSL_MC_STATUS:
printf("\n<%s> Received Item StatusMsg for stream %i \n", pSession->name, msg->statusMsg.msgBase.streamId);
if (msg->statusMsg.flags & RSSL_STMF_HAS_STATE)
{
rsslStateToString(&tempBuffer, &msg->statusMsg.state);
printf(" %.*s\n\n", tempBuffer.length, tempBuffer.data);
}
break;
case RSSL_MC_ACK:
/* although this application only posts on MP (Market Price),
* ACK handler is provided for other domains to allow user to extend
* and post on MBO (Market By Order), MBP (Market By Price), SymbolList, and Yield Curve domains */
printf("\n<%s> Received AckMsg for stream %i \n", pSession->name, msg->msgBase.streamId);
/* get key */
key = (RsslMsgKey *)rsslGetMsgKey(msg);
/* print out item name from key if it has it */
if (key)
{
printf("%.*s\nDOMAIN: %s\n", key->name.length, key->name.data, rsslDomainTypeToString(msg->msgBase.domainType));
}
printf("\tackId=%u\n", msg->ackMsg.ackId);
if (msg->ackMsg.flags & RSSL_AKMF_HAS_SEQ_NUM)
printf("\tseqNum=%u\n", msg->ackMsg.seqNum);
if (msg->ackMsg.flags & RSSL_AKMF_HAS_NAK_CODE)
printf("\tnakCode=%u\n", msg->ackMsg.nakCode);
if (msg->ackMsg.flags & RSSL_AKMF_HAS_TEXT)
printf("\ttext=%.*s\n", msg->ackMsg.text.length, msg->ackMsg.text.data);
break;
default:
printf("\n<%s> Recieved Unhandled Item Msg Class: %d\n", pSession->name, msg->msgBase.msgClass);
break;
}
return RSSL_RET_SUCCESS;
}
/* this function will encode a basic element list with several primitives embedded in it */
RsslRet exampleDecodeElementList(RsslDecodeIterator *decIter)
{
/* create and initialize element list structure */
RsslElementList elementList = RSSL_INIT_ELEMENT_LIST;
/* create a single RsslElementEntry and reuse for each entry */
RsslElementEntry elemEntry = RSSL_INIT_ELEMENT_ENTRY;
/* used to store and check return codes */
RsslRet retVal;
/* structures for decoding various data types */
RsslTime rsslTime;
RsslReal rsslReal;
RsslInt rsslInt;
RsslUInt rsslUInt;
/* decode into the element list structure */
if ((retVal = rsslDecodeElementList(decIter, &elementList, NULL)) < RSSL_RET_SUCCESS)
{
/* decoding failure tends to be unrecoverable */
printf("Error %s (%d) encountered with rsslDecodeElementList(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return RSSL_RET_FAILURE;
}
printf("\tElementList Header Decoded\n");
/* decode each element entry */
while ((retVal = rsslDecodeElementEntry(decIter, &elemEntry)) != RSSL_RET_END_OF_CONTAINER)
{
if (retVal < RSSL_RET_SUCCESS)
{
/* decoding failure tends to be unrecoverable */
printf("Error %s (%d) encountered with rsslDecodeElementEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return RSSL_RET_FAILURE;
}
/* Continue decoding field entries. */
printf("\tDecoding Element Entry (name: %.*s) \n", elemEntry.name.length, elemEntry.name.data);
/* use elemEntry.dataType to call correct primitive decode function */
switch (elemEntry.dataType)
{
case RSSL_DT_REAL:
if ((retVal = rsslDecodeReal(decIter, &rsslReal)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslDecodeReal(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return RSSL_RET_FAILURE;
}
if (rsslReal.isBlank)
printf("\t\tDecoded RsslReal: Blank\n");
else
printf("\t\tRsslReal Decoded: hint: %d value: " RTR_LLD "\n", rsslReal.hint, rsslReal.value);
break;
case RSSL_DT_TIME:
if ((retVal = rsslDecodeTime(decIter, &rsslTime)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslDecodeTime(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return RSSL_RET_FAILURE;
}
printf("\t\tRsslTime Decoded: %d:%d:%d\n", rsslTime.hour, rsslTime.minute, rsslTime.second);
break;
case RSSL_DT_INT:
if ((retVal = rsslDecodeInt(decIter, &rsslInt)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslDecodeInt(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return RSSL_RET_FAILURE;
}
printf("\t\tRsslInt Decoded: " RTR_LLD "\n", rsslInt);
break;
case RSSL_DT_UINT:
if ((retVal = rsslDecodeUInt(decIter, &rsslUInt)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslDecodeUInt(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return RSSL_RET_FAILURE;
}
printf("\t\tRsslUInt Decoded: " RTR_LLU "\n", rsslUInt);
break;
default:
printf("Error: unexpected datatype(%d) found in elementList\n", elemEntry.dataType);
break;
}
}
printf("\tElementList Decoding Complete\n");
return RSSL_RET_SUCCESS;
}
/* this function will encode a basic Element list with several primitives embedded in it */
RsslRet exampleEncodeElementList(RsslEncodeIterator *encIter)
{
/* create a single RsslElementEntry and reuse for each entry */
RsslElementEntry elemEntry = RSSL_INIT_ELEMENT_ENTRY;
/* used to store and check return values */
RsslRet retVal;
/* create and initialize element list structure */
RsslElementList elementList = RSSL_INIT_ELEMENT_LIST;
/* various data types used during encoding */
RsslTime rsslTime = {10, 21, 16, 777};
RsslUInt rsslUInt = 17;
RsslInt rsslInt = 13;
/* populate element list structure prior to call to rsslEncodeElementListInit */
/* indicate that standard data will be encoded and that elementListNum is included */
elementList.flags = RSSL_ELF_HAS_STANDARD_DATA | RSSL_ELF_HAS_ELEMENT_LIST_INFO;
/* populate elementListNum with info needed to cache */
elementList.elementListNum = 5;
/* begin encoding of element list - assumes that the RsslEncodeIterator pointed by the encIter pointer is already populated with buffer and version information */
/* Please note: here for simplicity, we did not use success parameter for rsslEncodeElementListInit/rsslEncodeElementListComplete calls.
We are just simply displaying an error if it occurs and exit, thus RSSL_TRUE is used in replacement for success parameter */
if ((retVal = rsslEncodeElementListInit(encIter, &elementList, 0, 0)) < RSSL_RET_SUCCESS)
{
/* print out message with return value string, value, and text */
printf("Error %s (%d) encountered with rsslEncodeElementListInit(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
/* FIRST Element Entry: encode entry from the RsslTime primitive type */
/* populate and encode element entry with name and dataType information for this element */
elemEntry.name.data = (char *)"Element - RsslTime";
elemEntry.name.length = 20;
elemEntry.dataType = RSSL_DT_TIME;
printf("\tEncoding Element Entry (name: %.*s) \n", elemEntry.name.length, elemEntry.name.data);
retVal = rsslEncodeElementEntry(encIter, &elemEntry, &rsslTime);
printf("\t\tEncoded RsslTime: %d:%d:%d\n", rsslTime.hour, rsslTime.minute, rsslTime.second);
/* SECOND Element Entry: encode entry from the RsslInt primitive type */
/* populate and encode element entry with name and dataType information for this element */
elemEntry.name.data = (char *)"Element - RsslInt";
elemEntry.name.length = 17;
elemEntry.dataType = RSSL_DT_INT;
printf("\tEncoding Element Entry (name: %.*s) \n", elemEntry.name.length, elemEntry.name.data);
retVal = rsslEncodeElementEntry(encIter, &elemEntry, &rsslInt);
printf("\t\tEncoded signed Integer: " RTR_LLD "\n", rsslInt);
/* THIRD Element Entry: encode entry from the RsslUInt primitive type */
/* populate and encode element entry with name and dataType information for this element */
elemEntry.name.data = (char *)"Element - RsslUInt";
elemEntry.name.length = 18;
elemEntry.dataType = RSSL_DT_UINT;
printf("\tEncoding Element Entry (name: %.*s) \n", elemEntry.name.length, elemEntry.name.data);
retVal = rsslEncodeElementEntry(encIter, &elemEntry, &rsslUInt);
printf("\t\tEncoded Unsigned Integer: " RTR_LLU "\n", rsslUInt);
/* FOURTH Element Entry: encode entry from the RsslReal primitive type */
/* populate and encode element entry with name and dataType information for this element */
rsslClearElementEntry(&elemEntry); // clear this to ensure a blank field
elemEntry.name.data = (char *)"Element - RsslReal - Blank";
elemEntry.name.length = 26;
elemEntry.dataType = RSSL_DT_REAL;
printf("\tEncoding Element Entry (name: %.*s) \n", elemEntry.name.length, elemEntry.name.data);
retVal = rsslEncodeElementEntry(encIter, &elemEntry, NULL); /* this encodes a blank */
printf("\t\tEncoded RsslReal: Blank\n");
/* complete elementList encoding. If success parameter is true, this will finalize encoding.
If success parameter is false, this will roll back encoding prior to rsslEncodeElementListInit */
if ((retVal = rsslEncodeElementListComplete(encIter, RSSL_TRUE)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslEncodeElementListComplete(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
printf("\tElementList Encoding Complete\n");
return RSSL_RET_SUCCESS;
}
/* this function will encode a basic field list with several primitives
embedded in it */
RsslRet exampleEncodeFieldList(RsslEncodeIterator *encIter)
{
/* used to store and check return values */
RsslRet retVal;
/* create and initialize field list structure */
RsslFieldList fieldList = RSSL_INIT_FIELD_LIST;
/* populate field list structure prior to call to rsslEncodeFieldListInit */
/* NOTE: the fieldId, dictionaryId and fieldListNum values used for this example
* do not correspond to actual id values */
/* indicate that standard data will be encoded and that dictionaryId and fieldListNum are included */
fieldList.flags = RSSL_FLF_HAS_STANDARD_DATA | RSSL_FLF_HAS_FIELD_LIST_INFO;
/* populate dictionaryId and fieldListNum with info needed to cross-reference fieldIds and cache */
fieldList.dictionaryId = 2;
fieldList.fieldListNum = 5;
/* begin encoding of field list - assumes that the RsslEncodeIterator pointed by the encIter pointer is already populated with
buffer and version information */
/* Please note: here for simplicity, we did not use success parameter for rsslEncodeFieldListInit/rsslEncodeFieldListComplete calls.
We are just simply displaying an error if it occurs and exit, thus RSSL_TRUE is used in replacement for success parameter */
if ((retVal = rsslEncodeFieldListInit(encIter, &fieldList, 0, 0)) < RSSL_RET_SUCCESS)
{
/* print out message with return value string, value, and text */
printf("Error %s (%d) encountered with rsslEncodeFieldListInit(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
else
{
/* fieldListInit encoding was successful */
/* create a single RsslFieldEntry and reuse for each entry */
RsslFieldEntry fieldEntry = RSSL_INIT_FIELD_ENTRY;
RsslBool success = RSSL_TRUE;
/* stack allocate a date and populate {day, month, year} */
RsslDate rsslDate = {30, 11, 2010};
RsslReal rsslReal = RSSL_INIT_REAL;
RsslTime rsslTime = RSSL_INIT_TIME;
RsslArray rsslArray = RSSL_INIT_ARRAY;
RsslDateTime rsslDateTime = RSSL_INIT_DATETIME;
RsslQos rsslQos = RSSL_INIT_QOS;
RsslState rsslState = RSSL_INIT_STATE;
RsslEnum rsslEnum = 0;
RsslBuffer rsslBuffer = RSSL_INIT_BUFFER;
RsslUInt uInt = 23456;
RsslInt Int = 65432;
RsslFloat Float = 3.14f;
RsslDouble Double = 3.1416;
/* create a buffer for uInt to encode into -
This buffer can come from anywhere (stack allocated, malloc/new heap allocated). Typically, for performance, the transport layer can provide
a pool of buffers for use and reuse that avoids the constant allocation/deallocation penalty.
For this example I am stack allocating the buffer */
char buf[10] = ""; //10 bytes is large enough for UInt encoding
/* create a RsslBuffer to set the buffer into */
RsslBuffer encDecBuffer;
RsslBuffer *pEncUInt = 0;
/* set the data members to encDecBuffer buf and the length I created */
encDecBuffer.data = buf;
encDecBuffer.length = 10;
printf("\tFieldList Header Encoded\n");
/* FIRST Field Entry: encode entry from the RsslDate primitive type */
/* populate and encode field entry with fieldId and dataType information for this field */
fieldEntry.fieldId = 16;
fieldEntry.dataType = RSSL_DT_DATE;
if ((retVal = rsslEncodeFieldEntry(encIter, &fieldEntry, &rsslDate)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslEncodeFieldEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
printf("\t\tFID %d Encoded Date: %d-%d-%d\n", fieldEntry.fieldId, rsslDate.month, rsslDate.day, rsslDate.year);
/* SECOND Field Entry: encode entry from the RsslUInt primitive type */
fieldEntry.fieldId = 1080;
fieldEntry.dataType = RSSL_DT_UINT;
if ((retVal = rsslEncodeFieldEntry(encIter, &fieldEntry, &uInt)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslEncodeFieldEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
printf("\t\tFID %d Encoded Unsigned Integer: "RTR_LLU"\n", fieldEntry.fieldId, uInt);
/* THIRD Field Entry: encode entry from preencoded buffer containing an encoded RsslUInt type */
/* populate and encode field entry with fieldId and dataType information for this field */
/* because we are re-populating all values on RsslFieldEntry, there is no need to clear it */
fieldEntry.fieldId = 1081;
fieldEntry.dataType = RSSL_DT_UINT;
/* assuming pEncUInt is an RsslBuffer with length and data properly populated */
if ((retVal = getPreEncodedRsslUIntBuffer(&encDecBuffer, uInt)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with getPreEncodedRsslUIntBuffer(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
pEncUInt = &encDecBuffer;
fieldEntry.encData.length = pEncUInt->length;
fieldEntry.encData.data = pEncUInt->data;
/* void* parameter is passed in as NULL because pre-encoded data is set on RsslFieldEntry itself */
if ((retVal = rsslEncodeFieldEntry(encIter, &fieldEntry, NULL)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslEncodeFieldEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
printf("\t\tFID %d Encoded Unsigned Integer: from preencoded buffer\n", fieldEntry.fieldId);
/* FOURTH Field Entry: encode entry as a blank RsslReal primitive type */
/* populate and encode field entry with fieldId and dataType information for this field */
/* need to ensure that RsslFieldEntry is appropriatley cleared
* - clearing will ensure that encData is properly emptied */
rsslClearFieldEntry(&fieldEntry);
fieldEntry.fieldId = 22;
fieldEntry.dataType = RSSL_DT_REAL;
/* void* parameter is passed in as NULL and encData is empty due to clearing */
if ((retVal = rsslEncodeFieldEntry(encIter, &fieldEntry, NULL)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslEncodeFieldEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
printf("\t\tFID %d Encoded RsslReal as blank.\n", fieldEntry.fieldId);
/* FIFTH Field Entry: encode entry for a RsslReal primitive type */
fieldEntry.fieldId = 24;
fieldEntry.dataType = RSSL_DT_REAL;
rsslReal.hint = RSSL_RH_EXPONENT_2;
rsslReal.value = 227;
if ((retVal = rsslEncodeFieldEntry(encIter, &fieldEntry, &rsslReal)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslEncodeFieldEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
printf("\t\tFID %d Encoded RsslReal: hint: %d value: "RTR_LLD"\n", fieldEntry.fieldId, rsslReal.hint, rsslReal.value);
/* SIXTH Field Entry: encode entry for another RsslReal primitive type */
fieldEntry.fieldId = 25;
fieldEntry.dataType = RSSL_DT_REAL;
rsslReal.hint = RSSL_RH_EXPONENT_4;
rsslReal.value = 22801;
if ((retVal = rsslEncodeFieldEntry(encIter, &fieldEntry, &rsslReal)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslEncodeFieldEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
printf("\t\tFID %d Encoded RsslReal: hint: %d value: "RTR_LLD"\n", fieldEntry.fieldId, rsslReal.hint, rsslReal.value);
/* SEVENTH Field Entry: encode entry for another RsslTime primitive type */
fieldEntry.fieldId = 18;
fieldEntry.dataType = RSSL_DT_TIME;
rsslTime.hour = 8;
rsslTime.minute = 39;
rsslTime.second = 24;
if ((retVal = rsslEncodeFieldEntry(encIter, &fieldEntry, &rsslTime)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslEncodeFieldEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
printf("\t\tFID %d Encoded RsslTime: %d:%d:%d\n", fieldEntry.fieldId, rsslTime.hour, rsslTime.minute, rsslTime.second);
/* EIGHTH Field Entry: encode entry from the RsslInt primitive type */
fieldEntry.fieldId = FID_INT;
fieldEntry.dataType = RSSL_DT_INT;
if ((retVal = rsslEncodeFieldEntry(encIter, &fieldEntry, &Int)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslEncodeFieldEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
printf("\t\tFID %d Encoded signed Integer: "RTR_LLD"\n", fieldEntry.fieldId, Int);
/* NINETH Field Entry: encode entry from the RsslFloat primitive type */
fieldEntry.fieldId = FID_FLOAT;
fieldEntry.dataType = RSSL_DT_FLOAT;
if ((retVal = rsslEncodeFieldEntry(encIter, &fieldEntry, &Float)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslEncodeFieldEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
printf("\t\tFID %d Encoded float: %f\n", fieldEntry.fieldId, Float);
/* TENTH Field Entry: encode entry from the RsslDouble primitive type */
fieldEntry.fieldId = FID_DOUBLE;
fieldEntry.dataType = RSSL_DT_DOUBLE;
if ((retVal = rsslEncodeFieldEntry(encIter, &fieldEntry, &Double)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslEncodeFieldEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
printf("\t\tFID %d Encoded Double: %f\n", fieldEntry.fieldId, Double);
/* ELEVENTH Field Entry: encode entry from the RsslDateTime primitive type */
fieldEntry.fieldId = FID_DATETIME;
fieldEntry.dataType = RSSL_DT_DATETIME;
rsslDateTime.date.month = 11;
rsslDateTime.date.day = 15;
rsslDateTime.date.year = 2011;
rsslDateTime.time.hour = 8;
rsslDateTime.time.minute = 39;
rsslDateTime.time.second = 24;
if ((retVal = rsslEncodeFieldEntry(encIter, &fieldEntry, &rsslDateTime)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslEncodeFieldEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
printf("\t\tFID %d Encoded DateTime: %d-%d-%d %d:%d:%d\n", fieldEntry.fieldId,
rsslDateTime.date.month, rsslDateTime.date.day, rsslDateTime.date.year, rsslDateTime.time.hour, rsslDateTime.time.minute, rsslDateTime.time.second);
/* TWELVETH Field Entry: encode entry from the RsslQos primitive type */
fieldEntry.fieldId = FID_QOS;
fieldEntry.dataType = RSSL_DT_QOS;
rsslQos.timeliness = RSSL_QOS_TIME_REALTIME;
rsslQos.rate = RSSL_QOS_RATE_TICK_BY_TICK;
rsslQos.dynamic = 1;
rsslQos.rateInfo = 0;
rsslQos.timeInfo = 0;
if ((retVal = rsslEncodeFieldEntry(encIter, &fieldEntry, &rsslQos)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslEncodeFieldEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
printf("\t\tFID %d Encoded QOS: %d %d %d %d %d\n", fieldEntry.fieldId, rsslQos.timeliness, rsslQos.rate, rsslQos.dynamic, rsslQos.rateInfo, rsslQos.timeInfo);
/* THIRTEENTH Field Entry: encode entry from the RsslState primitive type */
fieldEntry.fieldId = FID_STATE;
fieldEntry.dataType = RSSL_DT_STATE;
rsslState.streamState = RSSL_STREAM_OPEN;
rsslState.dataState = RSSL_DATA_OK;
rsslState.code = RSSL_SC_NONE;
rsslState.text.data = (char *)"Succeeded";
rsslState.text.length = 10; // include the null for printing
if ((retVal = rsslEncodeFieldEntry(encIter, &fieldEntry, &rsslState)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslEncodeFieldEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
printf("\t\tFID %d Encoded State: %d %d %d %s\n", fieldEntry.fieldId, rsslState.streamState, rsslState.dataState, rsslState.code, rsslState.text.data);
/* FOURTEENTH Field Entry: encode entry from the RsslBuffer primitive type */
fieldEntry.fieldId = FID_BUFFER;
fieldEntry.dataType = RSSL_DT_BUFFER;
rsslBuffer.data = (char *)"BUFFEREXAMPLE";
rsslBuffer.length = 14; // include the null terminator to make it easier to print
if ((retVal = rsslEncodeFieldEntry(encIter, &fieldEntry, &rsslBuffer)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslEncodeFieldEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
printf("\t\tFID %d Encoded Buffer: %s\n", fieldEntry.fieldId, rsslBuffer.data);
/* FIFTEENTH Field Entry: encode entry from the RsslEnum primitive type */
fieldEntry.fieldId = FID_ENUM;
fieldEntry.dataType = RSSL_DT_ENUM;
rsslEnum = 999;
if ((retVal = rsslEncodeFieldEntry(encIter, &fieldEntry, &rsslEnum)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslEncodeFieldEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
printf("\t\tFID %d Encoded Enum: %d\n", fieldEntry.fieldId, rsslEnum);
/* SIXTEENTH Field Entry: encode entry as a complex type, RsslArray primitive */
/* populate and encode field entry with fieldId and dataType information for this field */
/* need to ensure that RsslFieldEntry is appropriatley cleared
* - clearing will ensure that encData is properly emptied */
rsslClearFieldEntry(&fieldEntry);
fieldEntry.fieldId = 1021;
fieldEntry.dataType = RSSL_DT_ARRAY;
/* begin complex field entry encoding, we are not sure of the approximate max encoding length */
if ((retVal = rsslEncodeFieldEntryInit(encIter, &fieldEntry, 0)) < RSSL_RET_SUCCESS)
{
/* error condition - switch our success value to false so we can roll back */
success = RSSL_FALSE;
/* print out message with return value string, value, and text */
printf("Error %s (%d) encountered with rsslEncodeFieldEntryInit(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
}
else
{
/* now encode nested container using its own specific encode functions */
/* encode RsslReal values into the array */
rsslArray.primitiveType = RSSL_DT_UINT;
/* values are variable length */
rsslArray.itemLength = 2;
/* begin encoding of array - using same encIterator as field list */
if ((retVal = rsslEncodeArrayInit(encIter, &rsslArray)) < RSSL_RET_SUCCESS)
{
/* error condition - switch our success value to false so we can roll back */
success = RSSL_FALSE;
/* print out message with return value string, value, and text */
printf("Error %s (%d) encountered with rsslEncodeArrayInit(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
}
else
{
/*----- Continue encoding array entries. ---- */
RsslUInt uInt1 = 10, uInt2 = 20, uInt3 = 30, uInt4 = 40;
/* array encoding was successful */
printf("\t\tFID %d Encoded RsslArray: [", fieldEntry.fieldId);
/* encode first entry from a UInt from a primitive type */
if ((retVal = rsslEncodeArrayEntry(encIter, NULL, &uInt1)) < RSSL_RET_SUCCESS)
{
/* error condition - switch our success value to false so we can roll back */
success = RSSL_FALSE;
printf("Error %s (%d) encountered with rsslEncodeArrayEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
}
printf(" "RTR_LLU" ", uInt1);
/* encode second entry from a UInt from a primitive type */
if ((retVal = rsslEncodeArrayEntry(encIter, NULL, &uInt2)) < RSSL_RET_SUCCESS)
{
/* error condition - switch our success value to false so we can roll back */
success = RSSL_FALSE;
printf("Error %s (%d) encountered with rsslEncodeArrayEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
}
printf(" "RTR_LLU" ", uInt2);
/* encode third entry from a UInt from a primitive type */
if ((retVal = rsslEncodeArrayEntry(encIter, NULL, &uInt3)) < RSSL_RET_SUCCESS)
{
/* error condition - switch our success value to false so we can roll back */
success = RSSL_FALSE;
printf("Error %s (%d) encountered with rsslEncodeArrayEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
}
printf(" "RTR_LLU" ", uInt3);
/* encode forth entry from a UInt from a primitive type */
if ((retVal = rsslEncodeArrayEntry(encIter, NULL, &uInt4)) < RSSL_RET_SUCCESS)
{
/* error condition - switch our success value to false so we can roll back */
success = RSSL_FALSE;
printf("Error %s (%d) encountered with rsslEncodeArrayEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal)); ;
}
printf(" "RTR_LLU" ", uInt4);
/* encode fifth entry from a UInt from pre-encoded integer contained in a buffer */
/* this buffer.data should point to encoded int and the length should be number of bytes encoded */
if ((retVal = rsslEncodeArrayEntry(encIter, pEncUInt, NULL)) < RSSL_RET_SUCCESS)
{
/* error condition - switch our success value to false so we can roll back */
success = RSSL_FALSE;
printf("Error %s (%d) encountered with rsslEncodeArrayEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
}
printf(" <Preencoded> ]\n");
}
/* complete array encoding. If success parameter is true, this will finalize encoding.
If success parameter is false, this will roll back encoding prior to rsslEncodeArrayInit */
if ((retVal = rsslEncodeArrayComplete(encIter, success)) < RSSL_RET_SUCCESS)
{
/* error condition - switch our success value to false so we can roll back */
success = RSSL_FALSE;
printf("Error %s (%d) encountered with rsslEncodeArrayComplete(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
}
}
/* complete encoding of complex field entry. If any array encoding failed, success is false */
if ((retVal = rsslEncodeFieldEntryComplete(encIter, success)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslEncodeFieldEntryComplete(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
}
/* complete fieldList encoding. If success parameter is true, this will finalize encoding.
If success parameter is false, this will roll back encoding prior to rsslEncodeFieldListInit */
/* Please note: here for simplicity, we did not use success parameter for rsslEncodeFieldListInit/rsslEncodeFieldListComplete calls.
We are just simply displaying an error if it occurs and exit, thus RSSL_TRUE is used in replacement for success parameter */
if ((retVal = rsslEncodeFieldListComplete(encIter, RSSL_TRUE)) < RSSL_RET_SUCCESS)
{
printf("Error %s (%d) encountered with rsslEncodeFieldListComplete(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
printf("\tFieldList Encoding Complete\n");
return RSSL_RET_SUCCESS;
}
/* this function will decode a basic field list with several primitives embedded in it */
RsslRet exampleDecodeFieldList(RsslDecodeIterator *decIter)
{
/* used to store and check return codes */
RsslRet retVal;
/* create a field list to decode into -
since set data is not supported yet, there is nothing to put
here except the count of the number of fields encoded in this
message*/
RsslFieldList fieldList = RSSL_INIT_FIELD_LIST;
/* create field entry to decode into */
RsslFieldEntry fieldEntry = RSSL_INIT_FIELD_ENTRY;
/* create our primitives we will decode into */
RsslDate rsslDate = RSSL_INIT_DATE;
RsslTime rsslTime = RSSL_INIT_TIME;
RsslReal rsslReal = RSSL_INIT_REAL;
RsslArray rsslArray = RSSL_INIT_ARRAY;
RsslDateTime rsslDateTime = RSSL_INIT_DATETIME;
RsslQos rsslQos = RSSL_INIT_QOS;
RsslState rsslState = RSSL_INIT_STATE;
RsslBuffer rsslBuffer = RSSL_INIT_BUFFER;
RsslEnum rsslEnum = 0;
RsslUInt uInt;
RsslInt Int;
RsslBuffer arrayBuffer;
RsslFloat Float;
RsslDouble Double;
/* decode into the field list structure */
/* decode the field list header */
if ((retVal = rsslDecodeFieldList(decIter, &fieldList, 0)) >= RSSL_RET_SUCCESS)
{
printf("\tField List Header Decoded\n");
/* decode each field entry */
/* since this succeeded, we can decode fields until we
reach the end of the fields - until RSSL_RET_END_OF_CONTAINER is returned */
while ((retVal = rsslDecodeFieldEntry(decIter, &fieldEntry)) != RSSL_RET_END_OF_CONTAINER)
{
if (retVal < RSSL_RET_SUCCESS)
{
/* decoding failure tends to be unrecoverable */
printf("Error %s (%d) encountered with rsslDecodeFieldEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
else
{
/* A UPA application will typically use a field dictionary to decode field list content.
When using, code similar to the following can be used to look up type in field dictionary
and call correct primitive decode function */
/*switch (fieldDict->entriesArray[fEntry->fieldId]->rwfType)
{
case RSSL_DT_REAL:
retVal = rsslDecodeReal(&decIter, &rsslReal);
break;
case RSSL_DT_DATE:
retVal = rsslDecodeDate(&decIter, &rsslDate);
break;
/* full switch statement omitted to shorten sample code * /
}*/
/* decode our entry - this is typically based on the FID and what type
it is as designated by the field dictionary. Because we know
the FIDs we used to encode, we can handle them here without
looking up in the dictionary */
/* FID encodings:
FID 16 is RsslDate
FID 1080 is RsslUInt
FID 1081 is RsslUnit
FID 22 is RsslReal
FID 24 is RsslReal
FID 25 is RsslReal
FID 18 is RsslTime
FID 1021 is RsslArray
negative FIDs are user defined FIDs
*/
switch (fieldEntry.fieldId)
{
case 16: //RsslDate
{
if ((retVal = rsslDecodeDate(decIter, &rsslDate)) < RSSL_RET_SUCCESS)
{
printf("<%s:%d> Error decoding rsslDate.\n", __FILE__, __LINE__);
return retVal;
}
printf("\t\tFID %d RsslDate Decoded: %d-%d-%d\n", fieldEntry.fieldId, rsslDate.month, rsslDate.day, rsslDate.year);
}
break;
case 22:
case 24:
case 25: //RsslReal
{
if ((retVal = rsslDecodeReal(decIter, &rsslReal)) < RSSL_RET_SUCCESS)
{
printf("<%s:%d> Error decoding rsslReal.\n", __FILE__, __LINE__);
return retVal;
}
/* Handle blank case. This should be done across all types, however in this example
* we know the only field sent as blank is FID 22 */
if (retVal == RSSL_RET_BLANK_DATA)
printf("\t\tFID %d RsslReal Decoded as blank.\n", fieldEntry.fieldId);
else
printf("\t\tFID %d RsslReal Decoded: hint: %d value: "RTR_LLD"\n", fieldEntry.fieldId, rsslReal.hint, rsslReal.value);
}
break;
case 1080:
case 1081: //RsslUInt
{
if ((retVal = rsslDecodeUInt(decIter, &uInt)) < RSSL_RET_SUCCESS)
{
printf("<%s:%d> Error decoding rssl unsigned integer.\n", __FILE__, __LINE__);
return retVal;
}
printf("\t\tFID %d Rssl Unsigned Integer Decoded: "RTR_LLU"\n", fieldEntry.fieldId, uInt);
}
break;
case 18: //RsslTime
{
if ((retVal = rsslDecodeTime(decIter, &rsslTime)) < RSSL_RET_SUCCESS)
{
printf("<%s:%d> Error decoding rsslTime.\n", __FILE__, __LINE__);
return retVal;
}
printf("\t\tFID %d RsslTime Decoded: %d:%d:%d\n", fieldEntry.fieldId, rsslTime.hour, rsslTime.minute, rsslTime.second);
}
break;
/* full switch statement omitted to shorten sample code */
case 1021: //RsslArray
{
/* decode into the array structure header */
if ((retVal = rsslDecodeArray(decIter, &rsslArray)) >= RSSL_RET_SUCCESS)
{
/* decode each array entry */
printf("\t\tFID %d RsslArray Decoded: [", fieldEntry.fieldId);
while ((retVal = rsslDecodeArrayEntry(decIter, &arrayBuffer)) != RSSL_RET_END_OF_CONTAINER)
{
if (retVal < RSSL_RET_SUCCESS)
{
/* decoding failure tends to be unrecoverable */
printf("Error %s (%d) encountered with rsslDecodeArrayEntry(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
else
{
/* decode array entry into primitive type */
/* we can use the same decode iterator, or set the encoded
entry buffer onto a new iterator */
if ((retVal = rsslDecodeUInt(decIter, &uInt)) < RSSL_RET_SUCCESS)
{
printf("<%s:%d> Error decoding rssl unsigned integer.\n", __FILE__, __LINE__);
return retVal;
}
printf(" "RTR_LLU" ", uInt);
}
}
printf("]\n");
}
else
{
/* decoding failure tends to be unrecoverable */
printf("Error %s (%d) encountered with rsslDecodeArray(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
}
break;
case FID_INT:
{
if ((retVal = rsslDecodeInt(decIter, &Int)) < RSSL_RET_SUCCESS)
{
printf("<%s:%d> Error decoding rssl signed integer.\n", __FILE__, __LINE__);
return retVal;
}
printf("\t\tFID %d Rssl signed Integer Decoded: "RTR_LLD"\n", fieldEntry.fieldId, Int);
}
break;
case FID_FLOAT:
{
if ((retVal = rsslDecodeFloat(decIter, &Float)) < RSSL_RET_SUCCESS)
{
printf("<%s:%d> Error decoding rssl float.\n", __FILE__, __LINE__);
return retVal;
}
printf("\t\tFID %d Rssl float Decoded: %f\n", fieldEntry.fieldId, Float);
}
break;
case FID_DOUBLE:
{
if ((retVal = rsslDecodeDouble(decIter, &Double)) < RSSL_RET_SUCCESS)
{
printf("<%s:%d> Error decoding rssl double.\n", __FILE__, __LINE__);
return retVal;
}
printf("\t\tFID %d Rssl double Decoded: %lf\n", fieldEntry.fieldId, Double);
}
break;
case FID_DATETIME:
{
if ((retVal = rsslDecodeDateTime(decIter, &rsslDateTime)) < RSSL_RET_SUCCESS)
{
printf("<%s:%d> Error decoding rsslDateTime.\n", __FILE__, __LINE__);
return retVal;
}
printf("\t\tFID %d RsslDateTime Decoded: %d-%d-%d %d:%d:%d\n", fieldEntry.fieldId,
rsslDateTime.date.month, rsslDateTime.date.day, rsslDateTime.date.year,
rsslDateTime.time.hour, rsslDateTime.time.minute, rsslDateTime.time.second);
}
break;
case FID_QOS:
{
if ((retVal = rsslDecodeQos(decIter, &rsslQos)) < RSSL_RET_SUCCESS)
{
printf("<%s:%d> Error decoding QOS.\n", __FILE__, __LINE__);
return retVal;
}
printf("\t\tFID %d Decoded QOS: %d %d %d %d %d\n", fieldEntry.fieldId, rsslQos.timeliness, rsslQos.rate, rsslQos.dynamic, rsslQos.rateInfo, rsslQos.timeInfo);
}
break;
case FID_STATE:
{
if ((retVal = rsslDecodeState(decIter, &rsslState)) < RSSL_RET_SUCCESS)
{
printf("<%s:%d> Error decoding rsslState.\n", __FILE__, __LINE__);
return retVal;
}
printf("\t\tFID %d Decoded State: %d %d %d %s\n", fieldEntry.fieldId, rsslState.streamState, rsslState.dataState, rsslState.code, rsslState.text.data);
}
break;
case FID_BUFFER:
{
if ((retVal = rsslDecodeBuffer(decIter, &rsslBuffer)) < RSSL_RET_SUCCESS)
{
printf("<%s:%d> Error decoding rsslBuffer.\n", __FILE__, __LINE__);
return retVal;
}
printf("\t\tFID %d RsslBuffer Decoded: %s\n", fieldEntry.fieldId, rsslBuffer.data); // printf assumes its a null terminated character string
}
break;
case FID_ENUM:
{
if ((retVal = rsslDecodeEnum(decIter, &rsslEnum)) < RSSL_RET_SUCCESS)
{
printf("<%s:%d> Error decoding rsslEnum.\n", __FILE__, __LINE__);
return retVal;
}
printf("\t\tFID %d RsslEnum Decoded: %d\n", fieldEntry.fieldId, rsslEnum);
}
break;
default:
printf("\t\tUnexpected FID %d encountered!\n", fieldEntry.fieldId);
}
}
}
}
else
{
/* decoding failure tends to be unrecoverable */
printf("Error %s (%d) encountered with rsslDecodeFieldList(). Error Text: %s\n",
rsslRetCodeToString(retVal), retVal, rsslRetCodeInfo(retVal));
return retVal;
}
printf("\tFieldList Decoding Complete\n");
return RSSL_RET_SUCCESS;
}
