Fix Dictionary Validator Sample

This sample demonstrates how to validate FIX messages from the summary log file by the given dictionary.

Source code:

#include <OnixS/FIXEngine.h>
 
#include "../../Common/Helpers.h"
#include "../../Common/Settings.h"
 
#include <sstream>
 
using namespace Settings;
using namespace OnixS::FIX;
 
typedef OnixS::PtrTraits<Dictionary>::UniquePtr DictionaryPtr;
 
namespace
{
    int parseLogFile(const std::string & logFile, const DictionaryPtr & dialect);
};
 
int main(int argc, char * argv[])
{
    std::clog << "FixDictionaryValidator Sample." << std::endl << std::endl;
 
    try
    {
        if(argc < 2)
        {
            std::clog << "Usage: FixDictionaryValidator [FixLogFileToValidate.summary] (DialectFile) (DialectId)" << std::endl;
            return 1;
        }
 
        EngineSettings settings;
 
        settings.listenPort(-1)
                .licenseStore(LicenseStore)
                .validateRequiredFields(true)
                .validateUnknownFields(true)
                .validateUnknownMessages(true)
                .validateRepeatingGroupEntryCount(true)
                .validateRepeatingGroupLeadingTag(true)
                .validateFieldValues(true);
 
        if(argc > 2)
            settings.dictionaryFile(argv[2]);
 
        Engine::init(settings);
 
        DictionaryPtr dictionary;
 
        if(argc > 3)
            dictionary.reset(new Dictionary(argv[3]));
 
        std::clog << parseLogFile(argv[1], dictionary) <<  " messages are OK." << std::endl;
    }
    catch(const std::exception & ex)
    {
        processSampleException(ex.what());
        return 1;
    }
 
    Engine::shutdown();
 
    return 0;
}
 
namespace
{
    int parseLogFile(const std::string & logFile, const DictionaryPtr & dictionary)
    {
        std::ifstream file(logFile.c_str());
 
        if(!file)
            throw std::runtime_error("Cannot open " + logFile + " log file.");
 
        std::string line = "";
        int lineCounter = 0;
 
        while(std::getline(file, line))
        {
            ++lineCounter;
 
            if(line.empty())
                continue;
 
            const size_t StartOfFixMsgIndex = line.find("8=FIX");
 
            if(std::string::npos == StartOfFixMsgIndex)
            {
                std::stringstream ss;
                ss << lineCounter;
                throw std::runtime_error("Cannot find the start of the FIX message (8=FIX) in line #" + ss.str() + " of " + logFile);
            }
 
            line = line.substr(StartOfFixMsgIndex);
 
            try
            {
                Message message;
 
                if(dictionary.get())
                    Message::parse(line.data(), line.size(), *dictionary, MessageParsingFlag::Strict, message);
                else
                    Message::parse(line.data(), line.size(), MessageParsingFlag::Strict, message);
 
                message.validate();
            }
            catch (...)
            {
                std::stringstream ss;
                ss << lineCounter;
                std::clog << "The validation issue is detected in the summary file at line #" + ss.str() << ":" << std::endl << std::endl << line << std::endl << std::endl;
                throw;
            }
        }
 
        return lineCounter;
    }
};