Detailed Description
│ │ │ │ -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 example shows how the argument parser can be used.
│ │ │ │ +/* -*- mode: C++; indent-tabs-mode: nil; -*-
│ │ │ │ *
│ │ │ │ * This file is a part of LEMON, a generic C++ optimization library.
│ │ │ │ *
│ │ │ │ - * Copyright (C) 2003-2009
│ │ │ │ + * Copyright (C) 2003-2010
│ │ │ │ * 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 <iostream>
│ │ │ │ -#include <lemon/smart_graph.h>
│ │ │ │ -#include <lemon/lgf_reader.h>
│ │ │ │ -#include <lemon/lgf_writer.h>
│ │ │ │ +#include <lemon/arg_parser.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();
│ │ │ │ +
│ │ │ │ int main() {
│ │ │ │ - SmartDigraph g;
│ │ │ │ - SmartDigraph::ArcMap<int> cap(g);
│ │ │ │ - SmartDigraph::Node s, t;
│ │ │ │ + // Check each option if it has been given and print its value
│ │ │ │ + std::cout << "Parameters of '" << ap.commandName() << "':\n";
│ │ │ │ try {
│ │ │ │ - digraphReader(g, "digraph.lgf"). // read the directed graph into g
│ │ │ │ - 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;
│ │ │ │ + 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;
│ │ │ │ }
│ │ │ │ - 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();
│ │ │ │ + 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";
│ │ │ │ + }
│ │ │ │ + for(unsigned int i=0;i<ap.files().size();++i)
│ │ │ │ + std::cout << " '" << ap.files()[i] << "'\n";
│ │ │ │ return 0;
│ │ │ │ }
│ │ │ │ -LEMON Graph Format reader.
LEMON Graph Format writer.
SmartDigraph and SmartGraph classes.
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
A tool to parse command line arguments.
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>│ │ │ │ + │ │ │ │ + │ │ │ │ +
#include <lemon/arg_parser.h>│ │ │ │
│ │ │ │ Generated on Mon Jul 25 2022 18:36:57 for My Project by
1.9.8
│ │ │ │
│ │ │ │
│ │ │ │
│ │ │ │ ├── html2text {}
│ │ │ │ │ @@ -1,122 +1,119 @@
│ │ │ │ │ My Project
│ │ │ │ │ Loading...
│ │ │ │ │ Searching...
│ │ │ │ │ No Matches
│ │ │ │ │ * _d_e_m_o
│ │ │ │ │ -lgf_demo.cc File Reference
│ │ │ │ │ +arg_parser_demo.cc File Reference
│ │ │ │ │ _D_e_m_o_ _P_r_o_g_r_a_m_s
│ │ │ │ │ ********** DDeettaaiilleedd DDeessccrriippttiioonn **********
│ │ │ │ │ -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:
│ │ │ │ │ +This example shows how the argument parser can be used.
│ │ │ │ │ /* -*- mode: C++; indent-tabs-mode: nil; -*-
│ │ │ │ │ *
│ │ │ │ │ * This file is a part of LEMON, a generic C++ optimization library.
│ │ │ │ │ *
│ │ │ │ │ -* Copyright (C) 2003-2009
│ │ │ │ │ +* Copyright (C) 2003-2010
│ │ │ │ │ * 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