RhodeCode

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * 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 Argument parser demo

///

/// This example shows how the argument parser can be used.

///

/// \include arg_parser_demo.cc

#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();

  } catch (ArgParserException &) { return 1; }

  // Check each option if it has been given and print its value

  std::cout << "Parameters of '" << ap.commandName() << "':\n";

  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";

  }

  for(unsigned int i=0;i<ap.files().size();++i)

    std::cout << "    '" << ap.files()[i] << "'\n";

  return 0;

}

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * 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.

 *

 */

namespace lemon {

/**

@defgroup datas Data Structures

This group contains the several data structures implemented in LEMON.

*/

/**

@defgroup graphs Graph Structures

@ingroup datas

\brief Graph structures implemented in LEMON.

The implementation of combinatorial algorithms heavily relies on

efficient graph implementations. LEMON offers data structures which are

planned to be easily used in an experimental phase of implementation studies,

and thereafter the program code can be made efficient by small modifications.

The most efficient implementation of diverse applications require the

usage of different physical graph implementations. These differences

appear in the size of graph we require to handle, memory or time usage

limitations or in the set of operations through which the graph can be

accessed.  LEMON provides several physical graph structures to meet

the diverging requirements of the possible users.  In order to save on

running time or on memory usage, some structures may fail to provide

some graph features like arc/edge or node deletion.

Alteration of standard containers need a very limited number of

operations, these together satisfy the everyday requirements.

In the case of graph structures, different operations are needed which do

not alter the physical graph, but gives another view. If some nodes or

arcs have to be hidden or the reverse oriented graph have to be used, then

this is the case. It also may happen that in a flow implementation

the residual graph can be accessed by another algorithm, or a node-set

is to be shrunk for another algorithm.

LEMON also provides a variety of graphs for these requirements called

\ref graph_adaptors "graph adaptors". Adaptors cannot be used alone but only

in conjunction with other graph representations.

You are free to use the graph structure that fit your requirements

the best, most graph algorithms and auxiliary data structures can be used

with any graph structure.

<b>See also:</b> \ref graph_concepts "Graph Structure Concepts".

*/

/**

@defgroup graph_adaptors Adaptor Classes for Graphs

@ingroup graphs

\brief Adaptor classes for digraphs and graphs

This group contains several useful adaptor classes for digraphs and graphs.

The main parts of LEMON are the different graph structures, generic

graph algorithms, graph concepts, which couple them, and graph

adaptors. While the previous notions are more or less clear, the

latter one needs further explanation. Graph adaptors are graph classes

which serve for considering graph structures in different ways.

A short example makes this much clearer.  Suppose that we have an

instance \c g of a directed graph type, say ListDigraph and an algorithm

\code

template <typename Digraph>

int algorithm(const Digraph&);

\endcode

is needed to run on the reverse oriented graph.  It may be expensive

(in time or in memory usage) to copy \c g with the reversed

arcs.  In this case, an adaptor class is used, which (according

to LEMON \ref concepts::Digraph "digraph concepts") works as a digraph.

The adaptor uses the original digraph structure and digraph operations when

methods of the reversed oriented graph are called.  This means that the adaptor

have minor memory usage, and do not perform sophisticated algorithmic

actions.  The purpose of it is to give a tool for the cases when a

graph have to be used in a specific alteration.  If this alteration is

obtained by a usual construction like filtering the node or the arc set or

considering a new orientation, then an adaptor is worthwhile to use.

To come back to the reverse oriented graph, in this situation

\code

template<typename Digraph> class ReverseDigraph;

\endcode

template class can be used. The code looks as follows

\code

ListDigraph g;

ReverseDigraph<ListDigraph> rg(g);

int result = algorithm(rg);

\endcode

During running the algorithm, the original digraph \c g is untouched.

This techniques give rise to an elegant code, and based on stable

graph adaptors, complex algorithms can be implemented easily.

In flow, circulation and matching problems, the residual

graph is of particular importance. Combining an adaptor implementing

this with shortest path algorithms or minimum mean cycle algorithms,

a range of weighted and cardinality optimization algorithms can be

obtained. For other examples, the interested user is referred to the

detailed documentation of particular adaptors.

The behavior of graph adaptors can be very different. Some of them keep

capabilities of the original graph while in other cases this would be

meaningless. This means that the concepts that they meet depend

on the graph adaptor, and the wrapped graph.

For example, if an arc of a reversed digraph is deleted, this is carried

out by deleting the corresponding arc of the original digraph, thus the

adaptor modifies the original digraph.

However in case of a residual digraph, this operation has no sense.

Let us stand one more example here to simplify your work.

ReverseDigraph has constructor

\code

ReverseDigraph(Digraph& digraph);

\endcode

This means that in a situation, when a <tt>const %ListDigraph&</tt>

reference to a graph is given, then it have to be instantiated with

<tt>Digraph=const %ListDigraph</tt>.

\code

int algorithm1(const ListDigraph& g) {

  ReverseDigraph<const ListDigraph> rg(g);

  return algorithm2(rg);

}

\endcode

*/

/**

@defgroup maps Maps

@ingroup datas

\brief Map structures implemented in LEMON.

This group contains the map structures implemented in LEMON.

LEMON provides several special purpose maps and map adaptors that e.g. combine

new maps from existing ones.

<b>See also:</b> \ref map_concepts "Map Concepts".

*/

/**

@defgroup graph_maps Graph Maps

@ingroup maps

\brief Special graph-related maps.

This group contains maps that are specifically designed to assign

values to the nodes and arcs/edges of graphs.

If you are looking for the standard graph maps (\c NodeMap, \c ArcMap,

\c EdgeMap), see the \ref graph_concepts "Graph Structure Concepts".

*/

/**

\defgroup map_adaptors Map Adaptors

\ingroup maps

\brief Tools to create new maps from existing ones

This group contains map adaptors that are used to create "implicit"

maps from other maps.

Most of them are \ref concepts::ReadMap "read-only maps".

They can make arithmetic and logical operations between one or two maps

(negation, shifting, addition, multiplication, logical 'and', 'or',

'not' etc.) or e.g. convert a map to another one of different Value type.

The typical usage of this classes is passing implicit maps to

algorithms.  If a function type algorithm is called then the function

type map adaptors can be used comfortable. For example let's see the

usage of map adaptors with the \c graphToEps() function.

\code

  Color nodeColor(int deg) {

    if (deg >= 2) {

      return Color(0.5, 0.0, 0.5);

    } else if (deg == 1) {

      return Color(1.0, 0.5, 1.0);

    } else {

      return Color(0.0, 0.0, 0.0);

    }

  }

  Digraph::NodeMap<int> degree_map(graph);

  graphToEps(graph, "graph.eps")

    .coords(coords).scaleToA4().undirected()

    .nodeColors(composeMap(functorToMap(nodeColor), degree_map))

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * 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.

 *

 */

/**

\mainpage LEMON Documentation

\section intro Introduction

<b>LEMON</b> stands for <i><b>L</b>ibrary for <b>E</b>fficient <b>M</b>odeling

and <b>O</b>ptimization in <b>N</b>etworks</i>.

It is a C++ template library providing efficient implementations of common

data structures and algorithms with focus on combinatorial optimization

tasks connected mainly with graphs and networks. 

<b>

LEMON is an <a class="el" href="http://opensource.org/">open&nbsp;source</a>

project.

You are free to use it in your commercial or

non-commercial applications under very permissive

\ref license "license terms".

</b>

The project is maintained by the 

<a href="http://www.cs.elte.hu/egres/">Egerv&aacute;ry Research Group on

Combinatorial Optimization</a> \ref egres

at the Operations Research Department of the

<a href="http://www.elte.hu/en/">E&ouml;tv&ouml;s Lor&aacute;nd University</a>,

Budapest, Hungary.

LEMON is also a member of the <a href="http://www.coin-or.org/">COIN-OR</a>

initiative \ref coinor.

\section howtoread How to Read the Documentation

If you would like to get to know the library, see

<a class="el" href="http://lemon.cs.elte.hu/pub/tutorial/">LEMON Tutorial</a>.

If you are interested in starting to use the library, see the <a class="el"

href="http://lemon.cs.elte.hu/trac/lemon/wiki/InstallGuide/">Installation

Guide</a>.

If you know what you are looking for, then try to find it under the

<a class="el" href="modules.html">Modules</a> section.

If you are a user of the old (0.x) series of LEMON, please check out the

\ref migration "Migration Guide" for the backward incompatibilities.

*/

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * 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.

 *

 */

namespace lemon {

/**

\page min_cost_flow Minimum Cost Flow Problem

\section mcf_def Definition (GEQ form)

The \e minimum \e cost \e flow \e problem is to find a feasible flow of

minimum total cost from a set of supply nodes to a set of demand nodes

in a network with capacity constraints (lower and upper bounds)

and arc costs \ref amo93networkflows.

Formally, let \f$G=(V,A)\f$ be a digraph, \f$lower: A\rightarrow\mathbf{R}\f$,

\f$upper: A\rightarrow\mathbf{R}\cup\{+\infty\}\f$ denote the lower and

upper bounds for the flow values on the arcs, for which

\f$lower(uv) \leq upper(uv)\f$ must hold for all \f$uv\in A\f$,

\f$cost: A\rightarrow\mathbf{R}\f$ denotes the cost per unit flow

on the arcs and \f$sup: V\rightarrow\mathbf{R}\f$ denotes the

signed supply values of the nodes.

If \f$sup(u)>0\f$, then \f$u\f$ is a supply node with \f$sup(u)\f$

supply, if \f$sup(u)<0\f$, then \f$u\f$ is a demand node with

\f$-sup(u)\f$ demand.

A minimum cost flow is an \f$f: A\rightarrow\mathbf{R}\f$ solution

of the following optimization problem.

\f[ \min\sum_{uv\in A} f(uv) \cdot cost(uv) \f]

\f[ \sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \geq

    sup(u) \quad \forall u\in V \f]

\f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A \f]

The sum of the supply values, i.e. \f$\sum_{u\in V} sup(u)\f$ must be

zero or negative in order to have a feasible solution (since the sum

of the expressions on the left-hand side of the inequalities is zero).

It means that the total demand must be greater or equal to the total

supply and all the supplies have to be carried out from the supply nodes,

but there could be demands that are not satisfied.

If \f$\sum_{u\in V} sup(u)\f$ is zero, then all the supply/demand

constraints have to be satisfied with equality, i.e. all demands

have to be satisfied and all supplies have to be used.

\section mcf_algs Algorithms

LEMON contains several algorithms for solving this problem, for more

information see \ref min_cost_flow_algs "Minimum Cost Flow Algorithms".

A feasible solution for this problem can be found using \ref Circulation.

\section mcf_dual Dual Solution

The dual solution of the minimum cost flow problem is represented by

node potentials \f$\pi: V\rightarrow\mathbf{R}\f$.

An \f$f: A\rightarrow\mathbf{R}\f$ primal feasible solution is optimal

if and only if for some \f$\pi: V\rightarrow\mathbf{R}\f$ node potentials

the following \e complementary \e slackness optimality conditions hold.

 - For all \f$uv\in A\f$ arcs:

   - if \f$cost^\pi(uv)>0\f$, then \f$f(uv)=lower(uv)\f$;

   - if \f$lower(uv)<f(uv)<upper(uv)\f$, then \f$cost^\pi(uv)=0\f$;

   - if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$.

 - For all \f$u\in V\f$ nodes:

   - \f$\pi(u)\leq 0\f$;

   - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$,

     then \f$\pi(u)=0\f$.

Here \f$cost^\pi(uv)\f$ denotes the \e reduced \e cost of the arc

\f$uv\in A\f$ with respect to the potential function \f$\pi\f$, i.e.

\f[ cost^\pi(uv) = cost(uv) + \pi(u) - \pi(v).\f]

All algorithms provide dual solution (node potentials), as well,

if an optimal flow is found.

\section mcf_eq Equality Form

The above \ref mcf_def "definition" is actually more general than the

usual formulation of the minimum cost flow problem, in which strict

equalities are required in the supply/demand contraints.

\f[ \min\sum_{uv\in A} f(uv) \cdot cost(uv) \f]

\f[ \sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) =

    sup(u) \quad \forall u\in V \f]

\f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A \f]

However if the sum of the supply values is zero, then these two problems

are equivalent.

The \ref min_cost_flow_algs "algorithms" in LEMON support the general

form, so if you need the equality form, you have to ensure this additional

contraint manually.

\section mcf_leq Opposite Inequalites (LEQ Form)

Another possible definition of the minimum cost flow problem is

when there are <em>"less or equal"</em> (LEQ) supply/demand constraints,

instead of the <em>"greater or equal"</em> (GEQ) constraints.

\f[ \min\sum_{uv\in A} f(uv) \cdot cost(uv) \f]

\f[ \sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \leq

    sup(u) \quad \forall u\in V \f]

\f[ lower(uv) \leq f(uv) \leq upper(uv) \quad \forall uv\in A \f]

It means that the total demand must be less or equal to the 

total supply (i.e. \f$\sum_{u\in V} sup(u)\f$ must be zero or

positive) and all the demands have to be satisfied, but there

could be supplies that are not carried out from the supply

nodes.

The equality form is also a special case of this form, of course.

You could easily transform this case to the \ref mcf_def "GEQ form"

of the problem by reversing the direction of the arcs and taking the

negative of the supply values (e.g. using \ref ReverseDigraph and

\ref NegMap adaptors).

However \ref NetworkSimplex algorithm also supports this form directly

for the sake of convenience.

Note that the optimality conditions for this supply constraint type are

slightly differ from the conditions that are discussed for the GEQ form,

namely the potentials have to be non-negative instead of non-positive.

An \f$f: A\rightarrow\mathbf{R}\f$ feasible solution of this problem

is optimal if and only if for some \f$\pi: V\rightarrow\mathbf{R}\f$

node potentials the following conditions hold.

 - For all \f$uv\in A\f$ arcs:

   - if \f$cost^\pi(uv)>0\f$, then \f$f(uv)=lower(uv)\f$;

   - if \f$lower(uv)<f(uv)<upper(uv)\f$, then \f$cost^\pi(uv)=0\f$;

   - if \f$cost^\pi(uv)<0\f$, then \f$f(uv)=upper(uv)\f$.

 - For all \f$u\in V\f$ nodes:

   - \f$\pi(u)\geq 0\f$;

   - if \f$\sum_{uv\in A} f(uv) - \sum_{vu\in A} f(vu) \neq sup(u)\f$,

     then \f$\pi(u)=0\f$.

*/

}

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * 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.

 *

 */

#ifndef LEMON_ADAPTORS_H

#define LEMON_ADAPTORS_H

/// \ingroup graph_adaptors

/// \file

/// \brief Adaptor classes for digraphs and graphs

///

/// This file contains several useful adaptors for digraphs and graphs.

#include <lemon/core.h>

#include <lemon/maps.h>

#include <lemon/bits/variant.h>

#include <lemon/bits/graph_adaptor_extender.h>

#include <lemon/bits/map_extender.h>

#include <lemon/tolerance.h>

#include <algorithm>

namespace lemon {

#ifdef _MSC_VER

#define LEMON_SCOPE_FIX(OUTER, NESTED) OUTER::NESTED

#else

#define LEMON_SCOPE_FIX(OUTER, NESTED) typename OUTER::template NESTED

#endif

  template<typename DGR>

  class DigraphAdaptorBase {

  public:

    typedef DGR Digraph;

    typedef DigraphAdaptorBase Adaptor;

  protected:

    DGR* _digraph;

    DigraphAdaptorBase() : _digraph(0) { }

    void initialize(DGR& digraph) { _digraph = &digraph; }

  public:

    DigraphAdaptorBase(DGR& digraph) : _digraph(&digraph) { }

    typedef typename DGR::Node Node;

    typedef typename DGR::Arc Arc;

    void first(Node& i) const { _digraph->first(i); }

    void first(Arc& i) const { _digraph->first(i); }

    void firstIn(Arc& i, const Node& n) const { _digraph->firstIn(i, n); }

    void firstOut(Arc& i, const Node& n ) const { _digraph->firstOut(i, n); }

    void next(Node& i) const { _digraph->next(i); }

    void next(Arc& i) const { _digraph->next(i); }

    void nextIn(Arc& i) const { _digraph->nextIn(i); }

    void nextOut(Arc& i) const { _digraph->nextOut(i); }

    Node source(const Arc& a) const { return _digraph->source(a); }

    Node target(const Arc& a) const { return _digraph->target(a); }

    typedef NodeNumTagIndicator<DGR> NodeNumTag;

    int nodeNum() const { return _digraph->nodeNum(); }

    typedef ArcNumTagIndicator<DGR> ArcNumTag;

    int arcNum() const { return _digraph->arcNum(); }

    typedef FindArcTagIndicator<DGR> FindArcTag;

    Arc findArc(const Node& u, const Node& v, const Arc& prev = INVALID) const {

      return _digraph->findArc(u, v, prev);

    }

    Node addNode() { return _digraph->addNode(); }

    Arc addArc(const Node& u, const Node& v) { return _digraph->addArc(u, v); }

    void erase(const Node& n) { _digraph->erase(n); }

    void erase(const Arc& a) { _digraph->erase(a); }

    void clear() { _digraph->clear(); }

    int id(const Node& n) const { return _digraph->id(n); }

    int id(const Arc& a) const { return _digraph->id(a); }

    Node nodeFromId(int ix) const { return _digraph->nodeFromId(ix); }

    Arc arcFromId(int ix) const { return _digraph->arcFromId(ix); }

    int maxNodeId() const { return _digraph->maxNodeId(); }

    int maxArcId() const { return _digraph->maxArcId(); }

    typedef typename ItemSetTraits<DGR, Node>::ItemNotifier NodeNotifier;

    NodeNotifier& notifier(Node) const { return _digraph->notifier(Node()); }

    typedef typename ItemSetTraits<DGR, Arc>::ItemNotifier ArcNotifier;

    ArcNotifier& notifier(Arc) const { return _digraph->notifier(Arc()); }

    template <typename V>

    class NodeMap : public DGR::template NodeMap<V> {

      typedef typename DGR::template NodeMap<V> Parent;

    public:

      explicit NodeMap(const Adaptor& adaptor)

        : Parent(*adaptor._digraph) {}

      NodeMap(const Adaptor& adaptor, const V& value)

        : Parent(*adaptor._digraph, value) { }

    private:

      NodeMap& operator=(const NodeMap& cmap) {

        return operator=<NodeMap>(cmap);

      }

      template <typename CMap>

      NodeMap& operator=(const CMap& cmap) {

        Parent::operator=(cmap);

        return *this;

      }

    };

    template <typename V>

    class ArcMap : public DGR::template ArcMap<V> {

      typedef typename DGR::template ArcMap<V> Parent;

    public:

      explicit ArcMap(const DigraphAdaptorBase<DGR>& adaptor)

        : Parent(*adaptor._digraph) {}

      ArcMap(const DigraphAdaptorBase<DGR>& adaptor, const V& value)

        : Parent(*adaptor._digraph, value) {}

    private:

      ArcMap& operator=(const ArcMap& cmap) {

        return operator=<ArcMap>(cmap);

      }

      template <typename CMap>

      ArcMap& operator=(const CMap& cmap) {

        Parent::operator=(cmap);

        return *this;

      }

    };

  };

  template<typename GR>

  class GraphAdaptorBase {

  public:

    typedef GR Graph;

  protected:

    GR* _graph;

    GraphAdaptorBase() : _graph(0) {}

    void initialize(GR& graph) { _graph = &graph; }

  public:

    GraphAdaptorBase(GR& graph) : _graph(&graph) {}

    typedef typename GR::Node Node;

    typedef typename GR::Arc Arc;

    typedef typename GR::Edge Edge;

    void first(Node& i) const { _graph->first(i); }

    void first(Arc& i) const { _graph->first(i); }

    void first(Edge& i) const { _graph->first(i); }

    void firstIn(Arc& i, const Node& n) const { _graph->firstIn(i, n); }

    void firstOut(Arc& i, const Node& n ) const { _graph->firstOut(i, n); }

    void firstInc(Edge &i, bool &d, const Node &n) const {

      _graph->firstInc(i, d, n);

    }

    void next(Node& i) const { _graph->next(i); }

    void next(Arc& i) const { _graph->next(i); }

    void next(Edge& i) const { _graph->next(i); }

    void nextIn(Arc& i) const { _graph->nextIn(i); }

    void nextOut(Arc& i) const { _graph->nextOut(i); }

    void nextInc(Edge &i, bool &d) const { _graph->nextInc(i, d); }

    Node u(const Edge& e) const { return _graph->u(e); }

    Node v(const Edge& e) const { return _graph->v(e); }

    Node source(const Arc& a) const { return _graph->source(a); }

    Node target(const Arc& a) const { return _graph->target(a); }

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * 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>

namespace lemon {

  void ArgParser::_terminate(ArgParserException::Reason reason) const

  {

    if(_exit_on_problems)

      exit(1);

    else throw(ArgParserException(reason));

  }

  void ArgParser::_showHelp(void *p)

  {

    (static_cast<ArgParser*>(p))->showHelp();

    (static_cast<ArgParser*>(p))->_terminate(ArgParserException::HELP);

  }

  ArgParser::ArgParser(int argc, const char * const *argv)

    :_argc(argc), _argv(argv), _command_name(argv[0]),

    _exit_on_problems(true) {

    funcOption("-help","Print a short help message",_showHelp,this);

    synonym("help","-help");

    synonym("h","-help");

  }

  ArgParser::~ArgParser()

  {

    for(Opts::iterator i=_opts.begin();i!=_opts.end();++i)

      if(i->second.self_delete)

        switch(i->second.type) {

        case BOOL:

          delete i->second.bool_p;

          break;

        case STRING:

          delete i->second.string_p;

          break;

        case DOUBLE:

          delete i->second.double_p;

          break;

        case INTEGER:

          delete i->second.int_p;

          break;

        case UNKNOWN:

          break;

        case FUNC:

          break;

        }

  }

  ArgParser &ArgParser::intOption(const std::string &name,

                               const std::string &help,

                               int value, bool obl)

  {

    ParData p;

    p.int_p=new int(value);

    p.self_delete=true;

    p.help=help;

    p.type=INTEGER;

    p.mandatory=obl;

    _opts[name]=p;

    return *this;

  }

  ArgParser &ArgParser::doubleOption(const std::string &name,

                               const std::string &help,

                               double value, bool obl)

  {

    ParData p;

    p.double_p=new double(value);

    p.self_delete=true;

    p.help=help;

    p.type=DOUBLE;

    p.mandatory=obl;

    _opts[name]=p;

    return *this;

  }

  ArgParser &ArgParser::boolOption(const std::string &name,

                               const std::string &help,

                               bool value, bool obl)

  {

    ParData p;

    p.bool_p=new bool(value);

    p.self_delete=true;

    p.help=help;

    p.type=BOOL;

    p.mandatory=obl;

    _opts[name]=p;

    return *this;

  }

  ArgParser &ArgParser::stringOption(const std::string &name,

                               const std::string &help,

                               std::string value, bool obl)

  {

    ParData p;

    p.string_p=new std::string(value);

    p.self_delete=true;

    p.help=help;

    p.type=STRING;

    p.mandatory=obl;

    _opts[name]=p;

    return *this;

  }

  ArgParser &ArgParser::refOption(const std::string &name,

                               const std::string &help,

                               int &ref, bool obl)

  {

    ParData p;

    p.int_p=&ref;

    p.self_delete=false;

    p.help=help;

    p.type=INTEGER;

    p.mandatory=obl;

    _opts[name]=p;

    return *this;

  }

  ArgParser &ArgParser::refOption(const std::string &name,

                                  const std::string &help,

                                  double &ref, bool obl)

  {

    ParData p;

    p.double_p=&ref;

    p.self_delete=false;

    p.help=help;

    p.type=DOUBLE;

    p.mandatory=obl;

    _opts[name]=p;

    return *this;

  }

  ArgParser &ArgParser::refOption(const std::string &name,

                                  const std::string &help,

                                  bool &ref, bool obl)

  {

    ParData p;

    p.bool_p=&ref;

    p.self_delete=false;

    p.help=help;

    p.type=BOOL;

    p.mandatory=obl;

    _opts[name]=p;

    ref = false;

    return *this;

  }

  ArgParser &ArgParser::refOption(const std::string &name,

                               const std::string &help,

                               std::string &ref, bool obl)

  {

    ParData p;

    p.string_p=&ref;

    p.self_delete=false;

    p.help=help;

    p.type=STRING;

    p.mandatory=obl;

    _opts[name]=p;

    return *this;

  }

  ArgParser &ArgParser::funcOption(const std::string &name,

                               const std::string &help,

                               void (*func)(void *),void *data)

  {

    ParData p;

    p.func_p.p=func;

    p.func_p.data=data;

    p.self_delete=false;

    p.help=help;

    p.type=FUNC;

    p.mandatory=false;

    _opts[name]=p;

    return *this;

/* -*- mode: C++; indent-tabs-mode: nil; -*-

 *

 * This file is a part of LEMON, a generic C++ optimization library.

 *

 * 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.

 *

 */

#ifndef LEMON_ARG_PARSER_H

#define LEMON_ARG_PARSER_H

#include <vector>

#include <map>

#include <list>

#include <string>

#include <iostream>

#include <sstream>

#include <algorithm>

#include <lemon/assert.h>

///\ingroup misc

///\file

///\brief A tool to parse command line arguments.

namespace lemon {

  ///Exception used by ArgParser

  class ArgParserException : public Exception {

  public:

    enum Reason {

      HELP,         /// <tt>--help</tt> option was given

      UNKNOWN_OPT,  /// Unknown option was given

      INVALID_OPT   /// Invalid combination of options

    };

  private:

    Reason _reason;

  public:

    ///Constructor

    ArgParserException(Reason r) throw() : _reason(r) {}

    ///Virtual destructor

    virtual ~ArgParserException() throw() {}

    ///A short description of the exception

    virtual const char* what() const throw() {

      switch(_reason)

        {

        case HELP:

          return "lemon::ArgParseException: ask for help";

          break;

        case UNKNOWN_OPT:

          return "lemon::ArgParseException: unknown option";

          break;

        case INVALID_OPT:

          return "lemon::ArgParseException: invalid combination of options";

          break;

        }

      return "";

    }

    ///Return the reason for the failure

    Reason reason() const {return _reason; }

  };

  ///Command line arguments parser

  ///\ingroup misc

  ///Command line arguments parser.

  ///

  ///For a complete example see the \ref arg_parser_demo.cc demo file.

  class ArgParser {

    static void _showHelp(void *p);

  protected:

    int _argc;

    const char * const *_argv;

    enum OptType { UNKNOWN=0, BOOL=1, STRING=2, DOUBLE=3, INTEGER=4, FUNC=5 };

    class ParData {

    public:

      union {

        bool *bool_p;

        int *int_p;

        double *double_p;

        std::string *string_p;

        struct {

          void (*p)(void *);

          void *data;

        } func_p;

      };

      std::string help;

      bool mandatory;

      OptType type;

      bool set;

      bool ingroup;

      bool has_syn;

      bool syn;

      bool self_delete;

      ParData() : mandatory(false), type(UNKNOWN), set(false), ingroup(false),

                  has_syn(false), syn(false), self_delete(false) {}

    };

    typedef std::map<std::string,ParData> Opts;

    Opts _opts;

    class GroupData

    {

    public:

      typedef std::list<std::string> Opts;

      Opts opts;

      bool only_one;

      bool mandatory;

      GroupData() :only_one(false), mandatory(false) {}

    };

    typedef std::map<std::string,GroupData> Groups;

    Groups _groups;

    struct OtherArg

    {

      std::string name;

      std::string help;

      OtherArg(std::string n, std::string h) :name(n), help(h) {}

    };

    std::vector<OtherArg> _others_help;

    std::vector<std::string> _file_args;

    std::string _command_name;