RFA to download dictionary and save as a re-useable local dictionary

Akechi Sato
Akechi Sato
in RFA

Is it is possible for RFA to download dictionary from ADS/ADH and save that dictionary for local use next time the app runs?

Tagged:

Best Answer

  • Jirapongse
    Jirapongse
    Answer ✓

    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; 
    }

Answers

  • umer.nalla
    umer.nalla

    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.

Categories