Yes, it is possible.

RDMFieldDictionary provides functions (encodeRDMFieldDictionary() and encodeRDMEnumDictionary()) to encode Series from RDMFieldDictionary. After that, the application can write the encoded buffer of Series to binary files.

#include <fstream> 
… 
void Consumer::processDictionariesComplete() 
{ 
rfa::rdm::RDMFieldDictionary& dict = getRDMFieldDict(); 
rfa::data::Series rdmSeries; 
rfa::data::Series enumSeries; 

//Encode dictionary to Series 
dict.encodeRDMFieldDictionary(rdmSeries); 
dict.encodeRDMEnumDictionary(enumSeries); 

ofstream rdmFile("rdmfield.bin", ios::out | ios::binary); 
ofstream enumFile("enumtype.bin", ios::out | ios::binary); 

//Get Encoded buffer of Series 
const rfa::common::Buffer& rdmBuffer = rdmSeries.getEncodedBuffer(); 
const rfa::common::Buffer& enumBuffer = enumSeries.getEncodedBuffer(); 

//Write encoded buffer to binary files 
rdmFile.write(reinterpret_cast<const char*>(rdmBuffer.c_buf()), rdmBuffer.size()); 

enumFile.write(reinterpret_cast<const char*>(enumBuffer.c_buf()), enumBuffer.size()); 
rdmFile.close(); 
enumFile.close(); 
… 
} 

Then, the application can read those binary files and set the encoded buffers to the Series and then use RDMFieldDictionary::decodeRDMFieldDictionary() and RDMFieldDictionary::decodeRDMEnumDictionary() to decode the Series.

char* Consumer::ReadAllBytes(const char* filename, int* read) 
{ 
ifstream ifs(filename, ios::binary | ios::ate); 
ifstream::pos_type pos = ifs.tellg(); 
int length = pos; 
char *pChars = new char[length]; 
ifs.seekg(0, ios::beg); 
ifs.read(pChars, length); 
ifs.close(); 
*read = length; 
return pChars; 
} 


void Consumer::DecodeDictionaryFromFiles() 
{ 
rfa::rdm::RDMFieldDictionary& newDict = rfa::rdm::RDMFieldDictionary::create(); 
rfa::data::Series rdmSeries, enumSeries; 
rfa::common::Buffer rdmBuffer, enumBuffer; 
int rdmSize, enumSize; 
char* rdmSeriesData = ReadAllBytes("rdmfield.bin", &rdmSize); 
char* enumSeiresData = ReadAllBytes("enumtype.bin", &enumSize); 

//Set binary data to the buffers 
rdmBuffer.setFrom(reinterpret_cast<const unsigned char*>(rdmSeriesData), rdmSize); 
enumBuffer.setFrom(reinterpret_cast<const unsigned char*>(enumSeiresData), enumSize); 

//Set buffers to Series 
rdmSeries.setEncodedBuffer(rdmBuffer); 
enumSeries.setEncodedBuffer(enumBuffer); 

//Decode Series with RDMFieldDictionary 
newDict.decodeRDMFldDictionary(rdmSeries); 
newDict.decodeRDMEnumDictionary(enumSeries); 

delete rdmSeriesData; 
delete enumSeiresData; 
} 

Hi @Akechi Sato

As you may know, changes are made to the dictionary as & when required by Thomson Reuters e.g. there have been 5 dictionary service packs released in the past 6 months to add new Fields and update/add Enumeration types.

If the application consumes data which contains a new Field that does not exist in the local cached dictionary or if the definition of the field or list of enumerated values have changed, the application could experience a problem.

Please make your client aware of this.