source: observatorio/simulacion/SimEscenariosEconomicos/graph_builder.C

/*
  Copyright (C) 2012
  Alejandro Mujica (amujica@cenditel.gob.ve)
  Erwin Paredes (eparedes@cenditel.gob.ve)
  José Ruiz (jruiz@cenditel.gob.ve)
  Rodolfo Rangel (rrangel@cenditel.gob.ve)
  Julie Vera (jvera@cenditel.gob.ve)
 
  CENDITEL Fundación Centro Nacional de Desarrollo e Investigación en
  Tecnologías Libres
 
  Este programa es software libre; Usted puede usarlo bajo los términos de la
  licencia de software GPL versión 2.0 de la Free Software Foundation.
 
  Este programa se distribuye con la esperanza de que sea útil, pero SIN
  NINGUNA GARANTÍA; tampoco las implícitas garantías de MERCANTILIDAD o
  ADECUACIÓN A UN PROPÓSITO PARTICULAR.
  Consulte la licencia GPL para más detalles. Usted debe recibir una copia
  de la GPL junto con este programa; si no, escriba a la Free Software
  Foundation Inc. 51 Franklin Street,5 Piso, Boston, MA 02110-1301, USA.
*/

# include <argp.h>

# include <dbProperties.H>
# include <ioManager.H>
# include <process.H>


class Fields
{
  Fields() { /* Empty */ }

public:
  static std::string    dbFileName;

  static std::string    xmlInputFileName;

  static std::string    xmlOutputFileName;

  static bool           generateXml;

  static std::string    svgOutputFileName;

  static bool           generateSvg;

  static std::string    gvOutputFileName;

  static std::string    dotOutputFileName;

  static bool           generateGv;

  static bool           generateDot;

  static bool           verbose;
};

std::string Fields::dbFileName = "";

std::string Fields::xmlInputFileName = "";

std::string Fields::xmlOutputFileName = "";

bool Fields::generateXml = false;

std::string Fields::svgOutputFileName = "";

bool Fields::generateSvg = false;

std::string Fields::gvOutputFileName = "";

bool Fields::generateGv = false;

std::string Fields::dotOutputFileName = "";

bool Fields::generateDot = false;

bool Fields::verbose = false;

const char * argp_program_version =  "Graph Builder v1.1";

const char * argp_program_bug_address = "amujica@cenditel.gob.ve";

static char doc[] = "";

static char argDoc[] = "";

static struct argp_option options [] = {
  {"database", 'b', "database-filename", 0,
   "filename with database attributes", 0},
  {"xml-input", 'i', "xml-input-filename", 0, "xml input filename", 0},
  {"xml-output", 'o', "xml-output-filename", OPTION_ARG_OPTIONAL,
   "xml output filename", 0},
  {"svg-output", 's', "svg-output-filename", OPTION_ARG_OPTIONAL,
   "svg output filename", 0},
  {"gv-output", 'g', "gv-output-filename", OPTION_ARG_OPTIONAL,
   "gv output filename", 0},
  {"dot-output", 'd', "dot-output-filename", OPTION_ARG_OPTIONAL,
   "dot output filename", 0},
  {"keep-dot", 'k', 0, OPTION_ARG_OPTIONAL, "Don't remove temporal'", 0},
  {"verbose", 'v', 0, OPTION_ARG_OPTIONAL, "Verbose mode", 0},
  { 0, 0, 0, 0, 0, 0 }
}; 

static error_t parser_opt(int key, char * arg, struct argp_state *)
{
  switch (key)
    {
    case 'b':
      if (arg == NULL)
        {
          std::cout << "Waiting for filename with database attributes\n";
          exit(0);
        }
      Fields::dbFileName = arg;
      break;

    case 'i':
      if (arg == NULL)
        {
          std::cout << "Waiting for xml input filename\n";
          exit(0);
        }
      Fields::xmlInputFileName = arg;
      break;

    case 'o':
      if (arg == NULL)
        {
          std::cout << "Waiting for xml output filename\n";
          exit(0);
        }
      Fields::xmlOutputFileName = arg;
      Fields::generateXml = true;
      break;

    case 's':
      if (arg == NULL)
        {
          std::cout << "Waiting for svg output filename\n";
          exit(0);
        }
      Fields::svgOutputFileName = arg;
      Fields::generateSvg = true;
      break;

    case 'g':
      if (arg == NULL)
        {
          std::cout << "Waiting for gv output filename\n";
          exit(0);
        }
      Fields::gvOutputFileName = arg;
      Fields::generateGv = true;
      break;

    case 'd':
      if (arg == NULL)
        {
          std::cout << "Waiting for dot output filename\n";
          exit(0);
        }
      Fields::dotOutputFileName = arg;
      Fields::generateDot = true;
      break;

    case 'k': 
      Fields::generateDot = true;
      break;

    case 'v':
      Fields::verbose = true;
      break;
      
    default: return ARGP_ERR_UNKNOWN;
    }

  return 0;
}

static struct argp arg_defs = { options, parser_opt, argDoc, doc, 0, 0, 0 };

int main (int argc, char * argv[]) {

    argp_parse(&arg_defs, argc, argv, ARGP_IN_ORDER, 0, NULL);

    if (Fields::dbFileName == "" or Fields::xmlInputFileName == "") {

        std::cout << "filename with database attributes and xml input filename "
                     "are required\n";
        return 1;

    }

    IOManager ioManager;

    Graph graph;

    try {

        DBProperties::getInstance().readFile(Fields::dbFileName);

        ioManager.buildGraph(Fields::xmlInputFileName, graph);

        if (Fields::generateXml) {

            if (Fields::verbose) {
                std::cout << "Generating xml output...\n";
            }

            ioManager.addGraphToFile(graph, Fields::xmlInputFileName,
                                     Fields::xmlOutputFileName,
                                     IOManager::GRAPH);

            if (Fields::verbose) {
                std::cout << "Xml output generated.\n";
            }
        }

    } catch(const std::exception & e) {

        std::cout << "Exception catched: " << e.what() << std::endl;
        return 2;
    }


    if (Fields::generateSvg or Fields::generateGv or Fields::generateDot) {

        std::string dotFileName =
            Fields::generateDot ? Fields::dotOutputFileName : "temp.dot";

        if (Fields::verbose) {
            std::cout << "Generating " << dotFileName << "...\n";
        }

        ioManager.generateDot<IOManager::NodeLabel, IOManager::ArcLabel>
            (graph, dotFileName);

        if (Fields::verbose) {
            std::cerr << dotFileName << " generated.\n";
        }

        int returnValue = 0;

        char const * path = "dot";

        char * args[] = {"dot", "", (char *) dotFileName.c_str(), "-o", "", 0};

            if (Fields::generateSvg) {

                args[1] = "-Tsvg";
                args[4] = (char *) Fields::svgOutputFileName.c_str();

                if (Fields::verbose) {
                    std::cout << "Generating " << Fields::svgOutputFileName
                              << "...\n";
                }

                returnValue = Process::exec(path, args);

                if (returnValue == 0) {
                    if (Fields::verbose) {
                        std::cerr << Fields::svgOutputFileName
                                  << " generated.\n";
                    }
                } else {
                    std::cout << "Error generating "
                              << Fields::svgOutputFileName << "\n";
                }
            }

            if (Fields::generateGv) {

                args[1] = "-Txdot";
                args[4] = (char *) Fields::gvOutputFileName.c_str();

                if (Fields::verbose) {
                    std::cout << "Generating " << Fields::gvOutputFileName
                              << "...\n";
                }

                returnValue = Process::exec(path, args);

                if (returnValue == 0) {
                    if (Fields::verbose) {
                        std::cerr << Fields::gvOutputFileName
                                  << " generated.\n";
                    }
                } else {
                    std::cout << "Error generating "
                              << Fields::gvOutputFileName << "\n";
                }
            }

            if (not Fields::generateDot) {

                if (Fields::verbose) {
                    std::cout << "Removing " << dotFileName << "...\n";
                }

                remove(dotFileName.c_str());

                if (Fields::verbose) {
                    std::cerr << dotFileName << " removed.\n";
                }
            }

        }

    return 0;
}