Detailed Description
│ │ │ -This example shows how the argument parser can be used.
│ │ │ -/* -*- mode: C++; indent-tabs-mode: nil; -*-
│ │ │ +This program gives an example of how to read and write a digraph and additional maps from/to a stream or a file using the LGF format.
│ │ │ +The "digraph.lgf" file:
@nodes
│ │ │ +label
│ │ │ +0
│ │ │ +1
│ │ │ +2
│ │ │ +3
│ │ │ +4
│ │ │ +5
│ │ │ +6
│ │ │ +7
│ │ │ +@arcs
│ │ │ + label capacity
│ │ │ +0 1 0 16
│ │ │ +0 2 1 12
│ │ │ +0 3 2 20
│ │ │ +1 2 3 10
│ │ │ +1 4 4 10
│ │ │ +1 5 5 13
│ │ │ +2 3 6 10
│ │ │ +2 4 7 8
│ │ │ +2 6 8 8
│ │ │ +5 3 9 20
│ │ │ +3 6 10 25
│ │ │ +4 7 11 15
│ │ │ +5 7 12 15
│ │ │ +6 7 13 18
│ │ │ +@attributes
│ │ │ +source 0
│ │ │ +target 7
│ │ │ +And the program which reads it and prints the digraph to the standard output:
/* -*- mode: C++; indent-tabs-mode: nil; -*-
│ │ │ *
│ │ │ * This file is a part of LEMON, a generic C++ optimization library.
│ │ │ *
│ │ │ - * Copyright (C) 2003-2010
│ │ │ + * Copyright (C) 2003-2009
│ │ │ * 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.
│ │ │ *
│ │ │ */
│ │ │ #include <lemon/arg_parser.h>
│ │ │ +#include <iostream>
│ │ │ +#include <lemon/smart_graph.h>
│ │ │ +#include <lemon/lgf_reader.h>
│ │ │ +#include <lemon/lgf_writer.h>
│ │ │ using namespace lemon;
│ │ │ -int main(int argc, char **argv)
│ │ │ -{
│ │ │ - // Initialize the argument parser
│ │ │ - ArgParser ap(argc, argv);
│ │ │ - int i;
│ │ │ - std::string s;
│ │ │ - double d = 1.0;
│ │ │ - bool b, nh;
│ │ │ - bool g1, g2, g3;
│ │ │ - // Add a mandatory integer option with storage reference
│ │ │ - ap.refOption("n", "An integer input.", i, true);
│ │ │ - // Add a double option with storage reference (the default value is 1.0)
│ │ │ - ap.refOption("val", "A double input.", d);
│ │ │ - // Add a double option without storage reference (the default value is 3.14)
│ │ │ - ap.doubleOption("val2", "A double input.", 3.14);
│ │ │ - // Set synonym for -val option
│ │ │ - ap.synonym("vals", "val");
│ │ │ - // Add a string option
│ │ │ - ap.refOption("name", "A string input.", s);
│ │ │ - // Add bool options
│ │ │ - ap.refOption("f", "A switch.", b)
│ │ │ - .refOption("nohelp", "", nh)
│ │ │ - .refOption("gra", "Choice A", g1)
│ │ │ - .refOption("grb", "Choice B", g2)
│ │ │ - .refOption("grc", "Choice C", g3);
│ │ │ - // Bundle -gr* options into a group
│ │ │ - ap.optionGroup("gr", "gra")
│ │ │ - .optionGroup("gr", "grb")
│ │ │ - .optionGroup("gr", "grc");
│ │ │ - // Set the group mandatory
│ │ │ - ap.mandatoryGroup("gr");
│ │ │ - // Set the options of the group exclusive (only one option can be given)
│ │ │ - ap.onlyOneGroup("gr");
│ │ │ - // Add non-parsed arguments (e.g. input files)
│ │ │ - ap.other("infile", "The input file.")
│ │ │ - .other("...");
│ │ │ - // Throw an exception when problems occurs. The default behavior is to
│ │ │ - // exit(1) on these cases, but this makes Valgrind falsely warn
│ │ │ - // about memory leaks.
│ │ │ - ap.throwOnProblems();
│ │ │ - // Perform the parsing process
│ │ │ - // (in case of any error it terminates the program)
│ │ │ - // The try {} construct is necessary only if the ap.trowOnProblems()
│ │ │ - // setting is in use.
│ │ │ - try {
│ │ │ - ap.parse();
│ │ │ -
│ │ │ // Check each option if it has been given and print its value
│ │ │ - std::cout << "Parameters of '" << ap.commandName() << "':\n";
│ │ │ +int main() {
│ │ │ + SmartDigraph g;
│ │ │ + SmartDigraph::ArcMap<int> cap(g);
│ │ │ + SmartDigraph::Node s, t;
│ │ │ std::cout << " Value of -n: " << i << std::endl;
│ │ │ - if(ap.given("val")) std::cout << " Value of -val: " << d << std::endl;
│ │ │ - if(ap.given("val2")) {
│ │ │ - d = ap["val2"];
│ │ │ - std::cout << " Value of -val2: " << d << std::endl;
│ │ │ - }
│ │ │ - if(ap.given("name")) std::cout << " Value of -name: " << s << std::endl;
│ │ │ - if(ap.given("f")) std::cout << " -f is given\n";
│ │ │ - if(ap.given("nohelp")) std::cout << " Value of -nohelp: " << nh << std::endl;
│ │ │ - if(ap.given("gra")) std::cout << " -gra is given\n";
│ │ │ - if(ap.given("grb")) std::cout << " -grb is given\n";
│ │ │ - if(ap.given("grc")) std::cout << " -grc is given\n";
│ │ │ - switch(ap.files().size()) {
│ │ │ - case 0:
│ │ │ - std::cout << " No file argument was given.\n";
│ │ │ - break;
│ │ │ - case 1:
│ │ │ - std::cout << " 1 file argument was given. It is:\n";
│ │ │ - break;
│ │ │ - default:
│ │ │ - std::cout << " "
│ │ │ - << ap.files().size() << " file arguments were given. They are:\n";
│ │ │ + try {
│ │ │ +
│ │ │ + arcMap("capacity", cap). // read the 'capacity' arc map into cap
│ │ │ + node("source", s). // read 'source' node to s
│ │ │ + node("target", t). // read 'target' node to t
│ │ │ + run();
│ │ │ +
│ │ │ + std::cerr << "Error: " << error.what() << std::endl;
│ │ │ + return -1;
│ │ │ }
│ │ │ - for(unsigned int i=0;i<ap.files().size();++i)
│ │ │ - std::cout << " '" << ap.files()[i] << "'\n";
│ │ │ + std::cout << "A digraph is read from 'digraph.lgf'." << std::endl;
│ │ │ + std::cout << "Number of nodes: " << countNodes(g) << std::endl;
│ │ │ + std::cout << "Number of arcs: " << countArcs(g) << std::endl;
│ │ │ + std::cout << "We can write it to the standard output:" << std::endl;
│ │ │ + digraphWriter(g). // write g to the standard output
│ │ │ + arcMap("capacity", cap). // write cap into 'capacity'
│ │ │ + node("source", s). // write s to 'source'
│ │ │ + node("target", t). // write t to 'target'
│ │ │ + run();
│ │ │ return 0;
│ │ │ }
│ │ │ -A tool to parse command line arguments.
SmartDigraph and SmartGraph classes.
LEMON Graph Format reader.
LEMON Graph Format writer.
int countNodes(const Graph &g)
Function to count the nodes in the graph.
Definition: core.h:252
int countArcs(const Graph &g)
Function to count the arcs in the graph.
Definition: core.h:356
DigraphReader< TDGR > digraphReader(TDGR &digraph, std::istream &is)
Return a DigraphReader class.
Definition: lgf_reader.h:1265
DigraphWriter< TDGR > digraphWriter(const TDGR &digraph, std::ostream &os)
Return a DigraphWriter class.
Definition: lgf_writer.h:980
#include <lemon/arg_parser.h>│ │ │ + │ │ │ +
virtual const char * what() const
A short description of the exception.
Definition: error.h:49
#include <iostream>│ │ │ +
#include <lemon/smart_graph.h>│ │ │ +
#include <lemon/lgf_reader.h>│ │ │ +
#include <lemon/lgf_writer.h>│ │ │
│ │ │ Generated on Mon Jul 25 2022 18:36:57 for My Project by
1.9.4
│ │ │
│ │ │
│ │ │
│ │ │ ├── html2text {}
│ │ │ │ @@ -1,116 +1,127 @@
│ │ │ │ My Project
│ │ │ │ * _d_e_m_o
│ │ │ │ -arg_parser_demo.cc File Reference
│ │ │ │ +lgf_demo.cc File Reference
│ │ │ │ _D_e_m_o_ _P_r_o_g_r_a_m_s
│ │ │ │ ********** DDeettaaiilleedd DDeessccrriippttiioonn **********
│ │ │ │ -This example shows how the argument parser can be used.
│ │ │ │ +This program gives an example of how to read and write a digraph and additional
│ │ │ │ +maps from/to a stream or a file using the _L_G_F format.
│ │ │ │ +The "digraph.lgf" file:
│ │ │ │ +@nodes
│ │ │ │ +label
│ │ │ │ +0
│ │ │ │ +1
│ │ │ │ +2
│ │ │ │ +3
│ │ │ │ +4
│ │ │ │ +5
│ │ │ │ +6
│ │ │ │ +7
│ │ │ │ +@arcs
│ │ │ │ +label capacity
│ │ │ │ +0 1 0 16
│ │ │ │ +0 2 1 12
│ │ │ │ +0 3 2 20
│ │ │ │ +1 2 3 10
│ │ │ │ +1 4 4 10
│ │ │ │ +1 5 5 13
│ │ │ │ +2 3 6 10
│ │ │ │ +2 4 7 8
│ │ │ │ +2 6 8 8
│ │ │ │ +5 3 9 20
│ │ │ │ +3 6 10 25
│ │ │ │ +4 7 11 15
│ │ │ │ +5 7 12 15
│ │ │ │ +6 7 13 18
│ │ │ │ +@attributes
│ │ │ │ +source 0
│ │ │ │ +target 7
│ │ │ │ +And the program which reads it and prints the digraph to the standard output:
│ │ │ │ /* -*- mode: C++; indent-tabs-mode: nil; -*-
│ │ │ │ *
│ │ │ │ * This file is a part of LEMON, a generic C++ optimization library.
│ │ │ │ *
│ │ │ │ -* Copyright (C) 2003-2010
│ │ │ │ +* Copyright (C) 2003-2009
│ │ │ │ * 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.
│ │ │ │ *
│ │ │ │ */
│ │ │ │ -#include <_l_e_m_o_n_/_a_r_g___p_a_r_s_e_r_._h>
│ │ │ │ +#include