source: observatorio/simulacion/SimEscenariosEconomicos/svg_builder_canviz.C

/* 
 * File:   main.cpp
 * Autor: José Orlando Ruiz Hernández (joseph2283@gmail.com)
 * Institución: Fundación CENDITEL
 *
 * Created on 18 de junio de 2012, 10:05 AM
 * Modified on 02 de mayo de 2014
 *
 * Modificación por Alejandro J. Mujica (amujica@cenditel.gob.ve) con la
 * finalidad de adaptar para que genere la visualización estándar definida.
 */

#include <cstdlib>
#include <argp.h>
#include <string>

# include <tpl_dynDlist.H>

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

using namespace std;

const int MAX_LEVELS_DOWN = 10; //Cantidad máxima permitida de niveles abajo
const int MAX_LEVELS_UP = 10;  //Cantidad máxima permitida de niveles arriba

/* Keys for options without short-options. */
#define OPT_ABORT  1            /* --abort */

/* Opciones disponibles como argumentos del ejecutable del programa*/
static struct argp_option options[] = {
        {"levelsup", 'u', "levelsUp", 0, "Número de niveles hacia arriba", 0},
        {"levelsdown", 'd', "LevelsDown", 0, "Número de niveles hacia abajo", 0},
        {"year", 'y', "year", 0, "Año de estudio", 0},
        {"output", 'o', "OutputName", 0, "Nombre del archivo de salida sin extensión", 0},
        {"host", 'H', "Host", 0, "Host de la base de datos", 0},
        {"port", 'P', "Port", 0, "Puerto de conexión a la base de datos", 0},
        {"username", 'U', "Username", 0, "Usuario de la base de datos", 0},
        {"password", 'W', "Password", 0, "Password de la base de datos", 0},
        {"dbname", 'D', "Dbname", 0, "Nombre de la base de datos", 0},
        {"verbose", 'v', 0, 0, "Modo verbose", 0},
        {0, 0, 0, 0, 0, 0}
};
const char *argp_program_version = "Generador de Cadenas Productivas 2.0\n"
"CENDITEL Nodo Mérida (www.cenditel.gob.ve)";

static char doc[] = "Generador de Cadenas Productivas";

/* Descripcion de los argumentos que se aceptan */
static char args_doc[] = " PROD cod_producto [cod_producto ...]"; 

struct arguments
{
  int levelsup;                 /* '-u', '--levelsup' */
  int levelsdown;               /* '-d', '--levelsdown' */
  string year;                  /* '-y', '--year' */
  string output;                /* '-o', '--output' */
  string host;                  /* '-H', '--host' */
  string port;                  /* '-P', '--port' */
  string username;              /* '-U', '--username' */
  string password;              /* '-W', '--password' */
  string dbname;                /* '-D', '--dbname' */
  string type;                  /* 'arg1' */
  char **  values;              /* 'arg2 [arg3...]' */
  int  num_values;              /*  */
  bool verbose;
};


static error_t parse_opt(int key, char *arg, struct argp_state *state)
{
  struct arguments *arguments = (struct arguments*)state->input;

  switch (key) {
                        break;
                        break;
                case 'u':
                        arguments->levelsup = atoi(arg);
                        break;
                case 'd':
                        arguments->levelsdown = atoi(arg);
                        break;
                case 'y':
                        arguments->year = arg;
                        break;
                case 'o':
                        arguments->output = arg;
                        break;
                case 'H':
                        arguments->host = arg;
                        break;
                case 'P':
                        arguments->port = arg;
                        break;
                case 'U':
                        arguments->username = arg;
                        break;
                case 'W':
                        arguments->password = arg;
                        break;
                case 'D':
                        arguments->dbname = arg;
                        break;

                case 'v':
                        arguments->verbose = true;
                        break;

    case ARGP_KEY_NO_ARGS:
      argp_usage (state);
      break;
    
    case ARGP_KEY_ARG:
       /* Here we know that state->arg_num == 0, since we
          force argument parsing to end before any more arguments can
          get here. */
       arguments->type = arg;
       if(arguments->type!="PROD") { argp_usage (state); }

       /* Now we consume all the rest of the arguments.
          state->next is the index in state->argv of the
          next argument to be parsed, which is the first string
          we're interested in, so we can just use
          &state->argv[state->next] as the value for
          arguments->strings.

          In addition, by setting state->next to the end
          of the arguments, we can force argp to stop parsing here and
          return. */
       arguments->values = &state->argv[state->next];
       state->next = state->argc;

       break;

    case ARGP_KEY_END:
     arguments->num_values = state->arg_num;
     if (state->arg_num < 2 )
       /* Not enough arguments. */
       argp_usage (state);
     break;      

    default:
      return ARGP_ERR_UNKNOWN;
        }
        return 0;
}

static struct argp argp_s = { options, parse_opt, args_doc, doc, 0, 0, 0 };


/*
 * 
 */
int main(int argc, char** argv) {
  
  struct arguments arguments;
  arguments.levelsdown=0;
  arguments.levelsup=0;
  arguments.output="output";
  arguments.host="127.0.0.1";
  arguments.port="5432";
  arguments.username="desarrollos";
  arguments.password="development";
  //arguments.dbname="sig";
  arguments.dbname="sigesic_prueba";
  arguments.year="2010";
  arguments.verbose=false;

 
  if (argp_parse (&argp_s, argc, argv, 0/*ARGP_LONG_ONLY*/,0, &arguments) != 0)
                return 0;
  
  int lvsUp = arguments.levelsup;
  int lvsDown = arguments.levelsdown;

  DBProperties & dbProp = DBProperties::getInstance();

  dbProp.setHost(arguments.host);
  dbProp.setPort(arguments.port);
  dbProp.setDbname(arguments.dbname);
  dbProp.setUser(arguments.username);
  dbProp.setPassword(arguments.password);
  
  if (arguments.verbose) {
      std::cout << "Llenando lista de argumentos...\n";
  }

  DynDlist <long> ids;

  for (size_t i = 0; i < arguments.num_values - 1; ++i) {
      ids.append(std::atol(arguments.values[i]));
  }

  if (arguments.verbose) {
      std::cout << "Lista de argumentos completada\n";
  }

  std::string baseName = arguments.output;

  std::string dotFileName = baseName + ".dot";

  std::string svgOutputFileName = baseName + ".svg";

  std::string gvOutputFileName = baseName + ".gv";

  const char * const xmlRoots = "temp.xml";

  IOManager ioManager;

  if (arguments.verbose) {
      std::cout << "Creando " << xmlRoots << "...\n";
  }

  ioManager.createXmlRootsFile(arguments.year, ids, lvsUp, lvsDown, xmlRoots);

  if (arguments.verbose) {
      std::cout << xmlRoots << " creado.\n";
  }

  try {

      Graph graph;

      if (arguments.verbose) {
          std::cout << "Construyendo red...\n";
      }

      ioManager.buildGraph(xmlRoots, graph);

      if (arguments.verbose) {
          std::cout << "Red construída\n";
      }

      if (arguments.verbose) {
          std::cout << "Eliminando " << xmlRoots << "...\n";
      }

      remove(xmlRoots);

      if (arguments.verbose) {
          std::cout << xmlRoots << " eliminado.\n";
      }

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

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

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

      int returnValue = 0;

      char const * path = "dot";

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

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

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

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

      if (returnValue == 0) {
          if (arguments.verbose) {
              std::cerr << svgOutputFileName << " generado.\n";
          }
      } else {
          std::cout << "Error generando " << svgOutputFileName << "\n";
      }

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

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

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

      if (returnValue == 0) {
           if (arguments.verbose) {
               std::cerr << gvOutputFileName << " generado.\n";
           }
      } else {
          std::cout << "Error generando " << gvOutputFileName << "\n";
      }

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

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

  } catch (const std::exception & e) {
      std::cout << "Excepción capturada: " << e.what() << std::endl;
      return 1;
  }

  return 0;
}