reject_codes.cpp

Go to the documentation of this file.

/******************************************************************************
** Copyright © 2016 by J.M.McGuiness, isimud@hussar.me.uk
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
 
#include "core/application.hpp"
#include "core/exit_codes.hpp"
 
#include <boost/algorithm/string/split.hpp>
#include <boost/exception/diagnostic_information.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/program_options.hpp>
 
#include <cstdint>
#include <filesystem>
#include <fstream>
#include <iostream>
#include <map>
 
using namespace libjmmcg;
 
using row_t=std::vector<std::string>;
using table_t=std::map<std::int32_t, row_t>;
using parsed_csv_t=std::tuple<std::string, table_t, row_t::size_type, row_t::size_type>;
 
constexpr const char copyright[]=
"/******************************************************************************\n"
"** Copyright © 2016 by J.M.McGuiness, isimud@hussar.me.uk\n"
"**\n"
"** This library is free software; you can redistribute it and/or\n"
"** modify it under the terms of the GNU Lesser General Public\n"
"** License as published by the Free Software Foundation; either\n"
"** version 2.1 of the License, or (at your option) any later version.\n"
"**\n"
"** This library is distributed in the hope that it will be useful,\n"
"** but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
"** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
"** Lesser General Public License for more details.\n"
"**\n"
"** You should have received a copy of the GNU Lesser General Public\n"
"** License along with this library; if not, write to the Free Software\n"
"** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
"*/\n"
"#include \"../../common/config.h\"\n\n"
"#include <cassert>\n"
"#include <cstdint>\n"
"#include <iostream>\n";
constexpr const char header_guard_postfix[]="#endif\n";
/// The reject code must always be in the first column.
constexpr const row_t::size_type code_index=0;
/// The maximum number of columns in the converted CSV.
constexpr const row_t::size_type max_columns=5;
/// The name of the enum that is created with tags composed from the printable characters from the string relating to the reject-code.
constexpr const char reject_codes_enum_str[]="reject_codes_enum";
 
/// Some of the lines in the dratted CSV don't end with commas, so ensure that they do to allow the comma-recognition code to work correctly.
/**
   If a terminal comma is omitted, that last column will be read as empty.
*/
inline void
fixup_csv_line(std::string &line) noexcept(false) {
   if (*line.rbegin()!=',') {
      line.push_back(',');
   }
}
 
/// Some of the reject-codes are prefixed with zeroes, which in C++ signifies an octal number, strip those zeroes to ensure the reject-codes are correctly treated as decimal.
inline std::string
deoctalify(std::string const &code) noexcept(false) {
   std::string ret(code);
   while (ret.size()>1 && ret.front()=='0') {
      ret.erase(ret.begin());
   }
   return ret;
}
 
/// Sometimes the reject-code has trailing non-printable characters before the comma-separator. Strip it.
inline std::string
strip_trailing_junk(std::string const &code) noexcept(false) {
   std::string ret(code);
   while (ret.size()>1 && !std::isdigit(*ret.begin())) {
      ret.erase(std::next(ret.begin(), ret.size()-1));
   }
   return ret;
}
 
/// Suitably clean up the reject-code.
inline std::string
make_digits(std::string const &code) noexcept(false) {
   return strip_trailing_junk(deoctalify(code));
}
 
/// Convert the scanned line from the input CSV-file into a collection of strings, one string per column.
/**
   Also replace non-printable ASCII characters with underscores.
   
   \todo Consider using libjmmcg::csv_iterator
*/
inline row_t
make_row(std::string line) noexcept(false) {
   fixup_csv_line(line);
   assert(*line.rbegin()==',');
   row_t row;
   row.reserve(max_columns);
   std::string::size_type beg=0;
   std::string::size_type end=0;
   while ((end=line.find(",", beg))!=std::string::npos) {
      row_t::value_type cell(std::next(line.begin(), beg), std::next(line.begin(), end));
      std::transform(
         cell.begin(),
         cell.end(),
         cell.begin(),
         [](std::string::value_type v) {
            return std::isalnum(v) || std::isspace(v) || std::ispunct(v) ? v : '_';
         }
      );
      row.emplace_back(std::move(cell));
      beg=end;
      if (beg>=line.size()) {
         break;
      }
      ++beg;
   }
   return row;
}
 
inline std::string
remove_quotes(std::string const &s) noexcept(false) {
   return std::string(std::next(s.begin()), std::next(s.begin(), s.size()-1));
}
 
/// Read in and parse the specified CSV-file.
/**
   Note that any lines with non-digit reject-codes will be silently ignored.
   All FixGateway reject-codes are ignored (as they cause duplicates) & the links are binary-only.
   
   \param   fname The suitably-qualified path to the suitably-formatted CSV file. It must be comma separated, with no embedded commas.
   \param   ver_headers The string that specifies the headers for the version-table.
   \return  An associative collection of reject-code to details, the version string and column numbers of the required details in the rows.
*/
inline parsed_csv_t
read_csv(std::string const &fname, std::string const &version_headers, std::string const &end_of_version_headers, std::vector<std::string> const &reject_code_headers, std::string const &reject_column_name) noexcept(false) {
   assert(!reject_code_headers.empty());
   assert(reject_code_headers.size()<=max_columns);
   const auto &check_ver=[fname, version_headers, end_of_version_headers](auto const &version) {
      if (version.empty()) {
         std::ostringstream os;
         os<<"In: '"<<fname<<"', failed to find the version, using version headers: ["<<version_headers<<"] & end-version headers: ["<<end_of_version_headers<<"].";
         throw std::runtime_error(os.str());
      }
   };
   const std::string::size_type num_version_headers=std::count(version_headers.begin(), version_headers.end(), ',');
   assert(num_version_headers>1);
   std::ifstream reject_codes(fname.c_str());
   if (!reject_codes.is_open()) {
      std::ostringstream os;
      os<<"Failed to open the CSV file: '"<<fname<<"'.";
      throw std::runtime_error(os.str());
   }
   std::string line;
   std::string version;
   bool found_reject_code_headers=false;
   bool found_version_headers=false;
   while (std::getline(reject_codes, line, '\n')) {
      if (line.find(reject_code_headers[0])!=std::string::npos
         && line.find(reject_code_headers[1])!=std::string::npos
         && line.find(reject_code_headers[2])!=std::string::npos
         && line.find(reject_code_headers[3])!=std::string::npos) {
         found_reject_code_headers=true;
         break;
      } else if (line.find(version_headers)!=std::string::npos) {
         found_version_headers=true;
         break;
      }
   }
   if (found_version_headers) {
      while (std::getline(reject_codes, line, '\n')) {
         if (line.find(reject_code_headers[0])!=std::string::npos
            && line.find(reject_code_headers[1])!=std::string::npos
            && line.find(reject_code_headers[2])!=std::string::npos
            && line.find(reject_code_headers[3])!=std::string::npos) {
            found_reject_code_headers=true;
            break;
         } else if (line.find(end_of_version_headers)!=std::string::npos) {
            found_version_headers=false;
         }
         if (found_version_headers) {
            version=line;
         }
      }
      check_ver(version);
   }
   if (!found_reject_code_headers) {
      std::ostringstream os;
      os<<"In: '"<<fname<<"', failed to find the reject-code headers: [";
      std::copy(reject_code_headers.begin(), reject_code_headers.end(), std::ostream_iterator<std::string>(os, ","));
      os<<"].";
      throw std::runtime_error(os.str());
   }
   if (!found_reject_code_headers) {
      std::ostringstream os;
      os<<"In: '"<<fname<<"', failed to find the reject-code headers: [";
      std::copy(reject_code_headers.begin(), reject_code_headers.end(), std::ostream_iterator<std::string>(os, ","));
      os<<"].";
      throw std::runtime_error(os.str());
   }
   table_t table;
   row_t row(make_row(line));
   assert(!row.empty());
   assert(row.size()>=(max_columns-1));
   [[maybe_unused]] auto const &length_column=std::find(row.begin(), row.end(), reject_code_headers[1]);
   assert(length_column!=row.end());
   auto const &reason_column=std::find(row.begin(), row.end(), reject_column_name);
   assert(reason_column!=row.end());
   const row_t::size_type reason_index=reason_column-row.begin();
   assert(reason_index>code_index);
   assert(reason_index<max_columns);
   auto const &process_column=std::find(row.begin(), row.end(), reject_code_headers[3]);
   assert(process_column!=row.end());
   const row_t::size_type process_index=process_column-row.begin();
   assert(process_index>reason_index);
   while (std::getline(reject_codes, line, '\n')) {
      row_t row(make_row(line));
      if (row.size()>process_index) {
         if (!row[code_index].empty()
            && !row[reason_index].empty()
            && !row[process_index].empty()
            && row[process_index].find("FixGateway")==std::string::npos
            && row[process_index].find("FIX Gateway")==std::string::npos
            && row[process_index].find("FIX Trading")==std::string::npos
            && row[process_index].find("FIXTradingGateway")==std::string::npos
            && row[process_index].find("FIX/FAST")==std::string::npos
            && row[process_index].find("FAST Gateway")==std::string::npos
            && row[process_index].find("RNS Feed")==std::string::npos
         ) {
            try {
               row[code_index]=make_digits(row[code_index]);
               table.insert(std::make_pair(boost::lexical_cast<std::int32_t>(row[code_index]), row));
            } catch (std::exception const &) {
               // Silently ignore any rubbish in the input CSV....
            }
         }
      } else if (row.size()>num_version_headers && !row[code_index].empty() && !row[num_version_headers].empty()) {
         version=line;
      }
      row.clear();
   }
   if (version.empty()) {
      std::ostringstream os;
      os<<"In: '"<<fname<<"', failed to find the version headers: ["<<version_headers<<"].";
      throw std::runtime_error(os.str());
   }
   assert(!table.empty());
   return parsed_csv_t(version, table, reason_index, process_index);
}
 
/// Replace the non-alpha-numeric characters in the input string into underscores.
inline std::string
ASCII_ify(std::string const &arg) noexcept(false) {
   std::string ret(arg);
   std::transform(
      ret.begin(),
      ret.end(),
      ret.begin(),
      [](char v) {
         return std::isalnum(v) ? v : '_';
      }
   );
   return ret;
}
 
/// Construct a suitable enum-tag from the parsed row.
inline std::string
reject_code_to_enum_tag(table_t::const_iterator row, const row_t::size_type reason_index, const row_t::size_type process_index) noexcept(false) {
   const std::string tag(ASCII_ify(row->second[reason_index]));
   const std::string process(ASCII_ify(row->second[process_index]));
   return process+"_"+tag+"_"+row->second[code_index];
}
 
/// Apply a specified operator to all but the penultimate element in the collection, to which a different operation should be applied.
/**
   Algorithmic complexity: O(n)
   \param   c  The input collection.
   \param   o  The functor to be applied to all but the penultimate element in the input collection.
   \param   t  The functor to be applied to the penultimate element in the input collection.
*/
template<class Colln, class Op, class Trail>
inline void
fill(Colln &c, Op const &o, Trail const &t) noexcept(false) {
   auto row=c.begin();
   while (row!=std::prev(c.end())) {
      o.operator()(row);
      t.operator()();
      ++row;
   }
   o.operator()(row);
}
 
inline void
write_reject_code_enum(table_t const &table, const row_t::size_type reason_index, const row_t::size_type process_index, std::ostream &os) noexcept(false) {
   assert(!table.empty());
   os<<"using RejectCodes_t=std::int32_t;\n"
         "enum class "<<reject_codes_enum_str<<" : RejectCodes_t {\n"
         "\ttag_SUCCESS=0,\n";
   fill(
      table,
      [&os, reason_index, process_index](table_t::const_iterator row) {
         if (row->second.size()>reason_index) {
            const row_t::value_type cell(reject_code_to_enum_tag(row, reason_index, process_index));
            os<<"\t"<<cell<<"="<<row->first;
         }
      },
      [&os]() {
         os<<",\n";
      }
   );
   os<<"\n};\n";
}
 
inline void
write_string_table(table_t const &table, const row_t::size_type reason_index, std::ostream &os) noexcept(false) {
   assert(!table.empty());
   os<<"\tstatic constexpr char const * const reject_code_strs[]={\n"
      "\t\t\"SUCCESS\",\n";
   fill(
      table,
      [&os, reason_index](table_t::const_iterator row) {
         if (row->second.size()>reason_index) {
            os<<"\t\t\""<<row->second[reason_index]<<"\"";
         }
      },
      [&os]() {
         os<<",\n";
      }
   );
   os<<"\n\t};\n";
}
 
inline void
write_code_to_reason(table_t const &table, const row_t::size_type reason_index, const row_t::size_type process_index, std::ostream &os) noexcept(false) {
   os<<"inline std::ostream &\n"
      "operator<<(std::ostream &os, const "<<reject_codes_enum_str<<" code) noexcept(true) {\n";
   write_string_table(table, reason_index, os);
   assert(!table.empty());
   unsigned int reject_code_strs_index=0;
   os<<"\tswitch (code) {\n"
      "\t\tcase "<<reject_codes_enum_str<<"::tag_SUCCESS:\n"
      "\t\t\tos<<reject_code_strs["<<reject_code_strs_index<<"];\n"
      "\t\t\treturn os;\n";
   ++reject_code_strs_index;
   fill(
      table,
      [reason_index, process_index, &os, &reject_code_strs_index](table_t::const_iterator row) {
         if (row->second.size()>reason_index) {
            const row_t::value_type cell(reject_code_to_enum_tag(row, reason_index, process_index));
            os<<"\t\tcase "<<reject_codes_enum_str<<"::"<<cell<<":\n"
               "\t\t\tos<<reject_code_strs["<<reject_code_strs_index<<"];"
               "\t\t\treturn os;";
         }
         ++reject_code_strs_index;
      },
      [&os]() {
         os<<"\n";
      }
   );
   os<<"\n\t\tdefault:\n"
      "\t\t\tassert(!\"Unknown reject code.\");\n"
      "\t\t\tos<<\"Unknown reject code.\";\n"
      "\t\t\treturn os;\n"
      "\t};\n"
      "}\n";
}
 
inline void
write_header(parsed_csv_t const &parsed_csv, std::string const &fname, std::string const &nm_space) noexcept(false) {
   struct header_guard_t {
      std::ostream &os;
 
       header_guard_t(std::string const &nm_space, std::string const &xls_version, std::string const &fname, std::ostream &s) noexcept(false)
      : os(s) {
         os
            <<"#ifndef ISIMUD_EXCHANGES_MIT_REJECT_CODES_"<<nm_space<<"_"<<std::filesystem::path(fname).stem().string()<<"_hpp\n"
               "#define ISIMUD_EXCHANGES_MIT_REJECT_CODES_"<<nm_space<<"_"<<std::filesystem::path(fname).stem().string()<<"_hpp\n"
            <<copyright
            <<"// Auto-generated header file from auto-downloaded and converted XLS from the web, so good luck trying to identify the source.\n"
               "// DO NOT EDIT. IT WILL BE OVERWRITTEN.\n"
               "// Source XLS version info: '"<<xls_version<<"'\n"
               "// Version: "<<LIBJMMCG_VERSION_NUMBER<<"\n"
               "namespace isimud { namespace ISIMUD_VER_NAMESPACE { namespace exchanges { namespace MIT { namespace "<<nm_space<<" {\n";
      }
      ~header_guard_t() noexcept(false) {
         os<<"} } } } }\n"
            <<header_guard_postfix;
      }
   };
   std::ofstream cpp_header(fname.c_str());
   const header_guard_t header_guard(nm_space, std::get<0>(parsed_csv), fname, cpp_header);
   write_reject_code_enum(std::get<1>(parsed_csv), std::get<2>(parsed_csv), std::get<3>(parsed_csv), cpp_header);
   write_code_to_reason(std::get<1>(parsed_csv), std::get<2>(parsed_csv), std::get<3>(parsed_csv), cpp_header);
}
 
/// For MIT-based protocols, auto-generate a C++ function to convert the reject codes to strings. The mapping comes from the downloaded XLS that has been converted to a CSV file.
int
main(int argc, char const * const *argv) noexcept(true) {
   try {
      boost::program_options::options_description general(
         "A program to convert a table of exchange reject-codes in CSV-format to a C++ header-file. For details regarding the properties of the translator see the documentation that came with the distribution. Copyright © J.M.McGuiness, isimud@hussar.me.uk. http://libjmmcg.sf.net/ Distributed under the terms of the GPL v2.1.\n"+exit_codes::to_string()+"Arguments"
      );
      general.add_options()
         ("help", "Print this help message.")
         ("version", "Print the build number of this program.")
      ;
      boost::program_options::options_description prog_opts("Program options.");
      prog_opts.add_options()
         ("reject_codes", boost::program_options::value<std::string>()->required(), "The file-path of the reject codes.")
         ("cpp_header", boost::program_options::value<std::string>()->required(), "The file-path of the output C++ header-file.")
         ("namespace", boost::program_options::value<std::string>()->required(), "The namespace into which the contents of the header-file should be placed.")
         ("reject_code_headers", boost::program_options::value<std::string>()->required(), "The text that identifies the column-headings for the reject-codes.")
         ("reject_column_name", boost::program_options::value<std::string>()->required(), "The text that identifies the column name of the reject-codes.")
         ("version_headers", boost::program_options::value<std::string>()->required(), "The text that identifies the column-headings for the version information.")
         ("end_of_version_headers", boost::program_options::value<std::string>()->required(), "The text that identifies the column-headings delimiting the end of the version information. Some of the MIT-based exchanges convert to CSVs that have more than one table, this one follows the reject-code translations.")
      ;
      boost::program_options::options_description all("All options.");
      all.add(general).add(prog_opts);
      boost::program_options::variables_map vm;
      boost::program_options::store(boost::program_options::parse_command_line(argc, argv, all), vm);
      if (vm.count("help")) {
         std::cout<<all<<std::endl;
         return exit_codes::exit_print_help;
      }
      if (vm.count("version")) {
         std::cout<<LIBJMMCG_DETAILED_VERSION_INFO<<std::endl;
         return exit_codes::exit_print_version;
      }
      boost::program_options::notify(vm);
 
      std::vector<std::string> reject_codes_headers;
      std::string version_headers(remove_quotes(vm["reject_code_headers"].as<std::string>()));
      const parsed_csv_t parsed_csv(
         read_csv(
            vm["reject_codes"].as<std::string>(),
            remove_quotes(vm["version_headers"].as<std::string>()),
            remove_quotes(vm["end_of_version_headers"].as<std::string>()),
            boost::split(
               reject_codes_headers,
               version_headers,
               [](auto const &v) {return v==',';}
            ),
            remove_quotes(vm["reject_column_name"].as<std::string>())
         )
      );
      write_header(
         parsed_csv,
         vm["cpp_header"].as<std::string>(),
         vm["namespace"].as<std::string>()
      );
      return exit_codes::exit_success;
   } catch (std::exception const &ex) {
      std::cerr<<"STL-derived exception. Details: "<<boost::diagnostic_information(ex)<<std::endl;
      return exit_codes::exit_stl_exception;
   } catch (...) {
      std::cerr<<"Unknown exception."<<std::endl;
      return exit_codes::exit_unknown_exception;
   }
   return exit_codes::exit_unknown_failure;
}