/* -*- C++ -*-

  * demo/dim_to_lgf.cc - Part of LEMON, a generic C++ optimization library

  *

  * Copyright (C) 2005 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

  * (Egervary Research Group on Combinatorial Optimization, EGRES).

  *

  * Permission to use, modify and distribute this software is granted

  * provided that this copyright notice appears in all copies. For

  * precise terms see the accompanying LICENSE file.

  *

  * This software is provided "AS IS" with no warranty of any kind,

  * express or implied, and with no claim as to its suitability for any

  * purpose.

  *

  */

 ///\ingroup demos

 ///\file

 ///\brief DIMACS to LGF converter (demo).

 ///

 /// This program converts various DIMACS formats to the LEMON Graph Format

 /// (LGF).

 ///

 /// \include dim_to_lgf.cc

 #include <iostream>

 #include <fstream>

 #include <cstring>

 #include <lemon/smart_graph.h>

 #include <lemon/dimacs.h>

 #include <lemon/graph_writer.h>

 using namespace std;

 using namespace lemon;

 const char* versionString =

 "dim_to_lgf - part of lemon library\n";

 const char* helpString =

 "DIMACS to LGF converter\n"

 "Usage: dim_to_lgf [OPTIONS]\n"

 "\n"

 "Examples:\n"

 "  dim_to_lgf --type shortestpath --input graph.dim --output graph.lgf\n"

 "\n"

 "Options:\n"

 "  -i FILE, --input FILE    use FILE as input instead of standard input\n"

 "  -o FILE, --output FILE   use FILE as output instead of standard output\n"

 "  -t TYPE, --type TYPE     set up the type of the graph\n"

 "                             Possible types:\n"

 "                               mincostflow\n"

 "                               maxflow (default)\n"

 "                               shortestpath\n"

 "                               capacitated\n"

 "                               plain\n"

 "  -v, --version            shows the version of the converter\n"

 "  -h, --help               shows the help of the converter\n";

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

   typedef SmartGraph Graph;

   typedef Graph::Edge Edge;

   typedef Graph::Node Node;

   typedef Graph::EdgeIt EdgeIt;

   typedef Graph::NodeIt NodeIt;

   typedef Graph::EdgeMap<double> DoubleMap;

   std::string inputName;

   std::string outputName;

   std::string typeName;

   bool help = false;

   bool version = false;

   for (int arg = 1; arg < argc; ++arg) {

     if (strcmp(argv[arg], "--type") == 0 || 

 	strcmp(argv[arg], "-t") == 0) {

       if (!typeName.empty()) {

 	cerr << "Multiple type description" << endl;

 	return -1;

       }

       if (arg + 1 == argc) {

 	cerr << "Parameter without value" << endl;

 	return -1;

       }

       typeName = argv[++arg];

     }

     else if (strcmp(argv[arg], "--input") == 0 || 

 	     strcmp(argv[arg], "-i") == 0) {

       if (!inputName.empty()) {

 	cerr << "Multiple input description" << endl;

 	return -1;

       }

       if (arg + 1 == argc) {

 	cerr << "Parameter without value" << endl;

 	return -1;

       }

       inputName = argv[++arg];

     }

     else if (strcmp(argv[arg], "--output") == 0 || 

 	     strcmp(argv[arg], "-o") == 0) {

       if (!outputName.empty()) {

 	cerr << "Multiple input description" << endl;

 	return -1;

       }

       if (arg + 1 == argc) {

 	cerr << "Parameter without value" << endl;

 	return -1;

       }

       outputName = argv[++arg];

     } else if (strcmp(argv[arg], "--help") == 0 ||

 	       strcmp(argv[arg], "-h") == 0) {

       help = true;

     } else if (strcmp(argv[arg], "--version") == 0 ||

 	       strcmp(argv[arg], "-v") == 0) {

       version = true;

     } else {

       cerr << "Invalid option: " << argv[arg] << endl;

       return -1;

     }

   }

   if (version) {

     cout << versionString;

   }

   if (help) {

     cout << helpString;

   }

   if (help || version) {

     return 0;

   }

   ifstream input;

   if (!inputName.empty()) {

     input.open(inputName.c_str());

     if (!input) {

       cerr << "File open error" << endl;

       return -1;

     }

   }

   istream& is = (inputName.empty() ? cin : input);

   ofstream output;

   if (!outputName.empty()) {

     output.open(outputName.c_str());

     if (!output) {

       cerr << "File open error" << endl;

       return -1;

     }

   }

   ostream& os = (outputName.empty() ? cout : output);

   if (typeName.empty()) {

     typeName = "maxflow";

   }

   if (typeName == "mincostflow") {

     Graph graph;

     Node s, t;

     DoubleMap cost(graph), capacity(graph);

     readDimacs(is, graph, capacity, s, t, cost);

     GraphWriter<Graph>(os, graph).

       writeEdgeMap("capacity", capacity).

       writeNode("source", s).

       writeNode("target", t).

       writeEdgeMap("cost", cost).

       run();

   } else if (typeName == "maxflow") {

     Graph graph;

     Node s, t;

     DoubleMap capacity(graph);

     readDimacs(is, graph, capacity, s, t);

     GraphWriter<Graph>(os, graph).

       writeEdgeMap("capacity", capacity).

       writeNode("source", s).

       writeNode("target", t).

       run();

   } else if (typeName == "shortestpath") {

     Graph graph;

     Node s;

     DoubleMap capacity(graph);

     readDimacs(is, graph, capacity, s);

     GraphWriter<Graph>(os, graph).

       writeEdgeMap("capacity", capacity).

       writeNode("source", s).

       run();

   } else if (typeName == "capacitated") {

     Graph graph;

     DoubleMap capacity(graph);

     readDimacs(is, graph, capacity);

     GraphWriter<Graph>(os, graph).

       writeEdgeMap("capacity", capacity).

       run();

   } else if (typeName == "plain") {

     Graph graph;

     readDimacs(is, graph);

     GraphWriter<Graph>(os, graph).run();

   } else {

     cerr << "Invalid type error" << endl;

     return -1;

   }

   return 0;

 }