classdef2code.cc

Go to the documentation of this file.

#include <filesystem>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <regex>
#include <sstream>
#include <stdexcept>
#include <string>
#include <vector>
 
using namespace std;
 
struct Includes {
  std::vector<std::string> api;
  std::vector<std::string> apiV2;
  std::vector<std::string> files;
};
 
void outputTypes(std::ostream &out, const Includes &includes) {
  out << R"(#ifndef __JDB__JDBTypes__
#define __JDB__JDBTypes__
 
/**
 * @file
 * This file is automatically created by classdef2code during CMake build.
 */
 
namespace JDATABASE {
 
)";
 
  for (auto v1 : includes.api) {
    out << "  class " << v1 << ";\n";
  }
 
  out << "\n  namespace APIV2 {\n\n";
  for (auto v2 : includes.apiV2) {
    out << "    class " << v2 << ";\n";
  }
 
  out << R"(
  }
}
#endif
)";
}
 
void outputIncludes(std::ostream &out, const Includes &includes) {
  out << R"(/**
 * @file
 * This file is automatically created by classdef2code during CMake build.
 */
 
)";
  for (auto i : includes.files) {
    std::filesystem::path p(i);
    out << "#include \"JDB/" << p.filename().string() << "\"\n";
  }
}
 
Includes parseIncludes(const std::vector<std::string> &includes) {
  Includes cn;
  for (auto infile : includes) {
    ifstream in(infile);
    if (!in.is_open()) {
      std::cerr << "Cannot open input file " << infile << "\n";
      exit(1);
    }
    string line;
    std::regex classDefRegex(R"(ClassDef\s*(?:NV)?\‍(\s*(.*)\s*,\s*(\d*))");
    std::regex apiV2Regex("namespace.*APIV2");
    std::smatch classDefMatch;
    bool v2{false};
    string stype{""};
    bool used{false};
    while (getline(in, line)) {
      if (std::regex_search(line, apiV2Regex)) {
        v2 = true;
      }
      if (std::regex_search(line, classDefMatch, classDefRegex)) {
        // classDefMatch[2] is the version, if needed.
        stype = classDefMatch[1];
        if (v2) {
          cn.apiV2.emplace_back(stype);
          used = true;
        } else {
          cn.api.emplace_back(stype);
          used = true;
        }
      }
    }
    if (used) {
      cn.files.emplace_back(infile);
    }
  }
  return cn;
}
 
/**
 * Helper program to create includes files for types and includes
 * from a list of JDB includes
 *
 */
int main(int argc, char **argv) {
  if (argc < 5) {
    throw runtime_error("need at least 4 arguments");
  }
  string outfile = argv[1];    // output file name
  string outputType = argv[2]; // output type ("types" or "includes")
  vector<string> classdefs; // input include files (absolute paths or relative
                            // to current dir)
  for (int i = 3; i < argc; i++) {
    classdefs.emplace_back(argv[i]);
  }
 
  auto includes = parseIncludes(classdefs);
 
  ofstream out(outfile);
  if (!out.is_open()) {
    std::cerr << "Cannot open output file " << outfile << "\n";
    exit(1);
  }
 
  if (outputType == "types") {
    outputTypes(out, includes);
  } else if (outputType == "includes") {
    outputIncludes(out, includes);
  } else {
    std::cerr << "don't know what to do with outputType " << outputType
              << " : I only know 'types' or 'includes'\n";
    exit(2);
  }
 
  return 0;
}