package com.thomsonreuters.upa.valueadd.examples.watchlistconsumer; import com.thomsonreuters.upa.codec.Array; import com.thomsonreuters.upa.codec.ArrayEntry; import com.thomsonreuters.upa.codec.Buffer; import com.thomsonreuters.upa.codec.CodecFactory; import com.thomsonreuters.upa.codec.CodecReturnCodes; import com.thomsonreuters.upa.codec.DataDictionary; import com.thomsonreuters.upa.codec.DataTypes; import com.thomsonreuters.upa.codec.DateTime; import com.thomsonreuters.upa.codec.DecodeIterator; import com.thomsonreuters.upa.codec.DictionaryEntry; import com.thomsonreuters.upa.codec.EnumType; import com.thomsonreuters.upa.codec.FieldEntry; import com.thomsonreuters.upa.codec.FieldList; import com.thomsonreuters.upa.codec.Int; import com.thomsonreuters.upa.codec.LocalFieldSetDefDb; import com.thomsonreuters.upa.codec.Map; import com.thomsonreuters.upa.codec.MapEntry; import com.thomsonreuters.upa.codec.MapEntryActions; import com.thomsonreuters.upa.codec.Msg; import com.thomsonreuters.upa.codec.Qos; import com.thomsonreuters.upa.codec.Real; import com.thomsonreuters.upa.codec.State; import com.thomsonreuters.upa.codec.Time; import com.thomsonreuters.upa.codec.UInt; import com.thomsonreuters.upa.codec.Vector; import com.thomsonreuters.upa.codec.VectorEntry; import com.thomsonreuters.upa.codec.VectorEntryActions; import com.thomsonreuters.upa.rdm.DomainTypes; import com.thomsonreuters.upa.transport.Error; import com.thomsonreuters.upa.transport.TransportFactory; import com.thomsonreuters.upa.valueadd.reactor.ReactorChannel; //APIQA import com.thomsonreuters.upa.codec.ElementEntry; import com.thomsonreuters.upa.codec.ElementList; //END APIQA public class ItemDecoder { private final String FIELD_DICTIONARY_FILE_NAME = "RDMFieldDictionary"; private final String ENUM_TABLE_FILE_NAME = "enumtype.def"; DataDictionary dictionary; DecodeIterator dIter = CodecFactory.createDecodeIterator(); boolean fieldDictionaryLoadedFromFile; boolean enumTypeDictionaryLoadedFromFile; boolean fieldDictionaryDownloadedFromNetwork; boolean enumTypeDictionaryDownloadedFromNetwork; protected FieldList fieldList = CodecFactory.createFieldList(); protected FieldEntry fieldEntry = CodecFactory.createFieldEntry(); private Map map = CodecFactory.createMap(); private MapEntry mapEntry = CodecFactory.createMapEntry(); private Buffer mapKey = CodecFactory.createBuffer(); private LocalFieldSetDefDb localFieldSetDefDb = CodecFactory.createLocalFieldSetDefDb(); private Error error; private UInt fidUIntValue = CodecFactory.createUInt(); private Int fidIntValue = CodecFactory.createInt(); private Real fidRealValue = CodecFactory.createReal(); private com.thomsonreuters.upa.codec.Enum fidEnumValue = CodecFactory.createEnum(); private com.thomsonreuters.upa.codec.Date fidDateValue = CodecFactory.createDate(); private Time fidTimeValue = CodecFactory.createTime(); private DateTime fidDateTimeValue = CodecFactory.createDateTime(); private com.thomsonreuters.upa.codec.Float fidFloatValue = CodecFactory.createFloat(); private com.thomsonreuters.upa.codec.Double fidDoubleValue = CodecFactory.createDouble(); private Qos fidQosValue = CodecFactory.createQos(); private State fidStateValue = CodecFactory.createState(); StringBuilder displayStr = new StringBuilder(); private int indentCount; private String[] indents = { "", " ", " ", " " }; private Vector fidVectorValue = CodecFactory.createVector(); private Array fidArrayValue = CodecFactory.createArray(); private FieldList embeddedFieldList = CodecFactory.createFieldList(); private FieldEntry embeddedFieldEntry = CodecFactory.createFieldEntry(); private VectorEntry vectorEntry = CodecFactory.createVectorEntry(); private ArrayEntry arrayEntry = CodecFactory.createArrayEntry(); private Buffer fidBufferValue = CodecFactory.createBuffer(); /* Initializes the item decoder. Loads dictionaries from their files if the files * are found in the application's folder. */ public void init() { dictionary = CodecFactory.createDataDictionary(); fieldDictionaryLoadedFromFile = false; enumTypeDictionaryLoadedFromFile = false; fieldDictionaryDownloadedFromNetwork = false; enumTypeDictionaryDownloadedFromNetwork = false; error = TransportFactory.createError(); loadDictionary(); } void loadDictionary() { dictionary.clear(); if (dictionary.loadFieldDictionary(FIELD_DICTIONARY_FILE_NAME, error) < 0) { System.out.println("Unable to load field dictionary. Will attempt to download from provider.\n\tText: " + error.text()); } else { fieldDictionaryLoadedFromFile = true; } if (dictionary.loadEnumTypeDictionary(ENUM_TABLE_FILE_NAME, error) < 0) { System.out.println("Unable to load enum dictionary. Will attempt to download from provider.\n\tText: " + error.text()); } else { enumTypeDictionaryLoadedFromFile = true; } } public DataDictionary getDictionary() { return dictionary; } /* Decodes the payload of a message according to its domain. */ int decodeDataBody(ReactorChannel channel, Msg msg) { switch (msg.domainType()) { case DomainTypes.MARKET_PRICE: return decodeMarketPriceDataBody(channel, msg); case DomainTypes.MARKET_BY_ORDER: return decodeMarketByOrderDataBody(channel, msg); case DomainTypes.MARKET_BY_PRICE: return decodeMarketByPriceDataBody(channel, msg); case DomainTypes.YIELD_CURVE: return decodeYieldCurveDataBody(channel, msg); case DomainTypes.SYMBOL_LIST: return decodeSymbolListDataBody(channel, msg); // APIQA case DomainTypes.LOGIN: return decodeGenericMsgDataBody(channel, msg); case DomainTypes.SOURCE: return decodeGenericMsgDataBody(channel, msg); // END APIQA default: System.out.println("Received message with unhandled domain %u\n\n" + msg.domainType()); return CodecReturnCodes.FAILURE; } } /* Decodes a MarketPrice payload. * MarketPrice is represented as an RsslFieldList, where each field contains data about the item. */ int decodeMarketPriceDataBody(ReactorChannel channel, Msg msg) { if (!isDictionaryLoaded()) { System.out.println(" (Dictionary not loaded).\n"); return CodecReturnCodes.FAILURE; } if (msg.containerType() != DataTypes.FIELD_LIST) { System.out.println(" Incorrect container type: " + msg.containerType()); return CodecReturnCodes.FAILURE; } displayStr.setLength(0); dIter.clear(); dIter.setBufferAndRWFVersion(msg.encodedDataBody(), channel.majorVersion(), channel.minorVersion()); int ret = fieldList.decode(dIter, null); if (ret != CodecReturnCodes.SUCCESS) { System.out.println("DecodeFieldList() failed with return code: " + ret); return ret; } // decode each field entry in list while ((ret = fieldEntry.decode(dIter)) != CodecReturnCodes.END_OF_CONTAINER) { if (ret != CodecReturnCodes.SUCCESS) { System.out.println("decodeFieldEntry() failed with return code: " + ret); return ret; } ret = decodeFieldEntry(fieldEntry, dIter, dictionary, displayStr); if (ret != CodecReturnCodes.SUCCESS) { System.out.println("decodeFieldEntry() failed"); return ret; } displayStr.append("\n"); } System.out.println(displayStr.toString()); return CodecReturnCodes.SUCCESS; } // APIQA /* Decodes a GenericMsg payload. * GenericMsg contain ElementList with ElementEntry */ int decodeGenericMsgDataBody(ReactorChannel channel, Msg msg) { ElementList _elementList = CodecFactory.createElementList(); ElementEntry _elementEntry = CodecFactory.createElementEntry(); _elementList.clear(); _elementEntry.clear(); dIter.clear(); if (msg.containerType() != DataTypes.ELEMENT_LIST) return CodecReturnCodes.SUCCESS; // nothing to extract dIter.clear(); dIter.setBufferAndRWFVersion(msg.encodedDataBody(), channel.majorVersion(), channel.minorVersion()); int ret = _elementList.decode(dIter, null); if (ret != CodecReturnCodes.SUCCESS) { System.out.println("elementList.Decode() failed with return code: " + ret); return ret; } while ((ret = _elementEntry.decode(dIter)) != CodecReturnCodes.END_OF_CONTAINER) { if (ret != CodecReturnCodes.SUCCESS) { System.out.println("elementEntry.Decode() failed with return code: " + ret); return ret; } if (_elementEntry.dataType() == DataTypes.INT) { // Nothing to extract System.out.println("GenericMsg on StreamId : " + msg.streamId() + " ElementEntryName: " + _elementEntry.name()); return CodecReturnCodes.SUCCESS; } } return CodecReturnCodes.SUCCESS; } // END APIQA /* Decodes a MarketByOrder payload. * MarketByOrder is represented as an RsslMap, where each entry represents an order. * Each entry contains an RsslFieldList which contains data about that order. */ int decodeMarketByOrderDataBody(ReactorChannel channel, Msg msg) { if (msg.containerType() != DataTypes.MAP) { System.out.println(" Incorrect container type: " + msg.containerType()); return CodecReturnCodes.FAILURE; } displayStr.setLength(0); dIter.clear(); dIter.setBufferAndRWFVersion(msg.encodedDataBody(), channel.majorVersion(), channel.minorVersion()); int ret; if ((ret = map.decode(dIter)) != CodecReturnCodes.SUCCESS) { System.out.println("Map.Decode() failed with return code: " + ret); return ret; } // decode set definition database if (map.checkHasSetDefs()) { /* * decode set definition - should be field set definition */ /* * this needs to be passed in when we decode each field list */ localFieldSetDefDb.clear(); ret = localFieldSetDefDb.decode(dIter); if (ret != CodecReturnCodes.SUCCESS) { System.out.println("DecodeLocalFieldSetDefDb() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } } if (map.checkHasSummaryData()) { ret = decodeSummaryData(dIter, dictionary, displayStr); if (ret != CodecReturnCodes.SUCCESS) return ret; } ret = decodeMap(dIter, dictionary, displayStr); if (ret != CodecReturnCodes.SUCCESS) return ret; System.out.println(displayStr.toString()); return CodecReturnCodes.SUCCESS; } /* Decodes a MarketByPrice payload. * MarketByPrice is represented as an RsslMap, where each entry represents a price point. * Each entry contains an RsslFieldList which contains data about that price point. */ int decodeMarketByPriceDataBody(ReactorChannel channel, Msg msg) { if (msg.containerType() != DataTypes.MAP) { System.out.println(" Incorrect container type: " + msg.containerType()); return CodecReturnCodes.FAILURE; } displayStr.setLength(0); dIter.clear(); dIter.setBufferAndRWFVersion(msg.encodedDataBody(), channel.majorVersion(), channel.minorVersion()); int ret = map.decode(dIter); if (ret != CodecReturnCodes.SUCCESS) { System.out.println("DecodeMap() failed with return code: " + ret); return ret; } if (map.checkHasSetDefs()) { localFieldSetDefDb.clear(); ret = localFieldSetDefDb.decode(dIter); if (ret != CodecReturnCodes.SUCCESS) { System.out.println("DecodeLocalFieldSetDefDb() failed"); return ret; } } if (map.checkHasSummaryData()) { ret = decodeSummaryData(dIter, dictionary, displayStr); if (ret != CodecReturnCodes.SUCCESS) return ret; } ret = decodeMap(dIter, dictionary, displayStr); if (ret != CodecReturnCodes.SUCCESS) return ret; System.out.println(displayStr.toString()); return CodecReturnCodes.SUCCESS; } /* Decodes a YieldCurve payload. * YieldCurve is represented as an RsslFieldList, where each field contains data about the item. */ int decodeYieldCurveDataBody(ReactorChannel channel, Msg msg) { if (!isDictionaryLoaded()) { System.out.println(" (Dictionary not loaded).\n"); return CodecReturnCodes.FAILURE; } if (msg.containerType() != DataTypes.FIELD_LIST) { System.out.println(" Incorrect container type: " + msg.containerType()); return CodecReturnCodes.FAILURE; } displayStr.setLength(0); dIter.clear(); dIter.setBufferAndRWFVersion(msg.encodedDataBody(), channel.majorVersion(), channel.minorVersion()); int ret = decodeFieldListForYieldCurve(dIter, dictionary, fieldList, fieldEntry); if (ret != CodecReturnCodes.SUCCESS) { System.out.println("DecodeFieldList() failed with return code: " + ret); return ret; } return CodecReturnCodes.SUCCESS; } /* Decodes a SymbolList payload. * SymbolList is represented as an RsslMap, where each entry represents an item. * The entries are indexed by the item's name. */ int decodeSymbolListDataBody(ReactorChannel channel, Msg msg) { if (msg.containerType() != DataTypes.MAP) { System.out.println(" Incorrect container type: " + msg.containerType()); return CodecReturnCodes.FAILURE; } dIter.clear(); dIter.setBufferAndRWFVersion(msg.encodedDataBody(), channel.majorVersion(), channel.minorVersion()); int ret = map.decode(dIter); if (ret != CodecReturnCodes.SUCCESS) { System.out.println("DecodeMap() failed with return code: " + ret); return ret; } if (map.checkHasSetDefs()) { localFieldSetDefDb.clear(); ret = localFieldSetDefDb.decode(dIter); if (ret != CodecReturnCodes.SUCCESS) { System.out.println("DecodeLocalFieldSetDefDb() failed"); return ret; } } if (map.checkHasSummaryData()) { ret = decodeSummaryData(dIter, dictionary, displayStr); if (ret != CodecReturnCodes.SUCCESS) return ret; } while ((ret = mapEntry.decode(dIter, mapKey)) != CodecReturnCodes.END_OF_CONTAINER) { if (ret != CodecReturnCodes.SUCCESS) { System.out.println("DecodeMapEntry() failed: < " + CodecReturnCodes.toString(ret) + ">"); return ret; } System.out.println(mapKey.toString() + "\t" + mapEntryActionToString(mapEntry.action())); } return CodecReturnCodes.SUCCESS; } private int decodeMap(DecodeIterator dIter, DataDictionary dictionary, StringBuilder fieldValue) { String actionString; int ret; /* decode the map */ while ((ret = mapEntry.decode(dIter, mapKey)) != CodecReturnCodes.END_OF_CONTAINER) { if (ret != CodecReturnCodes.SUCCESS) { System.out.println("DecodeMapEntry() failed with return code: " + ret); return ret; } // convert the action to a string for display purposes switch (mapEntry.action()) { case MapEntryActions.UPDATE: actionString = "UPDATE"; break; case MapEntryActions.ADD: actionString = "ADD"; break; case MapEntryActions.DELETE: actionString = "DELETE"; break; default: actionString = "Unknown"; } // print out the key if (mapKey.length() > 0) { fieldValue.append("ORDER ID: " + mapKey.toString() + "\nACTION: " + actionString + "\n"); } // there is not any payload in delete actions if (mapEntry.action() != MapEntryActions.DELETE) { ret = decodeFieldList(dIter, dictionary, fieldValue); if (ret != CodecReturnCodes.SUCCESS) return ret; } } return CodecReturnCodes.SUCCESS; } private int decodeFieldListForYieldCurve(DecodeIterator dIter, DataDictionary dictionary, FieldList localFieldList, FieldEntry localFieldEntry) { localFieldList.clear(); int ret = localFieldList.decode(dIter, localFieldSetDefDb); if (ret < CodecReturnCodes.SUCCESS) { System.out.println("DecodeFieldList() failed with return code: " + ret); return ret; } localFieldEntry.clear(); indentCount++; // decode each field entry in list while ((ret = localFieldEntry.decode(dIter)) != CodecReturnCodes.END_OF_CONTAINER) { if (ret < CodecReturnCodes.SUCCESS) { System.out.println("decodeFieldEntry() failed with return code: " + ret); return ret; } // get dictionary entry DictionaryEntry dictionaryEntry = dictionary.entry(localFieldEntry.fieldId()); // return if no entry found if (dictionaryEntry == null) { System.out.println("\tFid " + localFieldEntry.fieldId() + " not found in dictionary"); System.out.println(localFieldEntry.encodedData().toHexString()); return CodecReturnCodes.SUCCESS; } // print out fid name System.out.print(indents[indentCount] + dictionaryEntry.acronym().toString()); for (int i = 0; i < 40 - indents[indentCount].length() - dictionaryEntry.acronym().length(); i++) { System.out.print(" "); } // decode and print out fid value int dataType = dictionaryEntry.rwfType(); switch (dataType) { case DataTypes.VECTOR: ret = decodeVector(dIter, dictionary); if (ret < CodecReturnCodes.SUCCESS) { System.out.println("decodeVector inside FieldList failed"); return ret; } break; case DataTypes.ARRAY: ret = decodeArray(dIter); if (ret < CodecReturnCodes.SUCCESS) { System.out.println("decodeArray inside FieldList failed"); return ret; } break; default: ret = decodePrimitive(dIter, dataType, false); if (ret < CodecReturnCodes.SUCCESS) { System.out.println("decodePrimitive inside FieldList failed"); return ret; } break; } } indentCount--; return CodecReturnCodes.SUCCESS; } private int decodeVector(DecodeIterator dIter, DataDictionary dictionary) { int ret = fidVectorValue.decode(dIter); if (ret < CodecReturnCodes.SUCCESS) { System.out.println("DecodeReal() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } if (ret == CodecReturnCodes.NO_DATA) { System.out.println(""); return CodecReturnCodes.SUCCESS; } if (fidVectorValue.checkHasSummaryData()) { System.out.println(); // fieldList inside summaryData within vector ret = decodeFieldListForYieldCurve(dIter, dictionary, embeddedFieldList, embeddedFieldEntry); if (ret < CodecReturnCodes.SUCCESS) { System.out.println("DecodeSummaryData failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } } // If the vector flags indicate that set definition content is present, // decode the set def db if (fidVectorValue.checkHasSetDefs()) { if (fidVectorValue.containerType() == DataTypes.FIELD_LIST) { localFieldSetDefDb.clear(); ret = localFieldSetDefDb.decode(dIter); if (ret < CodecReturnCodes.SUCCESS) { System.out.println("DecodeSetDefDb() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } } } indentCount++; System.out.println(); vectorEntry.clear(); while ((ret = vectorEntry.decode(dIter)) != CodecReturnCodes.END_OF_CONTAINER) { if (ret < CodecReturnCodes.SUCCESS) { System.out.printf("Error %s (%d) encountered with DecodeVectorEntry. Error Text: %s\n", CodecReturnCodes.toString(ret), ret, CodecReturnCodes.info(ret)); return ret; } System.out.println(indents[indentCount] + "INDEX: " + vectorEntry.index()); System.out.print(indents[indentCount] + "ACTION: "); switch (vectorEntry.action()) { case VectorEntryActions.UPDATE: System.out.println("UPDATE_ENTRY"); break; case VectorEntryActions.SET: System.out.println("SET_ENTRY"); break; case VectorEntryActions.CLEAR: System.out.println("CLEAR_ENTRY"); break; case VectorEntryActions.INSERT: System.out.println("INSERT_ENTRY"); break; case VectorEntryActions.DELETE: System.out.println("DELETE_ENTRY"); break; default: System.out.println("UNKNOWN"); break; } /* Continue decoding vector entries. */ switch (fidVectorValue.containerType()) { case DataTypes.FIELD_LIST: // fieldList inside vectorEntry within vector ret = decodeFieldListForYieldCurve(dIter, dictionary, embeddedFieldList, embeddedFieldEntry); if (ret < CodecReturnCodes.SUCCESS) { System.out.printf("Error %s (%d) encountered with decoding FieldList within Vector: %s\n", CodecReturnCodes.toString(ret), ret, CodecReturnCodes.info(ret)); return ret; } break; case DataTypes.ARRAY: ret = decodeArray(dIter); if (ret < CodecReturnCodes.SUCCESS) { System.out.printf("Error %s (%d) encountered with decoding ARRAY within Vector: %s\n", CodecReturnCodes.toString(ret), ret, CodecReturnCodes.info(ret)); return ret; } break; default: System.out.println("Error: Vector contained unhandled containerType " + fidVectorValue.containerType()); break; } } indentCount--; return CodecReturnCodes.SUCCESS; } private int decodePrimitive(DecodeIterator dIter, int dataType, boolean isArray) { int ret = 0; switch (dataType) { case DataTypes.INT: ret = fidIntValue.decode(dIter); if (ret == CodecReturnCodes.SUCCESS) { System.out.print(fidIntValue.toLong()); } else if (ret != CodecReturnCodes.BLANK_DATA) { System.out.println("DecodeInt() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } break; case DataTypes.REAL: ret = fidRealValue.decode(dIter); if (ret == CodecReturnCodes.SUCCESS) { System.out.print(fidRealValue.toDouble()); } else if (ret != CodecReturnCodes.BLANK_DATA) { System.out.println("DecodeReal() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } break; case DataTypes.DATE: ret = fidDateValue.decode(dIter); if (ret == CodecReturnCodes.SUCCESS) { System.out.print(fidDateValue.toString()); } else if (ret != CodecReturnCodes.BLANK_DATA) { System.out.println("DecodeDate() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } break; case DataTypes.TIME: ret = fidTimeValue.decode(dIter); if (ret == CodecReturnCodes.SUCCESS) { System.out.print(fidTimeValue.toString()); } else if (ret != CodecReturnCodes.BLANK_DATA) { System.out.println("DecodeTime() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } break; case DataTypes.DATETIME: ret = fidDateTimeValue.decode(dIter); if (ret == CodecReturnCodes.SUCCESS) { System.out.print(fidDateTimeValue.toString()); } else if (ret != CodecReturnCodes.BLANK_DATA) { System.out.println("DecodeDateTime() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } break; case DataTypes.ARRAY: ret = decodeArray(dIter); if (ret < CodecReturnCodes.SUCCESS) { System.out.printf("Error %s (%d) encountered with decoding ARRAY was primitive: %s\n", CodecReturnCodes.toString(ret), ret, CodecReturnCodes.info(ret)); return ret; } break; case DataTypes.BUFFER: case DataTypes.ASCII_STRING: case DataTypes.UTF8_STRING: case DataTypes.RMTES_STRING: ret = fidBufferValue.decode(dIter); if (ret == CodecReturnCodes.SUCCESS) { if (isArray) System.out.print("\""); System.out.print(fidBufferValue.toString()); if (isArray) System.out.print("\""); } else if (ret != CodecReturnCodes.BLANK_DATA) { System.out.println("DecodeString() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } break; default: System.out.print("Unsupported data type (" + DataTypes.toString(dataType) + ")"); break; } if (ret == CodecReturnCodes.BLANK_DATA) { System.out.print(""); } if (!isArray) System.out.print("\n"); return CodecReturnCodes.SUCCESS; } private int decodeArray(DecodeIterator dIter) { boolean firstArrayEntry = true; System.out.print("{ "); fidArrayValue.clear(); int ret = fidArrayValue.decode(dIter); if (ret < CodecReturnCodes.SUCCESS) { System.out.println("DecodeArray() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } int dataType = fidArrayValue.primitiveType(); arrayEntry.clear(); while ((ret = arrayEntry.decode(dIter)) != CodecReturnCodes.END_OF_CONTAINER) { if (ret < CodecReturnCodes.SUCCESS) { System.out.printf("Error %s (%d) encountered with DecodeArrayEntry. Error Text: %s\n", CodecReturnCodes.toString(ret), ret, CodecReturnCodes.info(ret)); return ret; } if (firstArrayEntry) firstArrayEntry = false; else System.out.print(", "); ret = decodePrimitive(dIter, dataType, true); if (ret < CodecReturnCodes.SUCCESS) { System.out.printf("Error %s (%d) encountered with DecodeArrayEntryPrimitives. Error Text: %s\n", CodecReturnCodes.toString(ret), ret, CodecReturnCodes.info(ret)); return ret; } } System.out.print(" }\n"); return CodecReturnCodes.SUCCESS; } private int decodeFieldList(DecodeIterator dIter, DataDictionary dictionary, StringBuilder fieldValue) { // decode field list int ret = fieldList.decode(dIter, localFieldSetDefDb); if (ret != CodecReturnCodes.SUCCESS) { System.out.println("DecodeFieldList() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } // decode each field entry in list while ((ret = fieldEntry.decode(dIter)) != CodecReturnCodes.END_OF_CONTAINER) { if (ret != CodecReturnCodes.SUCCESS) { System.out.println("DecodeFieldEntry() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } ret = decodeFieldEntry(fieldEntry, dIter, dictionary, fieldValue); if (ret != CodecReturnCodes.SUCCESS) { System.out.println("decodeFieldEntry() failed"); return ret; } fieldValue.append("\n"); } return CodecReturnCodes.SUCCESS; } /* * This is used by all market price domain handlers to output field lists. * * Decodes the field entry data and prints out the field entry data with * help of the dictionary. Returns success if decoding succeeds or failure * if decoding fails. */ protected int decodeFieldEntry(FieldEntry fEntry, DecodeIterator dIter, DataDictionary dictionary, StringBuilder fieldValue) { // get dictionary entry DictionaryEntry dictionaryEntry = dictionary.entry(fEntry.fieldId()); // return if no entry found if (dictionaryEntry == null) { fieldValue.append("\tFid " + fEntry.fieldId() + " not found in dictionary"); return CodecReturnCodes.SUCCESS; } // print out fid name fieldValue.append("\t" + fEntry.fieldId() + "/" + dictionaryEntry.acronym().toString() + ": "); // decode and print out fid value int dataType = dictionaryEntry.rwfType(); int ret = 0; switch (dataType) { case DataTypes.UINT: ret = fidUIntValue.decode(dIter); if (ret == CodecReturnCodes.SUCCESS) { fieldValue.append(fidUIntValue.toLong()); } else if (ret != CodecReturnCodes.BLANK_DATA) { System.out.println("DecodeUInt() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } break; case DataTypes.INT: ret = fidIntValue.decode(dIter); if (ret == CodecReturnCodes.SUCCESS) { fieldValue.append(fidIntValue.toLong()); } else if (ret != CodecReturnCodes.BLANK_DATA) { System.out.println("DecodeInt() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } break; case DataTypes.FLOAT: ret = fidFloatValue.decode(dIter); if (ret == CodecReturnCodes.SUCCESS) { fieldValue.append(fidFloatValue.toFloat()); } else if (ret != CodecReturnCodes.BLANK_DATA) { System.out.println("DecodeFloat() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } break; case DataTypes.DOUBLE: ret = fidDoubleValue.decode(dIter); if (ret == CodecReturnCodes.SUCCESS) { fieldValue.append(fidDoubleValue.toDouble()); } else if (ret != CodecReturnCodes.BLANK_DATA) { System.out.println("DecodeDouble() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } break; case DataTypes.REAL: ret = fidRealValue.decode(dIter); if (ret == CodecReturnCodes.SUCCESS) { fieldValue.append(fidRealValue.toDouble()); } else if (ret != CodecReturnCodes.BLANK_DATA) { System.out.println("DecodeReal() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } break; case DataTypes.ENUM: ret = fidEnumValue.decode(dIter); if (ret == CodecReturnCodes.SUCCESS) { EnumType enumType = dictionary.entryEnumType(dictionaryEntry, fidEnumValue); if (enumType == null) { fieldValue.append(fidEnumValue.toInt()); } else { fieldValue.append(enumType.display().toString() + "(" + fidEnumValue.toInt() + ")"); } } else if (ret != CodecReturnCodes.BLANK_DATA) { System.out.println("DecodeEnum() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } break; case DataTypes.DATE: ret = fidDateValue.decode(dIter); if (ret == CodecReturnCodes.SUCCESS) { fieldValue.append(fidDateValue.toString()); } else if (ret != CodecReturnCodes.BLANK_DATA) { System.out.println("DecodeDate() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } break; case DataTypes.TIME: ret = fidTimeValue.decode(dIter); if (ret == CodecReturnCodes.SUCCESS) { fieldValue.append(fidTimeValue.toString()); } else if (ret != CodecReturnCodes.BLANK_DATA) { System.out.println("DecodeTime() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } break; case DataTypes.DATETIME: ret = fidDateTimeValue.decode(dIter); if (ret == CodecReturnCodes.SUCCESS) { fieldValue.append(fidDateTimeValue.toString()); } else if (ret != CodecReturnCodes.BLANK_DATA) { System.out.println("DecodeDateTime() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } break; case DataTypes.QOS: ret = fidQosValue.decode(dIter); if (ret == CodecReturnCodes.SUCCESS) { fieldValue.append(fidQosValue.toString()); } else if (ret != CodecReturnCodes.BLANK_DATA) { System.out.println("DecodeQos() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } break; case DataTypes.STATE: ret = fidStateValue.decode(dIter); if (ret == CodecReturnCodes.SUCCESS) { fieldValue.append(fidStateValue.toString()); } else if (ret != CodecReturnCodes.BLANK_DATA) { System.out.println("DecodeState() failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } break; // For an example of array decoding, see // FieldListCodec.exampleDecode() case DataTypes.ARRAY: break; case DataTypes.BUFFER: case DataTypes.ASCII_STRING: case DataTypes.UTF8_STRING: case DataTypes.RMTES_STRING: if (fEntry.encodedData().length() > 0) { fieldValue.append(fEntry.encodedData().toString()); } else { ret = CodecReturnCodes.BLANK_DATA; } break; default: fieldValue.append("Unsupported data type (" + DataTypes.toString(dataType) + ")"); break; } if (ret == CodecReturnCodes.BLANK_DATA) { fieldValue.append(""); } return CodecReturnCodes.SUCCESS; } private int decodeSummaryData(DecodeIterator dIter, DataDictionary dictionary, StringBuilder fieldValue) { int ret = fieldList.decode(dIter, localFieldSetDefDb); if (ret != CodecReturnCodes.SUCCESS) { System.out.println("DecodeFieldList failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } fieldValue.append("SUMMARY DATA\n"); // decode each field entry in list while ((ret = fieldEntry.decode(dIter)) != CodecReturnCodes.END_OF_CONTAINER) { if (ret != CodecReturnCodes.SUCCESS) { System.out.println("DecodeFieldEntry failed: <" + CodecReturnCodes.toString(ret) + ">"); return ret; } ret = decodeFieldEntry(fieldEntry, dIter, dictionary, fieldValue); if (ret != CodecReturnCodes.SUCCESS) { System.out.println("decodeFieldEntry() failed"); return ret; } fieldValue.append("\n"); } return CodecReturnCodes.SUCCESS; } private boolean isDictionaryLoaded() { return ((fieldDictionaryLoadedFromFile && enumTypeDictionaryLoadedFromFile) || (fieldDictionaryDownloadedFromNetwork && enumTypeDictionaryDownloadedFromNetwork)); } private String mapEntryActionToString(int mapEntryAction) { switch (mapEntryAction) { case MapEntryActions.UPDATE: return "UPDATE"; case MapEntryActions.ADD: return "ADD"; case MapEntryActions.DELETE: return "DELETE"; default: return "Unknown Map Entry Action"; } } }