JEditProperties.cc

Go to the documentation of this file.

#include <iostream>
#include <fstream>
#include <iomanip>
#include <string>
#include <vector>
#include <set>
#include <map>
 
#include "JLang/JEquationParameters.hh"
#include "JLang/JEquation.hh"
#include "JLang/JToken.hh"
#include "JSupport/JMeta.hh"
 
#include "Jeep/JProperties.hh"
#include "Jeep/JComment.hh"
#include "Jeep/JParser.hh"
#include "Jeep/JMessage.hh"
 
namespace {
 
  using JLANG::JEquation;
 
  /**
   * Auxiliary data structure for counted value.
   */
  struct value_type {
    std::string    value = "";
    mutable size_t count = 0;
  };
 
 
  /**
   * Auxiliary map for conversion of equation with counted value.
   */
  struct map_type :
    public std::map<std::string, value_type>
  {
    /**
     * Convert equation.
     *
     * \param  equation    equation
     * \return             equation
     */
    JEquation operator()(const JEquation& equation) const
    {
      const_iterator p = this->find(equation.getKey());
 
      if (p != this->end()) {
 
        p->second.count += 1;
 
        return JEquation(equation.getKey(), p->second.value);
      }
 
      return equation;
    }
  };
}
 
 
/**
 * \file
 *
 * General purpose program to edit or create properties file.
 * \author mdejong
 */
int main(int argc, char **argv)
{
  using namespace std;
  using namespace JPP;
 
  typedef JToken<';'>  token_type;
 
  string              inputFile;
  string              outputFile;
  JEquationParameters parameters("=", "\n;", "", "#");
  vector<token_type>  modifier;
  set<string>         rm;
  bool                squash;
  int                 debug;
 
  try {
 
    JProperties properties;
 
    properties["sep"]   = parameters.getSeparator();
    properties["eol"]   = parameters.getEndOfLine();
    properties["div"]   = parameters.getDivision();
    properties["skip"]  = parameters.getSkipLine();
    properties["left"]  = parameters.getLeftBracket();
    properties["right"] = parameters.getRightBracket();
    properties["ws"]    = parameters.getWhiteSpace();
    properties["cc"]    = parameters.getComment();
 
    JParser<> zap("General purpose program to edit or create properties file.");
    
    zap['f'] = make_field(inputFile)   = "";
    zap['o'] = make_field(outputFile)  = "";
    zap['@'] = make_field(properties)  = JPARSER::initialised();
    zap['M'] = make_field(modifier,    "modifier; syntax \"<key> = <value>[" << token_type::SEPARATOR << "..]\"")  =  JPARSER::initialised();
    zap['r'] = make_field(rm,          "remove key")                                                               =  JPARSER::initialised();
    zap['q'] = make_field(squash,      "squash meta data");
    zap['d'] = make_field(debug,       "debug level")                                                              = 2;
 
    zap(argc, argv);
  }
  catch(const exception &error) {
    FATAL(error.what() << endl);
  }
 
 
  // modifiers
 
  map_type zip;
 
  if (!modifier.empty()) {
 
    const JEquationFacet facet(JEquationParameters("=", string(1,token_type::SEPARATOR), "", ""));
 
    istringstream is;
 
    is.imbue(locale(is.getloc(), facet.clone()));
 
    for (const token_type& token : modifier) {
 
      is.clear();
      is.str(token);
 
      JEquation equation;
 
      if (is >> equation && facet.isSeparator(equation.getSeparator()))
        zip[equation.getKey()] = { equation.getValue(), 0 };
      else
        ERROR("Invalid modifier: " << token << endl);
    }
  }
 
 
  // intermediate storage
 
  const JEquationFacet facet(parameters);
 
  ostringstream os;
 
  os.imbue(locale(cout.getloc(), facet.clone()));
 
 
  // input
 
  ifstream in(inputFile.c_str());
 
  JComment comment;
 
  in >> comment;
 
  if (squash) {
    comment.clear();
  }
 
  comment.add(JMeta(argc, argv));
 
  os << comment;
 
  istringstream is;
 
  is.imbue(locale(is.getloc(), facet.clone()));
 
  for (string buffer; getline(in, buffer, facet.getDefaultEndOfLine()); ) {
 
    is.clear();
    is.str(buffer);
 
    JEquation equation;
 
    if (is >> equation && facet.isSeparator(equation.getSeparator())) {
 
      if (rm.count(equation.getKey()) == 0) {
        os << zip(equation);
      }
 
    } else {
 
      os << buffer << endl;
    }
  }
 
  in.close();
 
 
  // add pending modifiers
 
  for (const auto& i : zip) {
    if (i.second.count == 0) {
      os << JEquation(i.first, i.second.value);
    }
  }
 
 
  // output
 
  filebuf buffer;
 
  if (outputFile != "") {
    buffer.open(outputFile.c_str(), ios::out);
  }
 
  ostream out(buffer.is_open() ? &buffer : cout.rdbuf());
 
  out << os.str();
 
  buffer.close();
}