LEMON/LEMON-main Changeset - r209:765619b7cbb2

demo/arg_parser_demo.cc

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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, const 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("...");
 		  // Perform the parsing process
 		  // (in case of any error it terminates the program)
 		  ap.parse();
 		  // 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;
+		}

demo/graph_to_eps_demo.cc

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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 Demo of the graph drawing function \ref graphToEps()
 		///
 		/// This demo program shows examples how to  use the function \ref
 		/// graphToEps(). It takes no input but simply creates  six
 		/// <tt>.eps</tt> files demonstrating the capability of \ref
 		/// graphToEps(), and showing how to draw directed graphs,
 		/// how to handle parallel egdes, how to change the properties (like
 		/// color, shape, size, title etc.) of nodes and arcs individually
 		/// using appropriate \ref maps-page "graph maps".
 		///
 		/// \include graph_to_eps_demo.cc
 		#include<lemon/list_graph.h>
 		#include<lemon/graph_utils.h>
 		#include<lemon/graph_to_eps.h>
 		#include<lemon/math.h>
 		using namespace std;
 		using namespace lemon;
 		int main()
+		{
 		  Palette palette;
 		  Palette paletteW(true);
 		  // Create a small digraph
 		  ListDigraph g;
 		  typedef ListDigraph::Node Node;
 		  typedef ListDigraph::NodeIt NodeIt;
 		  typedef ListDigraph::Arc Arc;
 		  typedef dim2::Point<int> Point;
 		  Node n1=g.addNode();
 		  Node n2=g.addNode();
 		  Node n3=g.addNode();
 		  Node n4=g.addNode();
 		  Node n5=g.addNode();
 		  ListDigraph::NodeMap<Point> coords(g);
 		  ListDigraph::NodeMap<double> sizes(g);
 		  ListDigraph::NodeMap<int> colors(g);
 		  ListDigraph::NodeMap<int> shapes(g);
 		  ListDigraph::ArcMap<int> acolors(g);
 		  ListDigraph::ArcMap<int> widths(g);
 		  coords[n1]=Point(50,50);  sizes[n1]=1; colors[n1]=1; shapes[n1]=0;
 		  coords[n2]=Point(50,70);  sizes[n2]=2; colors[n2]=2; shapes[n2]=2;
 		  coords[n3]=Point(70,70);  sizes[n3]=1; colors[n3]=3; shapes[n3]=0;
 		  coords[n4]=Point(70,50);  sizes[n4]=2; colors[n4]=4; shapes[n4]=1;
 		  coords[n5]=Point(85,60);  sizes[n5]=3; colors[n5]=5; shapes[n5]=2;
 		  Arc a;
 		  a=g.addArc(n1,n2); acolors[a]=0; widths[a]=1;
 		  a=g.addArc(n2,n3); acolors[a]=0; widths[a]=1;
 		  a=g.addArc(n3,n5); acolors[a]=0; widths[a]=3;
 		  a=g.addArc(n5,n4); acolors[a]=0; widths[a]=1;
 		  a=g.addArc(n4,n1); acolors[a]=0; widths[a]=1;
 		  a=g.addArc(n2,n4); acolors[a]=1; widths[a]=2;
 		  a=g.addArc(n3,n4); acolors[a]=2; widths[a]=1;
 		  IdMap<ListDigraph,Node> id(g);
 		  // Create five .eps files showing the digraph with different options
 		  cout << "Create 'graph_to_eps_demo_out_1_pure.eps'" << endl;
 		  graphToEps(g,"graph_to_eps_demo_out_1_pure.eps").
 		    coords(coords).
 		    title("Sample .eps figure").
 		    copyright("(C) 2003-2008 LEMON Project").
 		    run();
 		  cout << "Create 'graph_to_eps_demo_out_2.eps'" << endl;
 		  graphToEps(g,"graph_to_eps_demo_out_2.eps").
 		    coords(coords).
 		    title("Sample .eps figure").
 		    copyright("(C) 2003-2008 LEMON Project").
 		    absoluteNodeSizes().absoluteArcWidths().
 		    nodeScale(2).nodeSizes(sizes).
 		    nodeShapes(shapes).
 		    nodeColors(composeMap(palette,colors)).
 		    arcColors(composeMap(palette,acolors)).
 		    arcWidthScale(.4).arcWidths(widths).
 		    nodeTexts(id).nodeTextSize(3).
 		    run();
 		  cout << "Create 'graph_to_eps_demo_out_3_arr.eps'" << endl;
 		  graphToEps(g,"graph_to_eps_demo_out_3_arr.eps").
 		    title("Sample .eps figure (with arrowheads)").
 		    copyright("(C) 2003-2008 LEMON Project").
 		    absoluteNodeSizes().absoluteArcWidths().
 		    nodeColors(composeMap(palette,colors)).
 		    coords(coords).
 		    nodeScale(2).nodeSizes(sizes).
 		    nodeShapes(shapes).
 		    arcColors(composeMap(palette,acolors)).
 		    arcWidthScale(.4).arcWidths(widths).
 		    nodeTexts(id).nodeTextSize(3).
 		    drawArrows().arrowWidth(2).arrowLength(2).
 		    run();
 		  a=g.addArc(n1,n4); acolors[a]=2; widths[a]=1;
 		  a=g.addArc(n4,n1); acolors[a]=1; widths[a]=2;
 		  a=g.addArc(n1,n2); acolors[a]=1; widths[a]=1;
 		  a=g.addArc(n1,n2); acolors[a]=2; widths[a]=1;
 		  a=g.addArc(n1,n2); acolors[a]=3; widths[a]=1;
 		  a=g.addArc(n1,n2); acolors[a]=4; widths[a]=1;
 		  a=g.addArc(n1,n2); acolors[a]=5; widths[a]=1;
 		  a=g.addArc(n1,n2); acolors[a]=6; widths[a]=1;
 		  a=g.addArc(n1,n2); acolors[a]=7; widths[a]=1;
 		  cout << "Create 'graph_to_eps_demo_out_par.eps'" << endl;
 		  graphToEps(g,"graph_to_eps_demo_out_par.eps").
 		    //scale(10).
 		    title("Sample .eps figure (parallel arcs)").
 		    copyright("(C) 2003-2008 LEMON Project").
 		    absoluteNodeSizes().absoluteArcWidths().
 		    nodeShapes(shapes).
 		    coords(coords).
 		    nodeScale(2).nodeSizes(sizes).
 		    nodeColors(composeMap(palette,colors)).
 		    arcColors(composeMap(palette,acolors)).
 		    arcWidthScale(.4).arcWidths(widths).
 		    nodeTexts(id).nodeTextSize(3).
 		    enableParallel().parArcDist(1.5).
 		    run();
 		  cout << "Create 'graph_to_eps_demo_out_4_par_arr.eps'" << endl;
 		  graphToEps(g,"graph_to_eps_demo_out_4_par_arr.eps").
 		    title("Sample .eps figure (parallel arcs and arrowheads)").
 		    copyright("(C) 2003-2008 LEMON Project").
 		    absoluteNodeSizes().absoluteArcWidths().
 		    nodeScale(2).nodeSizes(sizes).
 		    coords(coords).
 		    nodeShapes(shapes).
 		    nodeColors(composeMap(palette,colors)).
 		    arcColors(composeMap(palette,acolors)).
 		    arcWidthScale(.3).arcWidths(widths).
 		    nodeTexts(id).nodeTextSize(3).
 		    enableParallel().parArcDist(1).
 		    drawArrows().arrowWidth(1).arrowLength(1).
 		    run();
 		  cout << "Create 'graph_to_eps_demo_out_5_par_arr_a4.eps'" << endl;
 		  graphToEps(g,"graph_to_eps_demo_out_5_par_arr_a4.eps").
 		    title("Sample .eps figure (fits to A4)").
 		    copyright("(C) 2003-2008 LEMON Project").
 		    scaleToA4().
 		    absoluteNodeSizes().absoluteArcWidths().
 		    nodeScale(2).nodeSizes(sizes).
 		    coords(coords).
 		    nodeShapes(shapes).
 		    nodeColors(composeMap(palette,colors)).
 		    arcColors(composeMap(palette,acolors)).
 		    arcWidthScale(.3).arcWidths(widths).
 		    nodeTexts(id).nodeTextSize(3).
 		    enableParallel().parArcDist(1).
 		    drawArrows().arrowWidth(1).arrowLength(1).
 		    run();
 		  // Create an .eps file showing the colors of a default Palette
 		  ListDigraph h;
 		  ListDigraph::NodeMap<int> hcolors(h);
 		  ListDigraph::NodeMap<Point> hcoords(h);
 		  int cols=int(sqrt(double(palette.size())));
 		  for(int i=0;i<int(paletteW.size());i++) {
 		    Node n=h.addNode();
 		    hcoords[n]=Point(1+i%cols,1+i/cols);
 		    hcolors[n]=i;
+		  }
 		  cout << "Create 'graph_to_eps_demo_out_6_colors.eps'" << endl;
 		  graphToEps(h,"graph_to_eps_demo_out_6_colors.eps").
 		    scale(60).
 		    title("Sample .eps figure (Palette demo)").
 		    copyright("(C) 2003-2008 LEMON Project").
 		    coords(hcoords).
 		    absoluteNodeSizes().absoluteArcWidths().
 		    nodeScale(.45).
 		    distantColorNodeTexts().
 		    nodeTexts(hcolors).nodeTextSize(.6).
 		    nodeColors(composeMap(paletteW,hcolors)).
 		    run();
 		  return 0;
+		}

demo/lgf_demo.cc

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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 Demonstrating graph input and output
 		///
 		/// 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
 		/// \ref lgf-format "LGF" format.
 		///
 		/// The \c "digraph.lgf" file:
 		/// \include digraph.lgf
 		///
 		/// And the program which reads it and prints the digraph to the
 		/// standard output:
 		/// \include lgf_demo.cc
 		#include <iostream>
 		#include <lemon/smart_graph.h>
 		#include <lemon/lgf_reader.h>
 		#include <lemon/lgf_writer.h>
 		using namespace lemon;
 		int main() {
 		  SmartDigraph g;
 		  SmartDigraph::ArcMap<int> cap(g);
 		  SmartDigraph::Node s, t;
 		  try {
 		    digraphReader("digraph.lgf", g). // 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();
 		  } catch (DataFormatError& error) { // check if there was any error
 		    std::cerr << "Error: " << error.what() << std::endl;
 		    return -1;
+		  }
 		  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(std::cout, 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;
+		}

doc/coding_style.dox

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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.
+		 *
 		 */
 		/*!
 		\page coding_style LEMON Coding Style
 		\section naming_conv Naming Conventions
 		In order to make development easier we have made some conventions
 		according to coding style. These include names of types, classes,
 		functions, variables, constants and exceptions. If these conventions
 		are met in one's code then it is easier to read and maintain
 		it. Please comply with these conventions if you want to contribute
 		developing LEMON library.
 		\note When the coding style requires the capitalization of an abbreviation,
 		only the first letter should be upper case.
 		\code
 		XmlReader
 		\endcode
 		\warning In some cases we diverge from these rules.
 		This is primary done because STL uses different naming convention and
 		in certain cases
 		it is beneficial to provide STL compatible interface.
 		\subsection cs-files File Names
 		The header file names should look like the following.
 		\code
 		header_file.h
 		\endcode
 		Note that all standard LEMON headers are located in the \c lemon subdirectory,
 		so you should include them from C++ source like this:
 		\code
 		#include <lemon/header_file.h>
 		\endcode
 		The source code files use the same style and they have '.cc' extension.
 		\code
 		source_code.cc
 		\endcode
 		\subsection cs-class Classes and other types
 		The name of a class or any type should look like the following.
 		\code
 		AllWordsCapitalizedWithoutUnderscores
 		\endcode
 		\subsection cs-func Methods and other functions
 		The name of a function should look like the following.
 		\code
 		firstWordLowerCaseRestCapitalizedWithoutUnderscores
 		\endcode
 		\subsection cs-funcs Constants, Macros
 		The names of constants and macros should look like the following.
 		\code
 		ALL_UPPER_CASE_WITH_UNDERSCORES
 		\endcode
 		\subsection cs-loc-var Class and instance member variables, auto variables
 		The names of class and instance member variables and auto variables (=variables used locally in methods) should look like the following.
 		\code
 		all_lower_case_with_underscores
 		\endcode
 		\subsection pri-loc-var Private member variables
 		Private member variables should start with underscore
 		\code
 		_start_with_underscores
 		\endcode
 		\subsection cs-excep Exceptions
 		When writing exceptions please comply the following naming conventions.
 		\code
 		ClassNameEndsWithException
 		\endcode
 		or
 		\code
 		ClassNameEndsWithError
 		\endcode
 		\section header-template Template Header File
 		Each LEMON header file should look like this:
 		\include template.h
 		*/

doc/dirs.dox

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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.
+		 *
 		 */
 		/**
 		\dir demo
 		\brief A collection of demo application.
 		This directory contains several simple demo application, mainly
 		for educational purposes.
 		*/
 		/**
 		\dir doc
 		\brief Auxiliary (and the whole generated) documentation.
 		Auxiliary (and the whole generated) documentation.
 		*/
 		/**
 		\dir test
 		\brief Test programs.
 		This directory contains several test programs that check the consistency
 		of the code.
 		*/
 		/**
 		\dir tools
 		\brief Some useful executables
 		This directory contains the sources of some useful complete executables.
 		*/
 		/**
 		\dir lemon
 		\brief Base include directory of LEMON
 		This is the base directory of lemon includes, so each include file must be
 		prefixed with this, e.g.
 		\code
 		#include<lemon/list_graph.h>
 		#include<lemon/dijkstra.h>
 		\endcode
 		*/
 		/**
 		\dir concepts
 		\brief Concept descriptors and checking classes
 		This directory contains the concept descriptors and concept checkers. As a user
 		you typically don't have to deal with these files.
 		*/
 		/**
 		\dir bits
 		\brief Implementation helper files
 		This directory contains some helper classes to implement graphs, maps and
 		some other classes. As a user you typically don't have to deal with these
 		files.
 		*/

doc/groups.dox

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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.
+		 *
 		 */
 		/**
 		@defgroup datas Data Structures
 		This group describes 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 structures.
 		*/
 		/**
 		@defgroup semi_adaptors Semi-Adaptor Classes for Graphs
 		@ingroup graphs
 		\brief Graph types between real graphs and graph adaptors.
 		This group describes some graph types between real graphs and graph adaptors.
 		These classes wrap graphs to give new functionality as the adaptors do it.
 		On the other hand they are not light-weight structures as the adaptors.
 		*/
 		/**
 		@defgroup maps Maps
 		@ingroup datas
 		\brief Map structures implemented in LEMON.
 		This group describes the map structures implemented in LEMON.
 		LEMON provides several special purpose maps that e.g. combine
 		new maps from existing ones.
 		*/
 		/**
 		@defgroup graph_maps Graph Maps
 		@ingroup maps
 		\brief Special graph-related maps.
 		This group describes maps that are specifically designed to assign
 		values to the nodes and arcs of graphs.
 		*/
 		/**
 		\defgroup map_adaptors Map Adaptors
 		\ingroup maps
 		\brief Tools to create new maps from existing ones
 		This group describes map adaptors that are used to create "implicit"
 		maps from other maps.
 		Most of them are \ref lemon::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 digraphToEps() 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);
 		  digraphToEps(graph, "graph.eps")
 		    .coords(coords).scaleToA4().undirected()
 		    .nodeColors(composeMap(functorToMap(nodeColor), degree_map))
 		    .run();
 		\endcode
 		The \c functorToMap() function makes an \c int to \c Color map from the
 		\e nodeColor() function. The \c composeMap() compose the \e degree_map
 		and the previously created map. The composed map is a proper function to
 		get the color of each node.
 		The usage with class type algorithms is little bit harder. In this
 		case the function type map adaptors can not be used, because the
 		function map adaptors give back temporary objects.
 		\code
 		  Digraph graph;
 		  typedef Digraph::ArcMap<double> DoubleArcMap;
 		  DoubleArcMap length(graph);
 		  DoubleArcMap speed(graph);
 		  typedef DivMap<DoubleArcMap, DoubleArcMap> TimeMap;
 		  TimeMap time(length, speed);
 		  Dijkstra<Digraph, TimeMap> dijkstra(graph, time);
 		  dijkstra.run(source, target);
 		\endcode
 		We have a length map and a maximum speed map on the arcs of a digraph.
 		The minimum time to pass the arc can be calculated as the division of
 		the two maps which can be done implicitly with the \c DivMap template
 		class. We use the implicit minimum time map as the length map of the
 		\c Dijkstra algorithm.
 		*/
 		/**
 		@defgroup matrices Matrices
 		@ingroup datas
 		\brief Two dimensional data storages implemented in LEMON.
 		This group describes two dimensional data storages implemented in LEMON.
 		*/
 		/**
 		@defgroup paths Path Structures
 		@ingroup datas
 		\brief Path structures implemented in LEMON.
 		This group describes the path structures implemented in LEMON.
 		LEMON provides flexible data structures to work with paths.
 		All of them have similar interfaces and they can be copied easily with
 		assignment operators and copy constructors. This makes it easy and
 		efficient to have e.g. the Dijkstra algorithm to store its result in
 		any kind of path structure.
 		\sa lemon::concepts::Path
 		*/
 		/**
 		@defgroup auxdat Auxiliary Data Structures
 		@ingroup datas
 		\brief Auxiliary data structures implemented in LEMON.
 		This group describes some data structures implemented in LEMON in
 		order to make it easier to implement combinatorial algorithms.
 		*/
 		/**
 		@defgroup algs Algorithms
 		\brief This group describes the several algorithms
 		implemented in LEMON.
 		This group describes the several algorithms
 		implemented in LEMON.
 		*/
 		/**
 		@defgroup search Graph Search
 		@ingroup algs
 		\brief Common graph search algorithms.
 		This group describes the common graph search algorithms like
 		Breadth-first search (Bfs) and Depth-first search (Dfs).
 		*/
 		/**
 		@defgroup shortest_path Shortest Path algorithms
 		@ingroup algs
 		\brief Algorithms for finding shortest paths.
 		This group describes the algorithms for finding shortest paths in graphs.
 		*/
 		/**
 		@defgroup max_flow Maximum Flow algorithms
 		@ingroup algs
 		\brief Algorithms for finding maximum flows.
 		This group describes the algorithms for finding maximum flows and
 		feasible circulations.
 		The maximum flow problem is to find a flow between a single source and
 		a single target that is maximum. Formally, there is a \f$G=(V,A)\f$
 		directed graph, an \f$c_a:A\rightarrow\mathbf{R}^+_0\f$ capacity
 		function and given \f$s, t \in V\f$ source and target node. The
 		maximum flow is the \f$f_a\f$ solution of the next optimization problem:
 		\f[ 0 \le f_a \le c_a \f]
 		\f[ \sum_{v\in\delta^{-}(u)}f_{vu}=\sum_{v\in\delta^{+}(u)}f_{uv} \qquad \forall u \in V \setminus \{s,t\}\f]
 		\f[ \max \sum_{v\in\delta^{+}(s)}f_{uv} - \sum_{v\in\delta^{-}(s)}f_{vu}\f]
 		LEMON contains several algorithms for solving maximum flow problems:
 		- \ref lemon::EdmondsKarp "Edmonds-Karp"
 		- \ref lemon::Preflow "Goldberg's Preflow algorithm"
 		- \ref lemon::DinitzSleatorTarjan "Dinitz's blocking flow algorithm with dynamic trees"
 		- \ref lemon::GoldbergTarjan "Preflow algorithm with dynamic trees"
 		In most cases the \ref lemon::Preflow "Preflow" algorithm provides the
 		fastest method to compute the maximum flow. All impelementations
 		provides functions to query the minimum cut, which is the dual linear
 		programming problem of the maximum flow.
 		*/
 		/**
 		@defgroup min_cost_flow Minimum Cost Flow algorithms
 		@ingroup algs
 		\brief Algorithms for finding minimum cost flows and circulations.
 		This group describes the algorithms for finding minimum cost flows and
 		circulations.
 		*/
 		/**
 		@defgroup min_cut Minimum Cut algorithms
 		@ingroup algs

doc/lgf.dox

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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 lgf-format Lemon Graph Format (LGF)
 		The \e LGF is a <em>column oriented</em>
 		file format for storing graphs and associated data like
 		node and edge maps.
 		Each line with \c '#' first non-whitespace
 		character is considered as a comment line.
 		Otherwise the file consists of sections starting with
 		a header line. The header lines starts with an \c '@' character followed by the
 		type of section. The standard section types are \c \@nodes, \c
 		\@arcs and \c \@edges
 		and \@attributes. Each header line may also have an optional
 		\e name, which can be use to distinguish the sections of the same
 		type.
 		The standard sections are column oriented, each line consists of
 		<em>token</em>s separated by whitespaces. A token can be \e plain or
 		\e quoted. A plain token is just a sequence of non-whitespace characters,
 		while a quoted token is a
 		character sequence surrounded by double quotes, and it can also
 		contain whitespaces and escape sequences.
 		The \c \@nodes section describes a set of nodes and associated
 		maps. The first is a header line, its columns are the names of the
 		maps appearing in the following lines.
 		One of the maps must be called \c
 		"label", which plays special role in the file.
 		The following
 		non-empty lines until the next section describes nodes of the
 		graph. Each line contains the values of the node maps
 		associated to the current node.
 		\code
 		 @nodes
 		 label   coordinates size    title
 (10,20)     10      "First node"
 (80,80)     8       "Second node"
 (40,10)     10      "Third node"
 		\endcode
 		The \c \@arcs section is very similar to the \c \@nodes section,
 		it again starts with a header line describing the names of the maps,
 		but the \c "label" map is not obligatory here. The following lines
 		describe the arcs. The first two tokens of each line are
 		the source and the target node of the arc, respectively, then come the map
 		values. The source and target tokens must be node labels.
 		\code
 		 @arcs
 		 	      capacity
 2   16
 3   12
 3   18
 		\endcode
 		The \c \@edges is just a synonym of \c \@arcs. The @arcs section can
 		also store the edge set of an undirected graph. In such case there is
 		a conventional method for store arc maps in the file, if two columns
 		has the same caption with \c '+' and \c '-' prefix, then these columns
 		can be regarded as the values of an arc map.
 		The \c \@attributes section contains key-value pairs, each line
 		consists of two tokens, an attribute name, and then an attribute
 		value. The value of the attribute could be also a label value of a
 		node or an edge, or even an edge label prefixed with \c '+' or \c '-',
 		which regards to the forward or backward directed arc of the
 		corresponding edge.
 		\code
 		 @attributes
 		 source 1
 		 target 3
 		 caption "LEMON test digraph"
 		\endcode
 		The \e LGF can contain extra sections, but there is no restriction on
 		the format of such sections.
 		*/
+		}
 		//  LocalWords:  whitespace whitespaces

doc/license.dox

Show inline comments

/* -*- C++ -*-
/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library
 * This file is a part of LEMON, a generic C++ optimization library.
 *
 * Copyright (C) 2003-2008
 * 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.
 *
 */

/**

\page license License Terms

\verbinclude LICENSE

*/

doc/mainpage.dox

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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
 		\subsection whatis What is LEMON
 		LEMON stands for
 		<b>L</b>ibrary of <b>E</b>fficient <b>M</b>odels
 		and <b>O</b>ptimization in <b>N</b>etworks.
 		It is a C++ template
 		library aimed at combinatorial optimization tasks which
 		often involve in working
 		with graphs.
 		<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>
 		\subsection howtoread How to read the documentation
 		If you want to get a quick start and see the most important features then
 		take a look at our \ref quicktour
 		"Quick Tour to LEMON" which will guide you along.
 		If you already feel like using our library, see the page that tells you
 		\ref getstart "How to start using LEMON".
 		If you
 		want to see how LEMON works, see
 		some \ref demoprograms "demo programs"!
 		If you know what you are looking for then try to find it under the
 		<a class="el" href="modules.html">Modules</a>
 		section.
 		*/

doc/namespaces.dox

Show inline comments

/* -*- C++ -*-
/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library
 * This file is a part of LEMON, a generic C++ optimization library.
 *
 * Copyright (C) 2003-2008
 * 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.
 *
 */

/// The namespace of LEMON

/// The namespace of LEMON
///
namespace lemon {

  /// The namespace of LEMON concepts and concept checking classes

  /// The namespace of LEMON concepts and concept checking classes
  ///
  namespace concepts {}
}

doc/template.h

Show inline comments

/* -*- C++ -*-
/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library
 * This file is a part of LEMON, a generic C++ optimization library.
 *
 * Copyright (C) 2003-2008
 * 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_TEMPLATE_H
#define LEMON_TEMPLATE_H

#endif // LEMON_TEMPLATE_H

lemon/arg_parser.cc

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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::_showHelp(void *p)
+		  {
 		    (static_cast<ArgParser*>(p))->showHelp();
 		    exit(1);
+		  }
 		  ArgParser::ArgParser(int argc, const char **argv) :_argc(argc), _argv(argv),
 		                                                     _command_name(argv[0]) {
 		    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;
+		  }
 		  ArgParser &ArgParser::optionGroup(const std::string &group,
 						    const std::string &opt)
+		  {
 		    Opts::iterator i = _opts.find(opt);
 		    LEMON_ASSERT(i!=_opts.end(), "Unknown option: '"+opt+"'");
 		    LEMON_ASSERT(!(i->second.ingroup),
 		                 "Option already in option group: '"+opt+"'");
 		    GroupData &g=_groups[group];
 		    g.opts.push_back(opt);
 		    i->second.ingroup=true;
 		    return *this;
+		  }
 		  ArgParser &ArgParser::onlyOneGroup(const std::string &group)
+		  {
 		    GroupData &g=_groups[group];
 		    g.only_one=true;
 		    return *this;
+		  }
 		  ArgParser &ArgParser::synonym(const std::string &syn,
 						const std::string &opt)
+		  {
 		    Opts::iterator o = _opts.find(opt);
 		    Opts::iterator s = _opts.find(syn);
 		    LEMON_ASSERT(o!=_opts.end(), "Unknown option: '"+opt+"'");
 		    LEMON_ASSERT(s==_opts.end(), "Option already used: '"+syn+"'");
 		    ParData p;
 		    p.help=opt;
 		    p.mandatory=false;
 		    p.syn=true;
 		    _opts[syn]=p;
 		    o->second.has_syn=true;
 		    return *this;
+		  }
 		  ArgParser &ArgParser::mandatoryGroup(const std::string &group)
+		  {
 		    GroupData &g=_groups[group];
 		    g.mandatory=true;
 		    return *this;
+		  }
 		  ArgParser &ArgParser::other(const std::string &name,
 					      const std::string &help)
+		  {
 		    _others_help.push_back(OtherArg(name,help));
 		    return *this;
+		  }
 		  void ArgParser::show(std::ostream &os,Opts::iterator i)
+		  {
 		    os << "-" << i->first;
 		    if(i->second.has_syn)
 		      for(Opts::iterator j=_opts.begin();j!=_opts.end();++j)
 			if(j->second.syn&&j->second.help==i->first)
 			  os << "|-" << j->first;
 		    switch(i->second.type) {
 		    case STRING:
 		      os << " str";
 		      break;
 		    case INTEGER:
 		      os << " int";
 		      break;
 		    case DOUBLE:
 		      os << " num";
 		      break;
 		    default:

lemon/arg_parser.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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
 		#define LEMON_ARG_PARSER
 		#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 {
 		  ///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 **_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;
 		  private:
 		    //Bind a function to an option.
 		    //\param name The name of the option. The leading '-' must be omitted.
 		    //\param help A help string.
 		    //\retval func The function to be called when the option is given. It
 		    //  must be of type "void f(void *)"
 		    //\param data Data to be passed to \c func
 		    ArgParser &funcOption(const std::string &name,
 				    const std::string &help,
 				    void (*func)(void *),void *data);
 		  public:
 		    ///Constructor
 		    ArgParser(int argc, const char **argv);
 		    ~ArgParser();
 		    ///\name Options
 		    ///
 		    ///@{
 		    ///Add a new integer type option
 		    ///Add a new integer type option.
 		    ///\param name The name of the option. The leading '-' must be omitted.
 		    ///\param help A help string.
 		    ///\param value A default value for the option.
 		    ///\param obl Indicate if the option is mandatory.
 		    ArgParser &intOption(const std::string &name,
 				    const std::string &help,
 				    int value=0, bool obl=false);
 		    ///Add a new floating point type option
 		    ///Add a new floating point type option.
 		    ///\param name The name of the option. The leading '-' must be omitted.
 		    ///\param help A help string.
 		    ///\param value A default value for the option.
 		    ///\param obl Indicate if the option is mandatory.
 		    ArgParser &doubleOption(const std::string &name,
 				      const std::string &help,
 				      double value=0, bool obl=false);
 		    ///Add a new bool type option
 		    ///Add a new bool type option.
 		    ///\param name The name of the option. The leading '-' must be omitted.
 		    ///\param help A help string.
 		    ///\param value A default value for the option.
 		    ///\param obl Indicate if the option is mandatory.
 		    ///\note A mandatory bool obtion is of very little use.
 		    ArgParser &boolOption(const std::string &name,
 				      const std::string &help,
 				      bool value=false, bool obl=false);
 		    ///Add a new string type option
 		    ///Add a new string type option.
 		    ///\param name The name of the option. The leading '-' must be omitted.
 		    ///\param help A help string.
 		    ///\param value A default value for the option.
 		    ///\param obl Indicate if the option is mandatory.
 		    ArgParser &stringOption(const std::string &name,
 				      const std::string &help,
 				      std::string value="", bool obl=false);
 		    ///Give help string for non-parsed arguments.
 		    ///With this function you can give help string for non-parsed arguments.
 		    ///The parameter \c name will be printed in the short usage line, while
 		    ///\c help gives a more detailed description.
 		    ArgParser &other(const std::string &name,
 				     const std::string &help="");
 		    ///@}
 		    ///\name Options with External Storage
 		    ///Using this functions, the value of the option will be directly written
 		    ///into a variable once the option appears in the command line.
 		    ///@{
 		    ///Add a new integer type option with a storage reference
 		    ///Add a new integer type option with a storage reference.
 		    ///\param name The name of the option. The leading '-' must be omitted.
 		    ///\param help A help string.
 		    ///\param obl Indicate if the option is mandatory.
 		    ///\retval ref The value of the argument will be written to this variable.
 		    ArgParser &refOption(const std::string &name,
 				    const std::string &help,
 				    int &ref, bool obl=false);
 		    ///Add a new floating type option with a storage reference
 		    ///Add a new floating type option with a storage reference.
 		    ///\param name The name of the option. The leading '-' must be omitted.
 		    ///\param help A help string.
 		    ///\param obl Indicate if the option is mandatory.
 		    ///\retval ref The value of the argument will be written to this variable.
 		    ArgParser &refOption(const std::string &name,
 				      const std::string &help,
 				      double &ref, bool obl=false);
 		    ///Add a new bool type option with a storage reference
 		    ///Add a new bool type option with a storage reference.
 		    ///\param name The name of the option. The leading '-' must be omitted.
 		    ///\param help A help string.
 		    ///\param obl Indicate if the option is mandatory.
 		    ///\retval ref The value of the argument will be written to this variable.
 		    ///\note A mandatory bool obtion is of very little use.
 		    ArgParser &refOption(const std::string &name,
 				      const std::string &help,
 				      bool &ref, bool obl=false);
 		    ///Add a new string type option with a storage reference
 		    ///Add a new string type option with a storage reference.
 		    ///\param name The name of the option. The leading '-' must be omitted.
 		    ///\param help A help string.
 		    ///\param obl Indicate if the option is mandatory.
 		    ///\retval ref The value of the argument will be written to this variable.
 		    ArgParser &refOption(const std::string &name,
 				      const std::string &help,
 				      std::string &ref, bool obl=false);
 		    ///@}
 		    ///\name Option Groups and Synonyms
 		    ///
 		    ///@{
 		    ///Bundle some options into a group
 		    /// You can group some option by calling this function repeatedly for each
 		    /// option to be grouped with the same groupname.
 		    ///\param group The group name.
 		    ///\param opt The option name.
 		    ArgParser &optionGroup(const std::string &group,
 					   const std::string &opt);
 		    ///Make the members of a group exclusive
 		    ///If you call this function for a group, than at most one of them can be
 		    ///given at the same time.
 		    ArgParser &onlyOneGroup(const std::string &group);
 		    ///Make a group mandatory

lemon/assert.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_ASSERT_H
 		#define LEMON_ASSERT_H
 		/// \ingroup exceptions
 		/// \file
 		/// \brief Extended assertion handling
 		#include <lemon/error.h>
 		namespace lemon {
 		  inline void assert_fail_log(const char *file, int line, const char *function,
 					      const char *message, const char *assertion)
+		  {
 		    std::cerr << file << ":" << line << ": ";
 		    if (function)
 		      std::cerr << function << ": ";
 		    std::cerr << message;
 		    if (assertion)
 		      std::cerr << " (assertion '" << assertion << "' failed)";
 		    std::cerr << std::endl;
+		  }
 		  inline void assert_fail_abort(const char *file, int line,
 						const char *function, const char* message,
 						const char *assertion)
+		  {
 		    assert_fail_log(file, line, function, message, assertion);
 		    std::abort();
+		  }
 		  namespace _assert_bits {
 		    inline const char* cstringify(const std::string& str) {
 		      return str.c_str();
+		    }
 		    inline const char* cstringify(const char* str) {
 		      return str;
+		    }
+		  }
+		}
 		#endif // LEMON_ASSERT_H
 		#undef LEMON_ASSERT
 		#undef LEMON_FIXME
 		#undef LEMON_DEBUG
 		#if (defined(LEMON_ASSERT_LOG) ? 1 : 0) +		\
 		  (defined(LEMON_ASSERT_ABORT) ? 1 : 0) +		\
 		  (defined(LEMON_ASSERT_CUSTOM) ? 1 : 0) > 1
 		#error "LEMON assertion system is not set properly"
 		#endif
 		#if ((defined(LEMON_ASSERT_LOG) ? 1 : 0) +		\
 		     (defined(LEMON_ASSERT_ABORT) ? 1 : 0) +		\
 		     (defined(LEMON_ASSERT_CUSTOM) ? 1 : 0) == 1 ||	\
 		     defined(LEMON_ENABLE_ASSERTS)) &&			\
 		  (defined(LEMON_DISABLE_ASSERTS) ||			\
 		   defined(NDEBUG))
 		#error "LEMON assertion system is not set properly"
 		#endif
 		#if defined LEMON_ASSERT_LOG
 		#  undef LEMON_ASSERT_HANDLER
 		#  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_log
 		#elif defined LEMON_ASSERT_ABORT
 		#  undef LEMON_ASSERT_HANDLER
 		#  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_abort
 		#elif defined LEMON_ASSERT_CUSTOM
 		#  undef LEMON_ASSERT_HANDLER
 		#  ifndef LEMON_CUSTOM_ASSERT_HANDLER
 		#    error "LEMON_CUSTOM_ASSERT_HANDLER is not set"
 		#  endif
 		#  define LEMON_ASSERT_HANDLER LEMON_CUSTOM_ASSERT_HANDLER
 		#elif defined LEMON_DISABLE_ASSERTS
 		#  undef LEMON_ASSERT_HANDLER
 		#elif defined NDEBUG
 		#  undef LEMON_ASSERT_HANDLER
 		#else
 		#  define LEMON_ASSERT_HANDLER ::lemon::assert_fail_abort
 		#endif
 		#ifndef LEMON_FUNCTION_NAME
 		#  if defined __GNUC__
 		#    define LEMON_FUNCTION_NAME (__PRETTY_FUNCTION__)
 		#  elif defined _MSC_VER
 		#    define LEMON_FUNCTION_NAME (__FUNCSIG__)
 		#  else
 		#    define LEMON_FUNCTION_NAME (__func__)
 		#  endif
 		#endif
 		#ifdef DOXYGEN
 		/// \ingroup exceptions
 		///
 		/// \brief Macro for assertion with customizable message
 		///
 		/// Macro for assertion with customizable message.  \param exp An
 		/// expression that must be convertible to \c bool.  If it is \c
 		/// false, then an assertion is raised. The concrete behaviour depends
 		/// on the settings of the assertion system.  \param msg A <tt>const
 		/// char*</tt> parameter, which can be used to provide information
 		/// about the circumstances of the failed assertion.
 		///
 		/// The assertions are enabled in the default behaviour.
 		/// You can disable them with the following code:
 		/// \code
 		/// #define LEMON_DISABLE_ASSERTS
 		/// \endcode
 		/// or with compilation parameters:
 		/// \code
 		/// g++ -DLEMON_DISABLE_ASSERTS
 		/// make CXXFLAGS='-DLEMON_DISABLE_ASSERTS'
 		/// \endcode
 		/// The checking is also disabled when the standard macro \c NDEBUG is defined.
 		///
 		/// The LEMON assertion system has a wide range of customization
 		/// properties. As a default behaviour the failed assertion prints a
 		/// short log message to the standard error and aborts the execution.
 		///
 		/// The following modes can be used in the assertion system:
 		///
 		/// - \c LEMON_ASSERT_LOG The failed assertion prints a short log
 		///   message to the standard error and continues the execution.
 		/// - \c LEMON_ASSERT_ABORT This mode is similar to the \c
 		///   LEMON_ASSERT_LOG, but it aborts the program. It is the default
 		///   behaviour.
 		/// - \c LEMON_ASSERT_CUSTOM The user can define own assertion handler
 		///   function.
 		///   \code
 		///     void custom_assert_handler(const char* file, int line, const char* function,
 		///                                const char* message, const char* assertion);
 		///   \endcode
 		///   The name of the function should be defined as the \c
 		///   LEMON_CUSTOM_ASSERT_HANDLER macro name.
 		///   \code
 		///     #define LEMON_CUSTOM_ASSERT_HANDLER custom_assert_handler
 		///   \endcode
 		///   Whenever an assertion is occured, the custom assertion
 		///   handler is called with appropiate parameters.
 		///
 		/// The assertion mode can also be changed within one compilation unit.
 		/// If the macros are redefined with other settings and the
 		/// \ref lemon/assert.h "assert.h" file is reincluded, then the
 		/// behaviour is changed appropiately to the new settings.
 		#  define LEMON_ASSERT(exp, msg)					\
 		  (static_cast<void> (!!(exp) ? 0 : (					\
 		    LEMON_ASSERT_HANDLER(__FILE__, __LINE__,				\
 					 LEMON_FUNCTION_NAME,				\
 					 ::lemon::_assert_bits::cstringify(msg), #exp), 0)))
 		/// \ingroup exceptions
 		///
 		/// \brief Macro for mark not yet implemented features.
 		///
 		/// Macro for mark not yet implemented features and outstanding bugs.
 		/// It is close to be the shortcut of the following code:
 		/// \code
 		///   LEMON_ASSERT(false, msg);
 		/// \endcode
 		///
 		/// \see LEMON_ASSERT
 		#  define LEMON_FIXME(msg)						\
 		  (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, LEMON_FUNCTION_NAME,	\
 					::lemon::_assert_bits::cstringify(msg),		\
 					static_cast<const char*>(0)))
 		/// \ingroup exceptions
 		///
 		/// \brief Macro for internal assertions
 		///
 		/// Macro for internal assertions, it is used in the library to check
 		/// the consistency of results of algorithms, several pre- and
 		/// postconditions and invariants. The checking is disabled by
 		/// default, but it can be turned on with the macro \c
 		/// LEMON_ENABLE_DEBUG.
 		/// \code
 		/// #define LEMON_ENABLE_DEBUG
 		/// \endcode
 		/// or with compilation parameters:
 		/// \code
 		/// g++ -DLEMON_ENABLE_DEBUG
 		/// make CXXFLAGS='-DLEMON_ENABLE_DEBUG'
 		/// \endcode
 		///
 		/// This macro works like the \c LEMON_ASSERT macro, therefore the
 		/// current behaviour depends on the settings of \c LEMON_ASSERT
 		/// macro.
 		///
 		/// \see LEMON_ASSERT
 		#  define LEMON_DEBUG(exp, msg)						\
 		  (static_cast<void> (!!(exp) ? 0 : (					\
 		    LEMON_ASSERT_HANDLER(__FILE__, __LINE__,                            \
 					 LEMON_FUNCTION_NAME,				\
 					 ::lemon::_assert_bits::cstringify(msg), #exp), 0)))
 		#else
 		#  ifndef LEMON_ASSERT_HANDLER
 		#    define LEMON_ASSERT(exp, msg)  (static_cast<void>(0))
 		#    define LEMON_FIXME(msg) (static_cast<void>(0))
 		#    define LEMON_DEBUG(exp, msg) (static_cast<void>(0))
 		#  else
 		#    define LEMON_ASSERT(exp, msg)					\
 		       (static_cast<void> (!!(exp) ? 0 : (				\
 		        LEMON_ASSERT_HANDLER(__FILE__, __LINE__,                        \
 					     LEMON_FUNCTION_NAME,			\
 					     ::lemon::_assert_bits::cstringify(msg),	\
 					     #exp), 0)))
 		#    define LEMON_FIXME(msg)						\
 		       (LEMON_ASSERT_HANDLER(__FILE__, __LINE__, LEMON_FUNCTION_NAME,	\
 					     ::lemon::_assert_bits::cstringify(msg),	\
 					     static_cast<const char*>(0)))
 		#    if LEMON_ENABLE_DEBUG
 		#      define LEMON_DEBUG(exp, msg)
 		         (static_cast<void> (!!(exp) ? 0 : (         \
 		           LEMON_ASSERT_HANDLER(__FILE__, __LINE__,  \
 		                                LEMON_FUNCTION_NAME, \
 						::lemon::_assert_bits::cstringify(msg),	\
 						#exp), 0)))
 		#    else
 		#      define LEMON_DEBUG(exp, msg) (static_cast<void>(0))
 		#    endif
 		#  endif
 		#endif
 		#ifdef DOXYGEN
 		#else
 		#endif

lemon/base.cc

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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.
+		 *
 		 */
 		///\file
 		///\brief Some basic non-inline functions and static global data.
 		#include<lemon/tolerance.h>
 		#include<lemon/bits/invalid.h>
 		namespace lemon {
 		  float Tolerance<float>::def_epsilon = 1e-4;
 		  double Tolerance<double>::def_epsilon = 1e-10;
 		  long double Tolerance<long double>::def_epsilon = 1e-14;
 		#ifndef LEMON_ONLY_TEMPLATES
 		  const Invalid INVALID = Invalid();
 		#endif
 		} //namespace lemon

lemon/bfs.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_BFS_H
 		#define LEMON_BFS_H
 		///\ingroup search
 		///\file
 		///\brief Bfs algorithm.
 		#include <lemon/list_graph.h>
 		#include <lemon/graph_utils.h>
 		#include <lemon/bits/path_dump.h>
 		#include <lemon/bits/invalid.h>
 		#include <lemon/error.h>
 		#include <lemon/maps.h>
 		namespace lemon {
 		  ///Default traits class of Bfs class.
 		  ///Default traits class of Bfs class.
 		  ///\tparam GR Digraph type.
 		  template<class GR>
 		  struct BfsDefaultTraits
+		  {
 		    ///The digraph type the algorithm runs on.
 		    typedef GR Digraph;
 		    ///\brief The type of the map that stores the last
 		    ///arcs of the shortest paths.
 		    ///
 		    ///The type of the map that stores the last
 		    ///arcs of the shortest paths.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///
 		    typedef typename Digraph::template NodeMap<typename GR::Arc> PredMap;
 		    ///Instantiates a PredMap.
 		    ///This function instantiates a \ref PredMap.
 		    ///\param G is the digraph, to which we would like to define the PredMap.
 		    ///\todo The digraph alone may be insufficient to initialize
 		    static PredMap *createPredMap(const GR &G)
+		    {
 		      return new PredMap(G);
+		    }
 		    ///The type of the map that indicates which nodes are processed.
 		    ///The type of the map that indicates which nodes are processed.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///\todo named parameter to set this type, function to read and write.
 		    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
 		    ///Instantiates a ProcessedMap.
 		    ///This function instantiates a \ref ProcessedMap.
 		    ///\param g is the digraph, to which
 		    ///we would like to define the \ref ProcessedMap
 		#ifdef DOXYGEN
 		    static ProcessedMap *createProcessedMap(const GR &g)
 		#else
 		    static ProcessedMap *createProcessedMap(const GR &)
 		#endif
+		    {
 		      return new ProcessedMap();
+		    }
 		    ///The type of the map that indicates which nodes are reached.
 		    ///The type of the map that indicates which nodes are reached.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///\todo named parameter to set this type, function to read and write.
 		    typedef typename Digraph::template NodeMap<bool> ReachedMap;
 		    ///Instantiates a ReachedMap.
 		    ///This function instantiates a \ref ReachedMap.
 		    ///\param G is the digraph, to which
 		    ///we would like to define the \ref ReachedMap.
 		    static ReachedMap *createReachedMap(const GR &G)
+		    {
 		      return new ReachedMap(G);
+		    }
 		    ///The type of the map that stores the dists of the nodes.
 		    ///The type of the map that stores the dists of the nodes.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///
 		    typedef typename Digraph::template NodeMap<int> DistMap;
 		    ///Instantiates a DistMap.
 		    ///This function instantiates a \ref DistMap.
 		    ///\param G is the digraph, to which we would like to define the \ref DistMap
 		    static DistMap *createDistMap(const GR &G)
+		    {
 		      return new DistMap(G);
+		    }
 		  };
 		  ///%BFS algorithm class.
 		  ///\ingroup search
 		  ///This class provides an efficient implementation of the %BFS algorithm.
 		  ///
 		  ///\tparam GR The digraph type the algorithm runs on. The default value is
 		  ///\ref ListDigraph. The value of GR is not used directly by Bfs, it
 		  ///is only passed to \ref BfsDefaultTraits.
 		  ///\tparam TR Traits class to set various data types used by the algorithm.
 		  ///The default traits class is
 		  ///\ref BfsDefaultTraits "BfsDefaultTraits<GR>".
 		  ///See \ref BfsDefaultTraits for the documentation of
 		  ///a Bfs traits class.
 		#ifdef DOXYGEN
 		  template <typename GR,
 			    typename TR>
 		#else
 		  template <typename GR=ListDigraph,
 			    typename TR=BfsDefaultTraits<GR> >
 		#endif
 		  class Bfs {
 		  public:
 		    /**
 		     * \brief \ref Exception for uninitialized parameters.
+		     *
 		     * This error represents problems in the initialization
 		     * of the parameters of the algorithms.
 		     */
 		    class UninitializedParameter : public lemon::UninitializedParameter {
 		    public:
 		      virtual const char* what() const throw() {
 			return "lemon::Bfs::UninitializedParameter";
+		      }
 		    };
 		    typedef TR Traits;
 		    ///The type of the underlying digraph.
 		    typedef typename TR::Digraph Digraph;
 		    ///\brief The type of the map that stores the last
 		    ///arcs of the shortest paths.
 		    typedef typename TR::PredMap PredMap;
 		    ///The type of the map indicating which nodes are reached.
 		    typedef typename TR::ReachedMap ReachedMap;
 		    ///The type of the map indicating which nodes are processed.
 		    typedef typename TR::ProcessedMap ProcessedMap;
 		    ///The type of the map that stores the dists of the nodes.
 		    typedef typename TR::DistMap DistMap;
 		  private:
 		    typedef typename Digraph::Node Node;
 		    typedef typename Digraph::NodeIt NodeIt;
 		    typedef typename Digraph::Arc Arc;
 		    typedef typename Digraph::OutArcIt OutArcIt;
 		    /// Pointer to the underlying digraph.
 		    const Digraph *G;
 		    ///Pointer to the map of predecessors arcs.
 		    PredMap *_pred;
 		    ///Indicates if \ref _pred is locally allocated (\c true) or not.
 		    bool local_pred;
 		    ///Pointer to the map of distances.
 		    DistMap *_dist;
 		    ///Indicates if \ref _dist is locally allocated (\c true) or not.
 		    bool local_dist;
 		    ///Pointer to the map of reached status of the nodes.
 		    ReachedMap *_reached;
 		    ///Indicates if \ref _reached is locally allocated (\c true) or not.
 		    bool local_reached;
 		    ///Pointer to the map of processed status of the nodes.
 		    ProcessedMap *_processed;
 		    ///Indicates if \ref _processed is locally allocated (\c true) or not.
 		    bool local_processed;
 		    std::vector<typename Digraph::Node> _queue;
 		    int _queue_head,_queue_tail,_queue_next_dist;
 		    int _curr_dist;
 		    ///Creates the maps if necessary.
 		    ///\todo Better memory allocation (instead of new).
 		    void create_maps()
+		    {
 		      if(!_pred) {
 			local_pred = true;
 			_pred = Traits::createPredMap(*G);
+		      }
 		      if(!_dist) {
 			local_dist = true;
 			_dist = Traits::createDistMap(*G);
+		      }
 		      if(!_reached) {
 			local_reached = true;
 			_reached = Traits::createReachedMap(*G);
+		      }
 		      if(!_processed) {
 			local_processed = true;
 			_processed = Traits::createProcessedMap(*G);
+		      }
+		    }
 		  protected:
 		    Bfs() {}
 		  public:
 		    typedef Bfs Create;
 		    ///\name Named template parameters
 		    ///@{
 		    template <class T>
 		    struct DefPredMapTraits : public Traits {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &)
+		      {
 			throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///PredMap type
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting PredMap type
 		    ///
 		    template <class T>
 		    struct DefPredMap : public Bfs< Digraph, DefPredMapTraits<T> > {
 		      typedef Bfs< Digraph, DefPredMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct DefDistMapTraits : public Traits {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &)
+		      {
 			throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///DistMap type
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting DistMap type
 		    ///
 		    template <class T>
 		    struct DefDistMap : public Bfs< Digraph, DefDistMapTraits<T> > {

lemon/bin_heap.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_BIN_HEAP_H
 		#define LEMON_BIN_HEAP_H
 		///\ingroup auxdat
 		///\file
 		///\brief Binary Heap implementation.
 		#include <vector>
 		#include <utility>
 		#include <functional>
 		namespace lemon {
 		  ///\ingroup auxdat
 		  ///
 		  ///\brief A Binary Heap implementation.
 		  ///
 		  ///This class implements the \e binary \e heap data structure. A \e heap
 		  ///is a data structure for storing items with specified values called \e
 		  ///priorities in such a way that finding the item with minimum priority is
 		  ///efficient. \c Compare specifies the ordering of the priorities. In a heap
 		  ///one can change the priority of an item, add or erase an item, etc.
 		  ///
 		  ///\tparam _Prio Type of the priority of the items.
 		  ///\tparam _ItemIntMap A read and writable Item int map, used internally
 		  ///to handle the cross references.
 		  ///\tparam _Compare A class for the ordering of the priorities. The
 		  ///default is \c std::less<_Prio>.
 		  ///
 		  ///\sa FibHeap
 		  ///\sa Dijkstra
 		  template <typename _Prio, typename _ItemIntMap,
 			    typename _Compare = std::less<_Prio> >
 		  class BinHeap {
 		  public:
 		    ///\e
 		    typedef _ItemIntMap ItemIntMap;
 		    ///\e
 		    typedef _Prio Prio;
 		    ///\e
 		    typedef typename ItemIntMap::Key Item;
 		    ///\e
 		    typedef std::pair<Item,Prio> Pair;
 		    ///\e
 		    typedef _Compare Compare;
 		    /// \brief Type to represent the items states.
 		    ///
 		    /// Each Item element have a state associated to it. It may be "in heap",
 		    /// "pre heap" or "post heap". The latter two are indifferent from the
 		    /// heap's point of view, but may be useful to the user.
 		    ///
 		    /// The ItemIntMap \e should be initialized in such way that it maps
 		    /// PRE_HEAP (-1) to any element to be put in the heap...
 		    enum State {
 		      IN_HEAP = 0,
 		      PRE_HEAP = -1,
 		      POST_HEAP = -2
 		    };
 		  private:
 		    std::vector<Pair> data;
 		    Compare comp;
 		    ItemIntMap &iim;
 		  public:
 		    /// \brief The constructor.
 		    ///
 		    /// The constructor.
 		    /// \param _iim should be given to the constructor, since it is used
 		    /// internally to handle the cross references. The value of the map
 		    /// should be PRE_HEAP (-1) for each element.
 		    explicit BinHeap(ItemIntMap &_iim) : iim(_iim) {}
 		    /// \brief The constructor.
 		    ///
 		    /// The constructor.
 		    /// \param _iim should be given to the constructor, since it is used
 		    /// internally to handle the cross references. The value of the map
 		    /// should be PRE_HEAP (-1) for each element.
 		    ///
 		    /// \param _comp The comparator function object.
 		    BinHeap(ItemIntMap &_iim, const Compare &_comp)
 		      : iim(_iim), comp(_comp) {}
 		    /// The number of items stored in the heap.
 		    ///
 		    /// \brief Returns the number of items stored in the heap.
 		    int size() const { return data.size(); }
 		    /// \brief Checks if the heap stores no items.
 		    ///
 		    /// Returns \c true if and only if the heap stores no items.
 		    bool empty() const { return data.empty(); }
 		    /// \brief Make empty this heap.
 		    ///
 		    /// Make empty this heap. It does not change the cross reference map.
 		    /// If you want to reuse what is not surely empty you should first clear
 		    /// the heap and after that you should set the cross reference map for
 		    /// each item to \c PRE_HEAP.
 		    void clear() {
 		      data.clear();
+		    }
 		  private:
 		    static int parent(int i) { return (i-1)/2; }
 		    static int second_child(int i) { return 2*i+2; }
 		    bool less(const Pair &p1, const Pair &p2) const {
 		      return comp(p1.second, p2.second);
+		    }
 		    int bubble_up(int hole, Pair p) {
 		      int par = parent(hole);
 		      while( hole>0 && less(p,data[par]) ) {
 			move(data[par],hole);
 			hole = par;
 			par = parent(hole);
+		      }
 		      move(p, hole);
 		      return hole;
+		    }
 		    int bubble_down(int hole, Pair p, int length) {
 		      int child = second_child(hole);
 		      while(child < length) {
 			if( less(data[child-1], data[child]) ) {
 			  --child;
+			}
 			if( !less(data[child], p) )
 			  goto ok;
 			move(data[child], hole);
 			hole = child;
 			child = second_child(hole);
+		      }
 		      child--;
 		      if( child<length && less(data[child], p) ) {
 			move(data[child], hole);
 			hole=child;
+		      }
 		    ok:
 		      move(p, hole);
 		      return hole;
+		    }
 		    void move(const Pair &p, int i) {
 		      data[i] = p;
 		      iim.set(p.first, i);
+		    }
 		  public:
 		    /// \brief Insert a pair of item and priority into the heap.
 		    ///
 		    /// Adds \c p.first to the heap with priority \c p.second.
 		    /// \param p The pair to insert.
 		    void push(const Pair &p) {
 		      int n = data.size();
 		      data.resize(n+1);
 		      bubble_up(n, p);
+		    }
 		    /// \brief Insert an item into the heap with the given heap.
 		    ///
 		    /// Adds \c i to the heap with priority \c p.
 		    /// \param i The item to insert.
 		    /// \param p The priority of the item.
 		    void push(const Item &i, const Prio &p) { push(Pair(i,p)); }
 		    /// \brief Returns the item with minimum priority relative to \c Compare.
 		    ///
 		    /// This method returns the item with minimum priority relative to \c
 		    /// Compare.
 		    /// \pre The heap must be nonempty.
 		    Item top() const {
 		      return data[0].first;
+		    }
 		    /// \brief Returns the minimum priority relative to \c Compare.
 		    ///
 		    /// It returns the minimum priority relative to \c Compare.
 		    /// \pre The heap must be nonempty.
 		    Prio prio() const {
 		      return data[0].second;
+		    }
 		    /// \brief Deletes the item with minimum priority relative to \c Compare.
 		    ///
 		    /// This method deletes the item with minimum priority relative to \c
 		    /// Compare from the heap.
 		    /// \pre The heap must be non-empty.
 		    void pop() {
 		      int n = data.size()-1;
 		      iim.set(data[0].first, POST_HEAP);
 		      if (n > 0) {
 			bubble_down(0, data[n], n);
+		      }
 		      data.pop_back();
+		    }
 		    /// \brief Deletes \c i from the heap.
 		    ///
 		    /// This method deletes item \c i from the heap.
 		    /// \param i The item to erase.
 		    /// \pre The item should be in the heap.
 		    void erase(const Item &i) {
 		      int h = iim[i];
 		      int n = data.size()-1;
 		      iim.set(data[h].first, POST_HEAP);
 		      if( h < n ) {
 			if ( bubble_up(h, data[n]) == h) {
 			  bubble_down(h, data[n], n);
+			}
+		      }
 		      data.pop_back();
+		    }
 		    /// \brief Returns the priority of \c i.
 		    ///
 		    /// This function returns the priority of item \c i.
 		    /// \pre \c i must be in the heap.
 		    /// \param i The item.
 		    Prio operator[](const Item &i) const {
 		      int idx = iim[i];
 		      return data[idx].second;
+		    }
 		    /// \brief \c i gets to the heap with priority \c p independently
 		    /// if \c i was already there.
 		    ///
 		    /// This method calls \ref push(\c i, \c p) if \c i is not stored
 		    /// in the heap and sets the priority of \c i to \c p otherwise.
 		    /// \param i The item.
 		    /// \param p The priority.
 		    void set(const Item &i, const Prio &p) {
 		      int idx = iim[i];
 		      if( idx < 0 ) {
 			push(i,p);

lemon/bits/alteration_notifier.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_BITS_ALTERATION_NOTIFIER_H
 		#define LEMON_BITS_ALTERATION_NOTIFIER_H
 		#include <vector>
 		#include <list>
 		#include <lemon/bits/utility.h>
 		///\ingroup graphbits
 		///\file
 		///\brief Observer notifier for graph alteration observers.
 		namespace lemon {
 		  /// \ingroup graphbits
 		  ///
 		  /// \brief Notifier class to notify observes about alterations in
 		  /// a container.
 		  ///
 		  /// The simple graph's can be refered as two containers, one node container
 		  /// and one edge container. But they are not standard containers they
 		  /// does not store values directly they are just key continars for more
 		  /// value containers which are the node and edge maps.
 		  ///
 		  /// The graph's node and edge sets can be changed as we add or erase
 		  /// nodes and edges in the graph. Lemon would like to handle easily
 		  /// that the node and edge maps should contain values for all nodes or
 		  /// edges. If we want to check on every indicing if the map contains
 		  /// the current indicing key that cause a drawback in the performance
 		  /// in the library. We use another solution we notify all maps about
 		  /// an alteration in the graph, which cause only drawback on the
 		  /// alteration of the graph.
 		  ///
 		  /// This class provides an interface to the container. The \e first() and \e
 		  /// next() member functions make possible to iterate on the keys of the
 		  /// container. The \e id() function returns an integer id for each key.
 		  /// The \e maxId() function gives back an upper bound of the ids.
 		  ///
 		  /// For the proper functonality of this class, we should notify it
 		  /// about each alteration in the container. The alterations have four type
 		  /// as \e add(), \e erase(), \e build() and \e clear(). The \e add() and
 		  /// \e erase() signals that only one or few items added or erased to or
 		  /// from the graph. If all items are erased from the graph or from an empty
 		  /// graph a new graph is builded then it can be signaled with the
 		  /// clear() and build() members. Important rule that if we erase items
 		  /// from graph we should first signal the alteration and after that erase
 		  /// them from the container, on the other way on item addition we should
 		  /// first extend the container and just after that signal the alteration.
 		  ///
 		  /// The alteration can be observed with a class inherited from the
 		  /// \e ObserverBase nested class. The signals can be handled with
 		  /// overriding the virtual functions defined in the base class.  The
 		  /// observer base can be attached to the notifier with the
 		  /// \e attach() member and can be detached with detach() function. The
 		  /// alteration handlers should not call any function which signals
 		  /// an other alteration in the same notifier and should not
 		  /// detach any observer from the notifier.
 		  ///
 		  /// Alteration observers try to be exception safe. If an \e add() or
 		  /// a \e clear() function throws an exception then the remaining
 		  /// observeres will not be notified and the fulfilled additions will
 		  /// be rolled back by calling the \e erase() or \e clear()
 		  /// functions. Thence the \e erase() and \e clear() should not throw
 		  /// exception. Actullay, it can be throw only
 		  /// \ref AlterationObserver::ImmediateDetach ImmediateDetach
 		  /// exception which detach the observer from the notifier.
 		  ///
 		  /// There are some place when the alteration observing is not completly
 		  /// reliable. If we want to carry out the node degree in the graph
 		  /// as in the \ref InDegMap and we use the reverseEdge that cause
 		  /// unreliable functionality. Because the alteration observing signals
 		  /// only erasing and adding but not the reversing it will stores bad
 		  /// degrees. The sub graph adaptors cannot signal the alterations because
 		  /// just a setting in the filter map can modify the graph and this cannot
 		  /// be watched in any way.
 		  ///
 		  /// \param _Container The container which is observed.
 		  /// \param _Item The item type which is obserbved.
 		  template <typename _Container, typename _Item>
 		  class AlterationNotifier {
 		  public:
 		    typedef True Notifier;
 		    typedef _Container Container;
 		    typedef _Item Item;
 		    /// \brief Exception which can be called from \e clear() and
 		    /// \e erase().
 		    ///
 		    /// From the \e clear() and \e erase() function only this
 		    /// exception is allowed to throw. The exception immediatly
 		    /// detaches the current observer from the notifier. Because the
 		    /// \e clear() and \e erase() should not throw other exceptions
 		    /// it can be used to invalidate the observer.
 		    struct ImmediateDetach {};
 		    /// \brief ObserverBase is the base class for the observers.
 		    ///
 		    /// ObserverBase is the abstract base class for the observers.
 		    /// It will be notified about an item was inserted into or
 		    /// erased from the graph.
 		    ///
 		    /// The observer interface contains some pure virtual functions
 		    /// to override. The add() and erase() functions are
 		    /// to notify the oberver when one item is added or
 		    /// erased.
 		    ///
 		    /// The build() and clear() members are to notify the observer
 		    /// about the container is built from an empty container or
 		    /// is cleared to an empty container.
 		    class ObserverBase {
 		    protected:
 		      typedef AlterationNotifier Notifier;
 		      friend class AlterationNotifier;
 		      /// \brief Default constructor.
 		      ///
 		      /// Default constructor for ObserverBase.
 		      ///
 		      ObserverBase() : _notifier(0) {}
 		      /// \brief Constructor which attach the observer into notifier.
 		      ///
 		      /// Constructor which attach the observer into notifier.
 		      ObserverBase(AlterationNotifier& nf) {
 		        attach(nf);
+		      }
 		      /// \brief Constructor which attach the obserever to the same notifier.
 		      ///
 		      /// Constructor which attach the obserever to the same notifier as
 		      /// the other observer is attached to.
 		      ObserverBase(const ObserverBase& copy) {
 			if (copy.attached()) {
 		          attach(*copy.notifier());
+			}
+		      }
 		      /// \brief Destructor
 		      virtual ~ObserverBase() {
 		        if (attached()) {
 		          detach();
+		        }
+		      }
 		      /// \brief Attaches the observer into an AlterationNotifier.
 		      ///
 		      /// This member attaches the observer into an AlterationNotifier.
 		      ///
 		      void attach(AlterationNotifier& nf) {
 			nf.attach(*this);
+		      }
 		      /// \brief Detaches the observer into an AlterationNotifier.
 		      ///
 		      /// This member detaches the observer from an AlterationNotifier.
 		      ///
 		      void detach() {
 		        _notifier->detach(*this);
+		      }
 		      /// \brief Gives back a pointer to the notifier which the map
 		      /// attached into.
 		      ///
 		      /// This function gives back a pointer to the notifier which the map
 		      /// attached into.
 		      ///
 		      Notifier* notifier() const { return const_cast<Notifier*>(_notifier); }
 		      /// Gives back true when the observer is attached into a notifier.
 		      bool attached() const { return _notifier != 0; }
 		    private:
 		      ObserverBase& operator=(const ObserverBase& copy);
 		    protected:
 		      Notifier* _notifier;
 		      typename std::list<ObserverBase*>::iterator _index;
 		      /// \brief The member function to notificate the observer about an
 		      /// item is added to the container.
 		      ///
 		      /// The add() member function notificates the observer about an item
 		      /// is added to the container. It have to be overrided in the
 		      /// subclasses.
 		      virtual void add(const Item&) = 0;
 		      /// \brief The member function to notificate the observer about
 		      /// more item is added to the container.
 		      ///
 		      /// The add() member function notificates the observer about more item
 		      /// is added to the container. It have to be overrided in the
 		      /// subclasses.
 		      virtual void add(const std::vector<Item>& items) = 0;
 		      /// \brief The member function to notificate the observer about an
 		      /// item is erased from the container.
 		      ///
 		      /// The erase() member function notificates the observer about an
 		      /// item is erased from the container. It have to be overrided in
 		      /// the subclasses.
 		      virtual void erase(const Item&) = 0;
 		      /// \brief The member function to notificate the observer about
 		      /// more item is erased from the container.
 		      ///
 		      /// The erase() member function notificates the observer about more item
 		      /// is erased from the container. It have to be overrided in the
 		      /// subclasses.
 		      virtual void erase(const std::vector<Item>& items) = 0;
 		      /// \brief The member function to notificate the observer about the
 		      /// container is built.
 		      ///
 		      /// The build() member function notificates the observer about the
 		      /// container is built from an empty container. It have to be
 		      /// overrided in the subclasses.
 		      virtual void build() = 0;
 		      /// \brief The member function to notificate the observer about all
 		      /// items are erased from the container.
 		      ///
 		      /// The clear() member function notificates the observer about all
 		      /// items are erased from the container. It have to be overrided in
 		      /// the subclasses.
 		      virtual void clear() = 0;
 		    };
 		  protected:
 		    const Container* container;
 		    typedef std::list<ObserverBase*> Observers;

lemon/bits/array_map.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_BITS_ARRAY_MAP_H
 		#define LEMON_BITS_ARRAY_MAP_H
 		#include <memory>
 		#include <lemon/bits/traits.h>
 		#include <lemon/bits/alteration_notifier.h>
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/maps.h>
 		/// \ingroup graphbits
 		/// \file
 		/// \brief Graph map based on the array storage.
 		namespace lemon {
 		  /// \ingroup graphbits
 		  ///
 		  /// \brief Graph map based on the array storage.
 		  ///
 		  /// The ArrayMap template class is graph map structure what
 		  /// automatically updates the map when a key is added to or erased from
 		  /// the map. This map uses the allocators to implement
 		  /// the container functionality.
 		  ///
 		  /// The template parameters are the Graph the current Item type and
 		  /// the Value type of the map.
 		  template <typename _Graph, typename _Item, typename _Value>
 		  class ArrayMap
 		    : public ItemSetTraits<_Graph, _Item>::ItemNotifier::ObserverBase {
 		  public:
 		    /// The graph type of the maps.
 		    typedef _Graph Graph;
 		    /// The item type of the map.
 		    typedef _Item Item;
 		    /// The reference map tag.
 		    typedef True ReferenceMapTag;
 		    /// The key type of the maps.
 		    typedef _Item Key;
 		    /// The value type of the map.
 		    typedef _Value Value;
 		    /// The const reference type of the map.
 		    typedef const _Value& ConstReference;
 		    /// The reference type of the map.
 		    typedef _Value& Reference;
 		    /// The notifier type.
 		    typedef typename ItemSetTraits<_Graph, _Item>::ItemNotifier Notifier;
 		    /// The MapBase of the Map which imlements the core regisitry function.
 		    typedef typename Notifier::ObserverBase Parent;
 		  private:
 		    typedef std::allocator<Value> Allocator;
 		  public:
 		    /// \brief Graph initialized map constructor.
 		    ///
 		    /// Graph initialized map constructor.
 		    explicit ArrayMap(const Graph& graph) {
 		      Parent::attach(graph.notifier(Item()));
 		      allocate_memory();
 		      Notifier* nf = Parent::notifier();
 		      Item it;
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 			int id = nf->id(it);;
 			allocator.construct(&(values[id]), Value());
+		      }
+		    }
 		    /// \brief Constructor to use default value to initialize the map.
 		    ///
 		    /// It constructs a map and initialize all of the the map.
 		    ArrayMap(const Graph& graph, const Value& value) {
 		      Parent::attach(graph.notifier(Item()));
 		      allocate_memory();
 		      Notifier* nf = Parent::notifier();
 		      Item it;
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 			int id = nf->id(it);;
 			allocator.construct(&(values[id]), value);
+		      }
+		    }
 		    /// \brief Constructor to copy a map of the same map type.
 		    ///
 		    /// Constructor to copy a map of the same map type.
 		    ArrayMap(const ArrayMap& copy) : Parent() {
 		      if (copy.attached()) {
 			attach(*copy.notifier());
+		      }
 		      capacity = copy.capacity;
 		      if (capacity == 0) return;
 		      values = allocator.allocate(capacity);
 		      Notifier* nf = Parent::notifier();
 		      Item it;
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 			int id = nf->id(it);;
 			allocator.construct(&(values[id]), copy.values[id]);
+		      }
+		    }
 		    /// \brief Assign operator.
 		    ///
 		    /// This operator assigns for each item in the map the
 		    /// value mapped to the same item in the copied map.
 		    /// The parameter map should be indiced with the same
 		    /// itemset because this assign operator does not change
 		    /// the container of the map.
 		    ArrayMap& operator=(const ArrayMap& cmap) {
 		      return operator=<ArrayMap>(cmap);
+		    }
 		    /// \brief Template assign operator.
 		    ///
 		    /// The given parameter should be conform to the ReadMap
 		    /// concecpt and could be indiced by the current item set of
 		    /// the NodeMap. In this case the value for each item
 		    /// is assigned by the value of the given ReadMap.
 		    template <typename CMap>
 		    ArrayMap& operator=(const CMap& cmap) {
 		      checkConcept<concepts::ReadMap<Key, _Value>, CMap>();
 		      const typename Parent::Notifier* nf = Parent::notifier();
 		      Item it;
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 		        set(it, cmap[it]);
+		      }
 		      return *this;
+		    }
 		    /// \brief The destructor of the map.
 		    ///
 		    /// The destructor of the map.
 		    virtual ~ArrayMap() {
 		      if (attached()) {
 			clear();
 			detach();
+		      }
+		    }
 		  protected:
 		    using Parent::attach;
 		    using Parent::detach;
 		    using Parent::attached;
 		  public:
 		    /// \brief The subscript operator.
 		    ///
 		    /// The subscript operator. The map can be subscripted by the
 		    /// actual keys of the graph.
 		    Value& operator[](const Key& key) {
 		      int id = Parent::notifier()->id(key);
 		      return values[id];
+		    }
 		    /// \brief The const subscript operator.
 		    ///
 		    /// The const subscript operator. The map can be subscripted by the
 		    /// actual keys of the graph.
 		    const Value& operator[](const Key& key) const {
 		      int id = Parent::notifier()->id(key);
 		      return values[id];
+		    }
 		    /// \brief Setter function of the map.
 		    ///
 		    /// Setter function of the map. Equivalent with map[key] = val.
 		    /// This is a compatibility feature with the not dereferable maps.
 		    void set(const Key& key, const Value& val) {
 		      (*this)[key] = val;
+		    }
 		  protected:
 		    /// \brief Adds a new key to the map.
 		    ///
 		    /// It adds a new key to the map. It called by the observer notifier
 		    /// and it overrides the add() member function of the observer base.
 		    virtual void add(const Key& key) {
 		      Notifier* nf = Parent::notifier();
 		      int id = nf->id(key);
 		      if (id >= capacity) {
 			int new_capacity = (capacity == 0 ? 1 : capacity);
 			while (new_capacity <= id) {
 			  new_capacity <<= 1;
+			}
 			Value* new_values = allocator.allocate(new_capacity);
 			Item it;
 			for (nf->first(it); it != INVALID; nf->next(it)) {
 			  int jd = nf->id(it);;
 			  if (id != jd) {
 			    allocator.construct(&(new_values[jd]), values[jd]);
 			    allocator.destroy(&(values[jd]));
+			  }
+			}
 			if (capacity != 0) allocator.deallocate(values, capacity);
 			values = new_values;
 			capacity = new_capacity;
+		      }
 		      allocator.construct(&(values[id]), Value());
+		    }
 		    /// \brief Adds more new keys to the map.
 		    ///
 		    /// It adds more new keys to the map. It called by the observer notifier
 		    /// and it overrides the add() member function of the observer base.
 		    virtual void add(const std::vector<Key>& keys) {
 		      Notifier* nf = Parent::notifier();
 		      int max_id = -1;
 		      for (int i = 0; i < int(keys.size()); ++i) {
 			int id = nf->id(keys[i]);
 			if (id > max_id) {
 			  max_id = id;
+			}
+		      }
 		      if (max_id >= capacity) {
 			int new_capacity = (capacity == 0 ? 1 : capacity);
 			while (new_capacity <= max_id) {
 			  new_capacity <<= 1;
+			}
 			Value* new_values = allocator.allocate(new_capacity);
 			Item it;
 			for (nf->first(it); it != INVALID; nf->next(it)) {
 			  int id = nf->id(it);
 			  bool found = false;
 			  for (int i = 0; i < int(keys.size()); ++i) {
 			    int jd = nf->id(keys[i]);
 			    if (id == jd) {
 			      found = true;
 			      break;
+			    }
+			  }
 			  if (found) continue;
 			  allocator.construct(&(new_values[id]), values[id]);
 			  allocator.destroy(&(values[id]));

lemon/bits/base_extender.h

Show inline comments

/* -*- C++ -*-
/* -*- mode: C++; indent-tabs-mode: nil; -*-
 *
 * This file is a part of LEMON, a generic C++ optimization library
 * This file is a part of LEMON, a generic C++ optimization library.
 *
 * Copyright (C) 2003-2008
 * 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_BITS_BASE_EXTENDER_H
#define LEMON_BITS_BASE_EXTENDER_H

#include <lemon/bits/invalid.h>
#include <lemon/error.h>

#include <lemon/bits/map_extender.h>
#include <lemon/bits/default_map.h>

#include <lemon/concept_check.h>
#include <lemon/concepts/maps.h>

///\ingroup digraphbits
///\file
///\brief Extenders for the digraph types
namespace lemon {

  /// \ingroup digraphbits
  ///
  /// \brief BaseDigraph to BaseGraph extender
  template <typename Base>
  class UndirDigraphExtender : public Base {

  public:

    typedef Base Parent;
    typedef typename Parent::Arc Edge;
    typedef typename Parent::Node Node;

    typedef True UndirectedTag;

    class Arc : public Edge {
      friend class UndirDigraphExtender;

    protected:
      bool forward;

      Arc(const Edge &ue, bool _forward) :
        Edge(ue), forward(_forward) {}

    public:
      Arc() {}

      /// Invalid arc constructor
      Arc(Invalid i) : Edge(i), forward(true) {}

      bool operator==(const Arc &that) const {
	return forward==that.forward && Edge(*this)==Edge(that);
      }
      bool operator!=(const Arc &that) const {
	return forward!=that.forward || Edge(*this)!=Edge(that);
      }
      bool operator<(const Arc &that) const {
	return forward<that.forward ||
	  (!(that.forward<forward) && Edge(*this)<Edge(that));
      }
    };



    using Parent::source;

    /// Source of the given Arc.
    Node source(const Arc &e) const {
      return e.forward ? Parent::source(e) : Parent::target(e);
    }

    using Parent::target;

    /// Target of the given Arc.
    Node target(const Arc &e) const {
      return e.forward ? Parent::target(e) : Parent::source(e);
    }

    /// \brief Directed arc from an edge.
    ///
    /// Returns a directed arc corresponding to the specified Edge.
    /// If the given bool is true the given edge and the
    /// returned arc have the same source node.
    static Arc direct(const Edge &ue, bool d) {
      return Arc(ue, d);
    }

    /// Returns whether the given directed arc is same orientation as the
    /// corresponding edge.
    ///
    /// \todo reference to the corresponding point of the undirected digraph
    /// concept. "What does the direction of an edge mean?"
    static bool direction(const Arc &e) { return e.forward; }


    using Parent::first;
    using Parent::next;

    void first(Arc &e) const {
      Parent::first(e);
      e.forward=true;
    }

    void next(Arc &e) const {
      if( e.forward ) {
	e.forward = false;
      }
      else {
	Parent::next(e);
	e.forward = true;
      }
    }

    void firstOut(Arc &e, const Node &n) const {
      Parent::firstIn(e,n);
      if( Edge(e) != INVALID ) {
	e.forward = false;
      }
      else {
	Parent::firstOut(e,n);
	e.forward = true;
      }
    }
    void nextOut(Arc &e) const {
      if( ! e.forward ) {
	Node n = Parent::target(e);
	Parent::nextIn(e);
	if( Edge(e) == INVALID ) {
	  Parent::firstOut(e, n);
	  e.forward = true;
	}
      }
      else {
	Parent::nextOut(e);
      }
    }

    void firstIn(Arc &e, const Node &n) const {
      Parent::firstOut(e,n);
      if( Edge(e) != INVALID ) {
	e.forward = false;
      }
      else {
	Parent::firstIn(e,n);
	e.forward = true;
      }
    }
    void nextIn(Arc &e) const {
      if( ! e.forward ) {
	Node n = Parent::source(e);
	Parent::nextOut(e);
	if( Edge(e) == INVALID ) {
	  Parent::firstIn(e, n);
	  e.forward = true;
	}
      }
      else {
	Parent::nextIn(e);
      }
    }

    void firstInc(Edge &e, bool &d, const Node &n) const {
      d = true;
      Parent::firstOut(e, n);
      if (e != INVALID) return;
      d = false;
      Parent::firstIn(e, n);
    }

    void nextInc(Edge &e, bool &d) const {
      if (d) {
	Node s = Parent::source(e);
	Parent::nextOut(e);
	if (e != INVALID) return;
	d = false;
	Parent::firstIn(e, s);
      } else {
	Parent::nextIn(e);
      }
    }

    Node nodeFromId(int ix) const {
      return Parent::nodeFromId(ix);
    }

    Arc arcFromId(int ix) const {
      return direct(Parent::arcFromId(ix >> 1), bool(ix & 1));
    }

    Edge edgeFromId(int ix) const {
      return Parent::arcFromId(ix);
    }

    int id(const Node &n) const {
      return Parent::id(n);
    }

    int id(const Edge &e) const {
      return Parent::id(e);
    }

    int id(const Arc &e) const {
      return 2 * Parent::id(e) + int(e.forward);
    }

    int maxNodeId() const {
      return Parent::maxNodeId();
    }

    int maxArcId() const {
      return 2 * Parent::maxArcId() + 1;
    }

    int maxEdgeId() const {
      return Parent::maxArcId();
    }


    int arcNum() const {
      return 2 * Parent::arcNum();
    }

    int edgeNum() const {
      return Parent::arcNum();
    }

    Arc findArc(Node s, Node t, Arc p = INVALID) const {
      if (p == INVALID) {
	Edge arc = Parent::findArc(s, t);
	if (arc != INVALID) return direct(arc, true);
	arc = Parent::findArc(t, s);
	if (arc != INVALID) return direct(arc, false);
      } else if (direction(p)) {
	Edge arc = Parent::findArc(s, t, p);
	if (arc != INVALID) return direct(arc, true);
	arc = Parent::findArc(t, s);
	if (arc != INVALID) return direct(arc, false);	
      } else {
	Edge arc = Parent::findArc(t, s, p);
	if (arc != INVALID) return direct(arc, false);	      
      }
      return INVALID;
    }

    Edge findEdge(Node s, Node t, Edge p = INVALID) const {

lemon/bits/bezier.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_BEZIER_H
 		#define LEMON_BEZIER_H
 		///\ingroup misc
 		///\file
 		///\brief Classes to compute with Bezier curves.
 		///
 		///Up to now this file is used internally by \ref graph_to_eps.h
 		#include<lemon/dim2.h>
 		namespace lemon {
 		  namespace dim2 {
 		class BezierBase {
 		public:
 		  typedef lemon::dim2::Point<double> Point;
 		protected:
 		  static Point conv(Point x,Point y,double t) {return (1-t)*x+t*y;}
 		};
 		class Bezier1 : public BezierBase
+		{
 		public:
 		  Point p1,p2;
 		  Bezier1() {}
 		  Bezier1(Point _p1, Point _p2) :p1(_p1), p2(_p2) {}
 		  Point operator()(double t) const
+		  {
 		    //    return conv(conv(p1,p2,t),conv(p2,p3,t),t);
 		    return conv(p1,p2,t);
+		  }
 		  Bezier1 before(double t) const
+		  {
 		    return Bezier1(p1,conv(p1,p2,t));
+		  }
 		  Bezier1 after(double t) const
+		  {
 		    return Bezier1(conv(p1,p2,t),p2);
+		  }
 		  Bezier1 revert() const { return Bezier1(p2,p1);}
 		  Bezier1 operator()(double a,double b) const { return before(b).after(a/b); }
 		  Point grad() const { return p2-p1; }
 		  Point norm() const { return rot90(p2-p1); }
 		  Point grad(double) const { return grad(); }
 		  Point norm(double t) const { return rot90(grad(t)); }
 		};
 		class Bezier2 : public BezierBase
+		{
 		public:
 		  Point p1,p2,p3;
 		  Bezier2() {}
 		  Bezier2(Point _p1, Point _p2, Point _p3) :p1(_p1), p2(_p2), p3(_p3) {}
 		  Bezier2(const Bezier1 &b) : p1(b.p1), p2(conv(b.p1,b.p2,.5)), p3(b.p2) {}
 		  Point operator()(double t) const
+		  {
 		    //    return conv(conv(p1,p2,t),conv(p2,p3,t),t);
 		    return ((1-t)*(1-t))*p1+(2*(1-t)*t)*p2+(t*t)*p3;
+		  }
 		  Bezier2 before(double t) const
+		  {
 		    Point q(conv(p1,p2,t));
 		    Point r(conv(p2,p3,t));
 		    return Bezier2(p1,q,conv(q,r,t));
+		  }
 		  Bezier2 after(double t) const
+		  {
 		    Point q(conv(p1,p2,t));
 		    Point r(conv(p2,p3,t));
 		    return Bezier2(conv(q,r,t),r,p3);
+		  }
 		  Bezier2 revert() const { return Bezier2(p3,p2,p1);}
 		  Bezier2 operator()(double a,double b) const { return before(b).after(a/b); }
 		  Bezier1 grad() const { return Bezier1(2.0*(p2-p1),2.0*(p3-p2)); }
 		  Bezier1 norm() const { return Bezier1(2.0*rot90(p2-p1),2.0*rot90(p3-p2)); }
 		  Point grad(double t) const { return grad()(t); }
 		  Point norm(double t) const { return rot90(grad(t)); }
 		};
 		class Bezier3 : public BezierBase
+		{
 		public:
 		  Point p1,p2,p3,p4;
 		  Bezier3() {}
 		  Bezier3(Point _p1, Point _p2, Point _p3, Point _p4)
 		    : p1(_p1), p2(_p2), p3(_p3), p4(_p4) {}
 		  Bezier3(const Bezier1 &b) : p1(b.p1), p2(conv(b.p1,b.p2,1.0/3.0)),
 					      p3(conv(b.p1,b.p2,2.0/3.0)), p4(b.p2) {}
 		  Bezier3(const Bezier2 &b) : p1(b.p1), p2(conv(b.p1,b.p2,2.0/3.0)),
 					      p3(conv(b.p2,b.p3,1.0/3.0)), p4(b.p3) {}
 		  Point operator()(double t) const
+		    {
 		      //    return Bezier2(conv(p1,p2,t),conv(p2,p3,t),conv(p3,p4,t))(t);
 		      return ((1-t)*(1-t)*(1-t))*p1+(3*t*(1-t)*(1-t))*p2+
 			(3*t*t*(1-t))*p3+(t*t*t)*p4;
+		    }
 		  Bezier3 before(double t) const
+		    {
 		      Point p(conv(p1,p2,t));
 		      Point q(conv(p2,p3,t));
 		      Point r(conv(p3,p4,t));
 		      Point a(conv(p,q,t));
 		      Point b(conv(q,r,t));
 		      Point c(conv(a,b,t));
 		      return Bezier3(p1,p,a,c);
+		    }
 		  Bezier3 after(double t) const
+		    {
 		      Point p(conv(p1,p2,t));
 		      Point q(conv(p2,p3,t));
 		      Point r(conv(p3,p4,t));
 		      Point a(conv(p,q,t));
 		      Point b(conv(q,r,t));
 		      Point c(conv(a,b,t));
 		      return Bezier3(c,b,r,p4);
+		    }
 		  Bezier3 revert() const { return Bezier3(p4,p3,p2,p1);}
 		  Bezier3 operator()(double a,double b) const { return before(b).after(a/b); }
 		  Bezier2 grad() const { return Bezier2(3.0*(p2-p1),3.0*(p3-p2),3.0*(p4-p3)); }
 		  Bezier2 norm() const { return Bezier2(3.0*rot90(p2-p1),
 .0*rot90(p3-p2),
 .0*rot90(p4-p3)); }
 		  Point grad(double t) const { return grad()(t); }
 		  Point norm(double t) const { return rot90(grad(t)); }
 		  template<class R,class F,class S,class D>
 		  R recSplit(F &_f,const S &_s,D _d) const
+		  {
 		    const Point a=(p1+p2)/2;
 		    const Point b=(p2+p3)/2;
 		    const Point c=(p3+p4)/2;
 		    const Point d=(a+b)/2;
 		    const Point e=(b+c)/2;
 		    const Point f=(d+e)/2;
 		    R f1=_f(Bezier3(p1,a,d,e),_d);
 		    R f2=_f(Bezier3(e,d,c,p4),_d);
 		    return _s(f1,f2);
+		  }
 		};
 		} //END OF NAMESPACE dim2
 		} //END OF NAMESPACE lemon
 		#endif // LEMON_BEZIER_H

lemon/bits/default_map.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_BITS_DEFAULT_MAP_H
 		#define LEMON_BITS_DEFAULT_MAP_H
 		#include <lemon/bits/array_map.h>
 		#include <lemon/bits/vector_map.h>
 		//#include <lemon/bits/debug_map.h>
 		///\ingroup graphbits
 		///\file
 		///\brief Graph maps that construct and destruct their elements dynamically.
 		namespace lemon {
 		  //#ifndef LEMON_USE_DEBUG_MAP
 		  template <typename _Graph, typename _Item, typename _Value>
 		  struct DefaultMapSelector {
 		    typedef ArrayMap<_Graph, _Item, _Value> Map;
 		  };
 		  // bool
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, bool> {
 		    typedef VectorMap<_Graph, _Item, bool> Map;
 		  };
 		  // char
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, char> {
 		    typedef VectorMap<_Graph, _Item, char> Map;
 		  };
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, signed char> {
 		    typedef VectorMap<_Graph, _Item, signed char> Map;
 		  };
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, unsigned char> {
 		    typedef VectorMap<_Graph, _Item, unsigned char> Map;
 		  };
 		  // int
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, signed int> {
 		    typedef VectorMap<_Graph, _Item, signed int> Map;
 		  };
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, unsigned int> {
 		    typedef VectorMap<_Graph, _Item, unsigned int> Map;
 		  };
 		  // short
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, signed short> {
 		    typedef VectorMap<_Graph, _Item, signed short> Map;
 		  };
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, unsigned short> {
 		    typedef VectorMap<_Graph, _Item, unsigned short> Map;
 		  };
 		  // long
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, signed long> {
 		    typedef VectorMap<_Graph, _Item, signed long> Map;
 		  };
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, unsigned long> {
 		    typedef VectorMap<_Graph, _Item, unsigned long> Map;
 		  };
 		#if defined __GNUC__ && !defined __STRICT_ANSI__
 		  // long long
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, signed long long> {
 		    typedef VectorMap<_Graph, _Item, signed long long> Map;
 		  };
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, unsigned long long> {
 		    typedef VectorMap<_Graph, _Item, unsigned long long> Map;
 		  };
 		#endif
 		  // float
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, float> {
 		    typedef VectorMap<_Graph, _Item, float> Map;
 		  };
 		  // double
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, double> {
 		    typedef VectorMap<_Graph, _Item,  double> Map;
 		  };
 		  // long double
 		  template <typename _Graph, typename _Item>
 		  struct DefaultMapSelector<_Graph, _Item, long double> {
 		    typedef VectorMap<_Graph, _Item, long double> Map;
 		  };
 		  // pointer
 		  template <typename _Graph, typename _Item, typename _Ptr>
 		  struct DefaultMapSelector<_Graph, _Item, _Ptr*> {
 		    typedef VectorMap<_Graph, _Item, _Ptr*> Map;
 		  };
 		// #else
 		//   template <typename _Graph, typename _Item, typename _Value>
 		//   struct DefaultMapSelector {
 		//     typedef DebugMap<_Graph, _Item, _Value> Map;
 		//   };
 		// #endif
 		  /// \e
 		  template <typename _Graph, typename _Item, typename _Value>
 		  class DefaultMap
 		    : public DefaultMapSelector<_Graph, _Item, _Value>::Map {
 		  public:
 		    typedef typename DefaultMapSelector<_Graph, _Item, _Value>::Map Parent;
 		    typedef DefaultMap<_Graph, _Item, _Value> Map;
 		    typedef typename Parent::Graph Graph;
 		    typedef typename Parent::Value Value;
 		    explicit DefaultMap(const Graph& graph) : Parent(graph) {}
 		    DefaultMap(const Graph& graph, const Value& value)
 		      : Parent(graph, value) {}
 		    DefaultMap& operator=(const DefaultMap& cmap) {
 		      return operator=<DefaultMap>(cmap);
+		    }
 		    template <typename CMap>
 		    DefaultMap& operator=(const CMap& cmap) {
 		      Parent::operator=(cmap);
 		      return *this;
+		    }
 		  };
+		}
 		#endif

lemon/bits/graph_extender.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_BITS_GRAPH_EXTENDER_H
 		#define LEMON_BITS_GRAPH_EXTENDER_H
 		#include <lemon/bits/invalid.h>
 		#include <lemon/bits/utility.h>
 		#include <lemon/bits/map_extender.h>
 		#include <lemon/bits/default_map.h>
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/maps.h>
 		///\ingroup graphbits
 		///\file
 		///\brief Extenders for the digraph types
 		namespace lemon {
 		  /// \ingroup graphbits
 		  ///
 		  /// \brief Extender for the Digraphs
 		  template <typename Base>
 		  class DigraphExtender : public Base {
 		  public:
 		    typedef Base Parent;
 		    typedef DigraphExtender Digraph;
 		    // Base extensions
 		    typedef typename Parent::Node Node;
 		    typedef typename Parent::Arc Arc;
 		    int maxId(Node) const {
 		      return Parent::maxNodeId();
+		    }
 		    int maxId(Arc) const {
 		      return Parent::maxArcId();
+		    }
 		    Node fromId(int id, Node) const {
 		      return Parent::nodeFromId(id);
+		    }
 		    Arc fromId(int id, Arc) const {
 		      return Parent::arcFromId(id);
+		    }
 		    Node oppositeNode(const Node &node, const Arc &arc) const {
 		      if (node == Parent::source(arc))
 			return Parent::target(arc);
 		      else if(node == Parent::target(arc))
 			return Parent::source(arc);
 		      else
 			return INVALID;
+		    }
 		    // Alterable extension
 		    typedef AlterationNotifier<DigraphExtender, Node> NodeNotifier;
 		    typedef AlterationNotifier<DigraphExtender, Arc> ArcNotifier;
 		  protected:
 		    mutable NodeNotifier node_notifier;
 		    mutable ArcNotifier arc_notifier;
 		  public:
 		    NodeNotifier& notifier(Node) const {
 		      return node_notifier;
+		    }
 		    ArcNotifier& notifier(Arc) const {
 		      return arc_notifier;
+		    }
 		    class NodeIt : public Node {
 		      const Digraph* _digraph;
 		    public:
 		      NodeIt() {}
 		      NodeIt(Invalid i) : Node(i) { }
 		      explicit NodeIt(const Digraph& digraph) : _digraph(&digraph) {
 			_digraph->first(static_cast<Node&>(*this));
+		      }
 		      NodeIt(const Digraph& digraph, const Node& node)
 			: Node(node), _digraph(&digraph) {}
 		      NodeIt& operator++() {
 			_digraph->next(*this);
 			return *this;
+		      }
 		    };
 		    class ArcIt : public Arc {
 		      const Digraph* _digraph;
 		    public:
 		      ArcIt() { }
 		      ArcIt(Invalid i) : Arc(i) { }
 		      explicit ArcIt(const Digraph& digraph) : _digraph(&digraph) {
 			_digraph->first(static_cast<Arc&>(*this));
+		      }
 		      ArcIt(const Digraph& digraph, const Arc& arc) :
 			Arc(arc), _digraph(&digraph) { }
 		      ArcIt& operator++() {
 			_digraph->next(*this);
 			return *this;
+		      }
 		    };
 		    class OutArcIt : public Arc {
 		      const Digraph* _digraph;
 		    public:
 		      OutArcIt() { }
 		      OutArcIt(Invalid i) : Arc(i) { }
 		      OutArcIt(const Digraph& digraph, const Node& node)
 			: _digraph(&digraph) {
 			_digraph->firstOut(*this, node);
+		      }
 		      OutArcIt(const Digraph& digraph, const Arc& arc)
 			: Arc(arc), _digraph(&digraph) {}
 		      OutArcIt& operator++() {
 			_digraph->nextOut(*this);
 			return *this;
+		      }
 		    };
 		    class InArcIt : public Arc {
 		      const Digraph* _digraph;
 		    public:
 		      InArcIt() { }
 		      InArcIt(Invalid i) : Arc(i) { }
 		      InArcIt(const Digraph& digraph, const Node& node)
 			: _digraph(&digraph) {
 			_digraph->firstIn(*this, node);
+		      }
 		      InArcIt(const Digraph& digraph, const Arc& arc) :
 			Arc(arc), _digraph(&digraph) {}
 		      InArcIt& operator++() {
 			_digraph->nextIn(*this);
 			return *this;
+		      }
 		    };
 		    /// \brief Base node of the iterator
 		    ///
 		    /// Returns the base node (i.e. the source in this case) of the iterator
 		    Node baseNode(const OutArcIt &arc) const {
 		      return Parent::source(arc);
+		    }
 		    /// \brief Running node of the iterator
 		    ///
 		    /// Returns the running node (i.e. the target in this case) of the
 		    /// iterator
 		    Node runningNode(const OutArcIt &arc) const {
 		      return Parent::target(arc);
+		    }
 		    /// \brief Base node of the iterator
 		    ///
 		    /// Returns the base node (i.e. the target in this case) of the iterator
 		    Node baseNode(const InArcIt &arc) const {
 		      return Parent::target(arc);
+		    }
 		    /// \brief Running node of the iterator
 		    ///
 		    /// Returns the running node (i.e. the source in this case) of the
 		    /// iterator
 		    Node runningNode(const InArcIt &arc) const {
 		      return Parent::source(arc);
+		    }
 		    template <typename _Value>
 		    class NodeMap
 		      : public MapExtender<DefaultMap<Digraph, Node, _Value> > {
 		    public:
 		      typedef DigraphExtender Digraph;
 		      typedef MapExtender<DefaultMap<Digraph, Node, _Value> > Parent;
 		      explicit NodeMap(const Digraph& digraph)
 			: Parent(digraph) {}
 		      NodeMap(const Digraph& digraph, const _Value& value)
 			: Parent(digraph, value) {}
 		      NodeMap& operator=(const NodeMap& cmap) {
 			return operator=<NodeMap>(cmap);
+		      }
 		      template <typename CMap>
 		      NodeMap& operator=(const CMap& cmap) {
 		        Parent::operator=(cmap);
 			return *this;
+		      }
 		    };
 		    template <typename _Value>
 		    class ArcMap
 		      : public MapExtender<DefaultMap<Digraph, Arc, _Value> > {
 		    public:
 		      typedef DigraphExtender Digraph;
 		      typedef MapExtender<DefaultMap<Digraph, Arc, _Value> > Parent;
 		      explicit ArcMap(const Digraph& digraph)
 			: Parent(digraph) {}
 		      ArcMap(const Digraph& digraph, const _Value& value)
 			: Parent(digraph, value) {}
 		      ArcMap& operator=(const ArcMap& cmap) {
 			return operator=<ArcMap>(cmap);
+		      }
 		      template <typename CMap>

lemon/bits/invalid.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_BITS_INVALID_H
 		#define LEMON_BITS_INVALID_H
 		///\file
 		///\brief Definition of INVALID.
 		namespace lemon {
 		  /// \brief Dummy type to make it easier to create invalid iterators.
 		  ///
 		  /// Dummy type to make it easier to create invalid iterators.
 		  /// See \ref INVALID for the usage.
 		  struct Invalid {
 		  public:
 		    bool operator==(Invalid) { return true;  }
 		    bool operator!=(Invalid) { return false; }
 		    bool operator< (Invalid) { return false; }
 		  };
 		  /// \brief Invalid iterators.
 		  ///
 		  /// \ref Invalid is a global type that converts to each iterator
 		  /// in such a way that the value of the target iterator will be invalid.
 		  //Some people didn't like this:
 		  //const Invalid &INVALID = *(Invalid *)0;
 		#ifdef LEMON_ONLY_TEMPLATES
 		  const Invalid INVALID = Invalid();
 		#else
 		  extern const Invalid INVALID;
 		#endif
 		} //namespace lemon
 		#endif

lemon/bits/map_extender.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_BITS_MAP_EXTENDER_H
 		#define LEMON_BITS_MAP_EXTENDER_H
 		#include <iterator>
 		#include <lemon/bits/traits.h>
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/maps.h>
 		///\file
 		///\brief Extenders for iterable maps.
 		namespace lemon {
 		  /// \ingroup graphbits
 		  ///
 		  /// \brief Extender for maps
 		  template <typename _Map>
 		  class MapExtender : public _Map {
 		  public:
 		    typedef _Map Parent;
 		    typedef MapExtender Map;
 		    typedef typename Parent::Graph Graph;
 		    typedef typename Parent::Key Item;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    class MapIt;
 		    class ConstMapIt;
 		    friend class MapIt;
 		    friend class ConstMapIt;
 		  public:
 		    MapExtender(const Graph& graph)
 		      : Parent(graph) {}
 		    MapExtender(const Graph& graph, const Value& value)
 		      : Parent(graph, value) {}
 		    MapExtender& operator=(const MapExtender& cmap) {
 		      return operator=<MapExtender>(cmap);
+		    }
 		    template <typename CMap>
 		    MapExtender& operator=(const CMap& cmap) {
 		      Parent::operator=(cmap);
 		      return *this;
+		    }
 		    class MapIt : public Item {
 		    public:
 		      typedef Item Parent;
 		      typedef typename Map::Value Value;
 		      MapIt() {}
 		      MapIt(Invalid i) : Parent(i) { }
 		      explicit MapIt(Map& _map) : map(_map) {
 		        map.notifier()->first(*this);
+		      }
 		      MapIt(const Map& _map, const Item& item)
 			: Parent(item), map(_map) {}
 		      MapIt& operator++() {
 			map.notifier()->next(*this);
 			return *this;
+		      }
 		      typename MapTraits<Map>::ConstReturnValue operator*() const {
 			return map[*this];
+		      }
 		      typename MapTraits<Map>::ReturnValue operator*() {
 			return map[*this];
+		      }
 		      void set(const Value& value) {
 			map.set(*this, value);
+		      }
 		    protected:
 		      Map& map;
 		    };
 		    class ConstMapIt : public Item {
 		    public:
 		      typedef Item Parent;
 		      typedef typename Map::Value Value;
 		      ConstMapIt() {}
 		      ConstMapIt(Invalid i) : Parent(i) { }
 		      explicit ConstMapIt(Map& _map) : map(_map) {
 		        map.notifier()->first(*this);
+		      }
 		      ConstMapIt(const Map& _map, const Item& item)
 			: Parent(item), map(_map) {}
 		      ConstMapIt& operator++() {
 			map.notifier()->next(*this);
 			return *this;
+		      }
 		      typename MapTraits<Map>::ConstReturnValue operator*() const {
 			return map[*this];
+		      }
 		    protected:
 		      const Map& map;
 		    };
 		    class ItemIt : public Item {
 		    public:
 		      typedef Item Parent;
 		      ItemIt() {}
 		      ItemIt(Invalid i) : Parent(i) { }
 		      explicit ItemIt(Map& _map) : map(_map) {
 		        map.notifier()->first(*this);
+		      }
 		      ItemIt(const Map& _map, const Item& item)
 			: Parent(item), map(_map) {}
 		      ItemIt& operator++() {
 			map.notifier()->next(*this);
 			return *this;
+		      }
 		    protected:
 		      const Map& map;
 		    };
 		  };
 		  /// \ingroup graphbits
 		  ///
 		  /// \brief Extender for maps which use a subset of the items.
 		  template <typename _Graph, typename _Map>
 		  class SubMapExtender : public _Map {
 		  public:
 		    typedef _Map Parent;
 		    typedef SubMapExtender Map;
 		    typedef _Graph Graph;
 		    typedef typename Parent::Key Item;
 		    typedef typename Parent::Key Key;
 		    typedef typename Parent::Value Value;
 		    class MapIt;
 		    class ConstMapIt;
 		    friend class MapIt;
 		    friend class ConstMapIt;
 		  public:
 		    SubMapExtender(const Graph& _graph)
 		      : Parent(_graph), graph(_graph) {}
 		    SubMapExtender(const Graph& _graph, const Value& _value)
 		      : Parent(_graph, _value), graph(_graph) {}
 		    SubMapExtender& operator=(const SubMapExtender& cmap) {
 		      return operator=<MapExtender>(cmap);
+		    }
 		    template <typename CMap>
 		    SubMapExtender& operator=(const CMap& cmap) {
 		      checkConcept<concepts::ReadMap<Key, Value>, CMap>();
 		      Item it;
 		      for (graph.first(it); it != INVALID; graph.next(it)) {
 		        Parent::set(it, cmap[it]);
+		      }
 		      return *this;
+		    }
 		    class MapIt : public Item {
 		    public:
 		      typedef Item Parent;
 		      typedef typename Map::Value Value;
 		      MapIt() {}
 		      MapIt(Invalid i) : Parent(i) { }
 		      explicit MapIt(Map& _map) : map(_map) {
 		        map.graph.first(*this);
+		      }
 		      MapIt(const Map& _map, const Item& item)
 			: Parent(item), map(_map) {}
 		      MapIt& operator++() {
 			map.graph.next(*this);
 			return *this;
+		      }
 		      typename MapTraits<Map>::ConstReturnValue operator*() const {
 			return map[*this];
+		      }
 		      typename MapTraits<Map>::ReturnValue operator*() {
 			return map[*this];
+		      }
 		      void set(const Value& value) {
 			map.set(*this, value);
+		      }
 		    protected:
 		      Map& map;
 		    };
 		    class ConstMapIt : public Item {
 		    public:
 		      typedef Item Parent;

lemon/bits/path_dump.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_BITS_PRED_MAP_PATH_H
 		#define LEMON_BITS_PRED_MAP_PATH_H
 		namespace lemon {
 		  template <typename _Digraph, typename _PredMap>
 		  class PredMapPath {
 		  public:
 		    typedef True RevPathTag;
 		    typedef _Digraph Digraph;
 		    typedef typename Digraph::Arc Arc;
 		    typedef _PredMap PredMap;
 		    PredMapPath(const Digraph& _digraph, const PredMap& _predMap,
 		                typename Digraph::Node _target)
 		      : digraph(_digraph), predMap(_predMap), target(_target) {}
 		    int length() const {
 		      int len = 0;
 		      typename Digraph::Node node = target;
 		      typename Digraph::Arc arc;
 		      while ((arc = predMap[node]) != INVALID) {
 		        node = digraph.source(arc);
 		        ++len;
+		      }
 		      return len;
+		    }
 		    bool empty() const {
 		      return predMap[target] != INVALID;
+		    }
 		    class RevArcIt {
 		    public:
 		      RevArcIt() {}
 		      RevArcIt(Invalid) : path(0), current(INVALID) {}
 		      RevArcIt(const PredMapPath& _path)
 		        : path(&_path), current(_path.target) {
 		        if (path->predMap[current] == INVALID) current = INVALID;
+		      }
 		      operator const typename Digraph::Arc() const {
 		        return path->predMap[current];
+		      }
 		      RevArcIt& operator++() {
 		        current = path->digraph.source(path->predMap[current]);
 		        if (path->predMap[current] == INVALID) current = INVALID;
 		        return *this;
+		      }
 		      bool operator==(const RevArcIt& e) const {
 		        return current == e.current;
+		      }
 		      bool operator!=(const RevArcIt& e) const {
 		        return current != e.current;
+		      }
 		      bool operator<(const RevArcIt& e) const {
 		        return current < e.current;
+		      }
 		    private:
 		      const PredMapPath* path;
 		      typename Digraph::Node current;
 		    };
 		  private:
 		    const Digraph& digraph;
 		    const PredMap& predMap;
 		    typename Digraph::Node target;
 		  };
 		  template <typename _Digraph, typename _PredMatrixMap>
 		  class PredMatrixMapPath {
 		  public:
 		    typedef True RevPathTag;
 		    typedef _Digraph Digraph;
 		    typedef typename Digraph::Arc Arc;
 		    typedef _PredMatrixMap PredMatrixMap;
 		    PredMatrixMapPath(const Digraph& _digraph,
 		                      const PredMatrixMap& _predMatrixMap,
 		                      typename Digraph::Node _source,
 		                      typename Digraph::Node _target)
 		      : digraph(_digraph), predMatrixMap(_predMatrixMap),
 		        source(_source), target(_target) {}
 		    int length() const {
 		      int len = 0;
 		      typename Digraph::Node node = target;
 		      typename Digraph::Arc arc;
 		      while ((arc = predMatrixMap(source, node)) != INVALID) {
 		        node = digraph.source(arc);
 		        ++len;
+		      }
 		      return len;
+		    }
 		    bool empty() const {
 		      return source != target;
+		    }
 		    class RevArcIt {
 		    public:
 		      RevArcIt() {}
 		      RevArcIt(Invalid) : path(0), current(INVALID) {}
 		      RevArcIt(const PredMatrixMapPath& _path)
 		        : path(&_path), current(_path.target) {
 		        if (path->predMatrixMap(path->source, current) == INVALID)
 		          current = INVALID;
+		      }
 		      operator const typename Digraph::Arc() const {
 		        return path->predMatrixMap(path->source, current);
+		      }
 		      RevArcIt& operator++() {
 		        current =
 		          path->digraph.source(path->predMatrixMap(path->source, current));
 		        if (path->predMatrixMap(path->source, current) == INVALID)
 		          current = INVALID;
 		        return *this;
+		      }
 		      bool operator==(const RevArcIt& e) const {
 		        return current == e.current;
+		      }
 		      bool operator!=(const RevArcIt& e) const {
 		        return current != e.current;
+		      }
 		      bool operator<(const RevArcIt& e) const {
 		        return current < e.current;
+		      }
 		    private:
 		      const PredMatrixMapPath* path;
 		      typename Digraph::Node current;
 		    };
 		  private:
 		    const Digraph& digraph;
 		    const PredMatrixMap& predMatrixMap;
 		    typename Digraph::Node source;
 		    typename Digraph::Node target;
 		  };
+		}
 		#endif

lemon/bits/traits.h

Show inline comments

 		/* -*- C++ -*-
 		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_BITS_TRAITS_H
 		#define LEMON_BITS_TRAITS_H
 		#include <lemon/bits/utility.h>
 		///\file
 		///\brief Traits for graphs and maps
 		///
 		namespace lemon {
 		  template <typename _Graph, typename _Item>
 		  class ItemSetTraits {};
 		  template <typename Graph, typename Enable = void>
 		  struct NodeNotifierIndicator {
 		    typedef InvalidType Type;
 		  };
 		  template <typename Graph>
 		  struct NodeNotifierIndicator<
 		    Graph,
 		    typename enable_if<typename Graph::NodeNotifier::Notifier, void>::type
 		  > {
 		    typedef typename Graph::NodeNotifier Type;
 		  };
 		  template <typename _Graph>
 		  class ItemSetTraits<_Graph, typename _Graph::Node> {
 		  public:
 		    typedef _Graph Graph;
 		    typedef typename Graph::Node Item;
 		    typedef typename Graph::NodeIt ItemIt;
 		    typedef typename NodeNotifierIndicator<Graph>::Type ItemNotifier;
 		    template <typename _Value>
 		    class Map : public Graph::template NodeMap<_Value> {
 		    public:
 		      typedef typename Graph::template NodeMap<_Value> Parent;
 		      typedef typename Graph::template NodeMap<_Value> Type;
 		      typedef typename Parent::Value Value;
 		      Map(const Graph& _digraph) : Parent(_digraph) {}
 		      Map(const Graph& _digraph, const Value& _value)
 			: Parent(_digraph, _value) {}
 		     };
 		  };
 		  template <typename Graph, typename Enable = void>
 		  struct ArcNotifierIndicator {
 		    typedef InvalidType Type;
 		  };
 		  template <typename Graph>
 		  struct ArcNotifierIndicator<
 		    Graph,
 		    typename enable_if<typename Graph::ArcNotifier::Notifier, void>::type
 		  > {
 		    typedef typename Graph::ArcNotifier Type;
 		  };
 		  template <typename _Graph>
 		  class ItemSetTraits<_Graph, typename _Graph::Arc> {
 		  public:
 		    typedef _Graph Graph;
 		    typedef typename Graph::Arc Item;
 		    typedef typename Graph::ArcIt ItemIt;
 		    typedef typename ArcNotifierIndicator<Graph>::Type ItemNotifier;
 		    template <typename _Value>
 		    class Map : public Graph::template ArcMap<_Value> {
 		    public:
 		      typedef typename Graph::template ArcMap<_Value> Parent;
 		      typedef typename Graph::template ArcMap<_Value> Type;
 		      typedef typename Parent::Value Value;
 		      Map(const Graph& _digraph) : Parent(_digraph) {}
 		      Map(const Graph& _digraph, const Value& _value)
 			: Parent(_digraph, _value) {}
 		    };
 		  };
 		  template <typename Graph, typename Enable = void>
 		  struct EdgeNotifierIndicator {
 		    typedef InvalidType Type;
 		  };
 		  template <typename Graph>
 		  struct EdgeNotifierIndicator<
 		    Graph,
 		    typename enable_if<typename Graph::EdgeNotifier::Notifier, void>::type
 		  > {
 		    typedef typename Graph::EdgeNotifier Type;
 		  };
 		  template <typename _Graph>
 		  class ItemSetTraits<_Graph, typename _Graph::Edge> {
 		  public:
 		    typedef _Graph Graph;
 		    typedef typename Graph::Edge Item;
 		    typedef typename Graph::EdgeIt ItemIt;
 		    typedef typename EdgeNotifierIndicator<Graph>::Type ItemNotifier;
 		    template <typename _Value>
 		    class Map : public Graph::template EdgeMap<_Value> {
 		    public:
 		      typedef typename Graph::template EdgeMap<_Value> Parent;
 		      typedef typename Graph::template EdgeMap<_Value> Type;
 		      typedef typename Parent::Value Value;
 		      Map(const Graph& _digraph) : Parent(_digraph) {}
 		      Map(const Graph& _digraph, const Value& _value)
 			: Parent(_digraph, _value) {}
 		    };
 		  };
 		  template <typename Map, typename Enable = void>
 		  struct MapTraits {
 		    typedef False ReferenceMapTag;
 		    typedef typename Map::Key Key;
 		    typedef typename Map::Value Value;
 		    typedef Value ConstReturnValue;
 		    typedef Value ReturnValue;
 		  };
 		  template <typename Map>
 		  struct MapTraits<
 		    Map, typename enable_if<typename Map::ReferenceMapTag, void>::type >
+		  {
 		    typedef True ReferenceMapTag;
 		    typedef typename Map::Key Key;
 		    typedef typename Map::Value Value;
 		    typedef typename Map::ConstReference ConstReturnValue;
 		    typedef typename Map::Reference ReturnValue;
 		    typedef typename Map::ConstReference ConstReference;
 		    typedef typename Map::Reference Reference;
 		 };
 		  template <typename MatrixMap, typename Enable = void>
 		  struct MatrixMapTraits {
 		    typedef False ReferenceMapTag;
 		    typedef typename MatrixMap::FirstKey FirstKey;
 		    typedef typename MatrixMap::SecondKey SecondKey;
 		    typedef typename MatrixMap::Value Value;
 		    typedef Value ConstReturnValue;
 		    typedef Value ReturnValue;
 		  };
 		  template <typename MatrixMap>
 		  struct MatrixMapTraits<
 		    MatrixMap, typename enable_if<typename MatrixMap::ReferenceMapTag,
 		                                  void>::type >
+		  {
 		    typedef True ReferenceMapTag;
 		    typedef typename MatrixMap::FirstKey FirstKey;
 		    typedef typename MatrixMap::SecondKey SecondKey;
 		    typedef typename MatrixMap::Value Value;
 		    typedef typename MatrixMap::ConstReference ConstReturnValue;
 		    typedef typename MatrixMap::Reference ReturnValue;
 		    typedef typename MatrixMap::ConstReference ConstReference;
 		    typedef typename MatrixMap::Reference Reference;
 		 };
 		  // Indicators for the tags
 		  template <typename Graph, typename Enable = void>
 		  struct NodeNumTagIndicator {
 		    static const bool value = false;
 		  };
 		  template <typename Graph>
 		  struct NodeNumTagIndicator<
 		    Graph,
 		    typename enable_if<typename Graph::NodeNumTag, void>::type
 		  > {
 		    static const bool value = true;
 		  };
 		  template <typename Graph, typename Enable = void>
 		  struct EdgeNumTagIndicator {
 		    static const bool value = false;
 		  };
 		  template <typename Graph>
 		  struct EdgeNumTagIndicator<
 		    Graph,
 		    typename enable_if<typename Graph::EdgeNumTag, void>::type
 		  > {
 		    static const bool value = true;
 		  };
 		  template <typename Graph, typename Enable = void>
 		  struct FindEdgeTagIndicator {
 		    static const bool value = false;
 		  };
 		  template <typename Graph>
 		  struct FindEdgeTagIndicator<
 		    Graph,
 		    typename enable_if<typename Graph::FindEdgeTag, void>::type
 		  > {
 		    static const bool value = true;
 		  };
 		  template <typename Graph, typename Enable = void>
 		  struct UndirectedTagIndicator {
 		    static const bool value = false;
 		  };
 		  template <typename Graph>
 		  struct UndirectedTagIndicator<
 		    Graph,
 		    typename enable_if<typename Graph::UndirectedTag, void>::type
 		  > {
 		    static const bool value = true;
 		  };
 		  template <typename Graph, typename Enable = void>
 		  struct BuildTagIndicator {
 		    static const bool value = false;
 		  };

lemon/bits/utility.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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.
+		 *
 		 */
 		// This file contains a modified version of the enable_if library from BOOST.
 		// See the appropriate copyright notice below.
 		// Boost enable_if library
 		// Copyright 2003 (c) The Trustees of Indiana University.
 		// Use, modification, and distribution is subject to the Boost Software
 		// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
 		// http://www.boost.org/LICENSE_1_0.txt)
 		//    Authors: Jaakko Jarvi (jajarvi at osl.iu.edu)
 		//             Jeremiah Willcock (jewillco at osl.iu.edu)
 		//             Andrew Lumsdaine (lums at osl.iu.edu)
 		#ifndef LEMON_BITS_UTILITY_H
 		#define LEMON_BITS_UTILITY_H
 		///\file
 		///\brief Miscellaneous basic utilities
 		///
 		///\todo Please rethink the organisation of the basic files like this.
 		///E.g. this file might be merged with invalid.h.
 		namespace lemon
+		{
 		  /// Basic type for defining "tags". A "YES" condition for \c enable_if.
 		  /// Basic type for defining "tags". A "YES" condition for \c enable_if.
 		  ///
 		  ///\sa False
 		  ///
 		  /// \todo This should go to a separate "basic_types.h" (or something)
 		  /// file.
 		  struct True {
 		    ///\e
 		    static const bool value = true;
 		  };
 		  /// Basic type for defining "tags". A "NO" condition for \c enable_if.
 		  /// Basic type for defining "tags". A "NO" condition for \c enable_if.
 		  ///
 		  ///\sa True
 		  struct False {
 		    ///\e
 		    static const bool value = false;
 		  };
 		  struct InvalidType {
 		  };
 		  template <typename T>
 		  struct Wrap {
 		    const T &value;
 		    Wrap(const T &t) : value(t) {}
 		  };
 		  /**************** dummy class to avoid ambiguity ****************/
 		  template<int T> struct dummy { dummy(int) {} };
 		  /**************** enable_if from BOOST ****************/
 		  template <typename Type, typename T = void>
 		  struct exists {
 		    typedef T type;
 		  };
 		  template <bool B, class T = void>
 		  struct enable_if_c {
 		    typedef T type;
 		  };
 		  template <class T>
 		  struct enable_if_c<false, T> {};
 		  template <class Cond, class T = void>
 		  struct enable_if : public enable_if_c<Cond::value, T> {};
 		  template <bool B, class T>
 		  struct lazy_enable_if_c {
 		    typedef typename T::type type;
 		  };
 		  template <class T>
 		  struct lazy_enable_if_c<false, T> {};
 		  template <class Cond, class T>
 		  struct lazy_enable_if : public lazy_enable_if_c<Cond::value, T> {};
 		  template <bool B, class T = void>
 		  struct disable_if_c {
 		    typedef T type;
 		  };
 		  template <class T>
 		  struct disable_if_c<true, T> {};
 		  template <class Cond, class T = void>
 		  struct disable_if : public disable_if_c<Cond::value, T> {};
 		  template <bool B, class T>
 		  struct lazy_disable_if_c {
 		    typedef typename T::type type;
 		  };
 		  template <class T>
 		  struct lazy_disable_if_c<true, T> {};
 		  template <class Cond, class T>
 		  struct lazy_disable_if : public lazy_disable_if_c<Cond::value, T> {};
 		} // namespace lemon
 		#endif

lemon/bits/vector_map.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_BITS_VECTOR_MAP_H
 		#define LEMON_BITS_VECTOR_MAP_H
 		#include <vector>
 		#include <algorithm>
 		#include <lemon/bits/traits.h>
 		#include <lemon/bits/utility.h>
 		#include <lemon/bits/alteration_notifier.h>
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/maps.h>
 		///\ingroup graphbits
 		///
 		///\file
 		///\brief Vector based graph maps.
 		namespace lemon {
 		  /// \ingroup graphbits
 		  ///
 		  /// \brief Graph map based on the std::vector storage.
 		  ///
 		  /// The VectorMap template class is graph map structure what
 		  /// automatically updates the map when a key is added to or erased from
 		  /// the map. This map type uses the std::vector to store the values.
 		  ///
 		  /// \tparam _Notifier The AlterationNotifier that will notify this map.
 		  /// \tparam _Item The item type of the graph items.
 		  /// \tparam _Value The value type of the map.
 		  /// \todo Fix the doc: there is _Graph parameter instead of _Notifier.
 		  template <typename _Graph, typename _Item, typename _Value>
 		  class VectorMap
 		    : public ItemSetTraits<_Graph, _Item>::ItemNotifier::ObserverBase {
 		  private:
 		    /// The container type of the map.
 		    typedef std::vector<_Value> Container;
 		  public:
 		    /// The graph type of the map.
 		    typedef _Graph Graph;
 		    /// The item type of the map.
 		    typedef _Item Item;
 		    /// The reference map tag.
 		    typedef True ReferenceMapTag;
 		    /// The key type of the map.
 		    typedef _Item Key;
 		    /// The value type of the map.
 		    typedef _Value Value;
 		    /// The notifier type.
 		    typedef typename ItemSetTraits<_Graph, _Item>::ItemNotifier Notifier;
 		    /// The map type.
 		    typedef VectorMap Map;
 		    /// The base class of the map.
 		    typedef typename Notifier::ObserverBase Parent;
 		    /// The reference type of the map;
 		    typedef typename Container::reference Reference;
 		    /// The const reference type of the map;
 		    typedef typename Container::const_reference ConstReference;
 		    /// \brief Constructor to attach the new map into the notifier.
 		    ///
 		    /// It constructs a map and attachs it into the notifier.
 		    /// It adds all the items of the graph to the map.
 		    VectorMap(const Graph& graph) {
 		      Parent::attach(graph.notifier(Item()));
 		      container.resize(Parent::notifier()->maxId() + 1);
+		    }
 		    /// \brief Constructor uses given value to initialize the map.
 		    ///
 		    /// It constructs a map uses a given value to initialize the map.
 		    /// It adds all the items of the graph to the map.
 		    VectorMap(const Graph& graph, const Value& value) {
 		      Parent::attach(graph.notifier(Item()));
 		      container.resize(Parent::notifier()->maxId() + 1, value);
+		    }
 		    /// \brief Copy constructor
 		    ///
 		    /// Copy constructor.
 		    VectorMap(const VectorMap& _copy) : Parent() {
 		      if (_copy.attached()) {
 			Parent::attach(*_copy.notifier());
 			container = _copy.container;
+		      }
+		    }
 		    /// \brief Assign operator.
 		    ///
 		    /// This operator assigns for each item in the map the
 		    /// value mapped to the same item in the copied map.
 		    /// The parameter map should be indiced with the same
 		    /// itemset because this assign operator does not change
 		    /// the container of the map.
 		    VectorMap& operator=(const VectorMap& cmap) {
 		      return operator=<VectorMap>(cmap);
+		    }
 		    /// \brief Template assign operator.
 		    ///
 		    /// The given parameter should be conform to the ReadMap
 		    /// concecpt and could be indiced by the current item set of
 		    /// the NodeMap. In this case the value for each item
 		    /// is assigned by the value of the given ReadMap.
 		    template <typename CMap>
 		    VectorMap& operator=(const CMap& cmap) {
 		      checkConcept<concepts::ReadMap<Key, _Value>, CMap>();
 		      const typename Parent::Notifier* nf = Parent::notifier();
 		      Item it;
 		      for (nf->first(it); it != INVALID; nf->next(it)) {
 		        set(it, cmap[it]);
+		      }
 		      return *this;
+		    }
 		  public:
 		    /// \brief The subcript operator.
 		    ///
 		    /// The subscript operator. The map can be subscripted by the
 		    /// actual items of the graph.
 		    Reference operator[](const Key& key) {
 		      return container[Parent::notifier()->id(key)];
+		    }
 		    /// \brief The const subcript operator.
 		    ///
 		    /// The const subscript operator. The map can be subscripted by the
 		    /// actual items of the graph.
 		    ConstReference operator[](const Key& key) const {
 		      return container[Parent::notifier()->id(key)];
+		    }
 		    /// \brief The setter function of the map.
 		    ///
 		    /// It the same as operator[](key) = value expression.
 		    void set(const Key& key, const Value& value) {
 		      (*this)[key] = value;
+		    }
 		  protected:
 		    /// \brief Adds a new key to the map.
 		    ///
 		    /// It adds a new key to the map. It called by the observer notifier
 		    /// and it overrides the add() member function of the observer base.
 		    virtual void add(const Key& key) {
 		      int id = Parent::notifier()->id(key);
 		      if (id >= int(container.size())) {
 			container.resize(id + 1);
+		      }
+		    }
 		    /// \brief Adds more new keys to the map.
 		    ///
 		    /// It adds more new keys to the map. It called by the observer notifier
 		    /// and it overrides the add() member function of the observer base.
 		    virtual void add(const std::vector<Key>& keys) {
 		      int max = container.size() - 1;
 		      for (int i = 0; i < int(keys.size()); ++i) {
 		        int id = Parent::notifier()->id(keys[i]);
 		        if (id >= max) {
 		          max = id;
+		        }
+		      }
 		      container.resize(max + 1);
+		    }
 		    /// \brief Erase a key from the map.
 		    ///
 		    /// Erase a key from the map. It called by the observer notifier
 		    /// and it overrides the erase() member function of the observer base.
 		    virtual void erase(const Key& key) {
 		      container[Parent::notifier()->id(key)] = Value();
+		    }
 		    /// \brief Erase more keys from the map.
 		    ///
 		    /// Erase more keys from the map. It called by the observer notifier
 		    /// and it overrides the erase() member function of the observer base.
 		    virtual void erase(const std::vector<Key>& keys) {
 		      for (int i = 0; i < int(keys.size()); ++i) {
 			container[Parent::notifier()->id(keys[i])] = Value();
+		      }
+		    }
 		    /// \brief Buildes the map.
 		    ///
 		    /// It buildes the map. It called by the observer notifier
 		    /// and it overrides the build() member function of the observer base.
 		    virtual void build() {
 		      int size = Parent::notifier()->maxId() + 1;
 		      container.reserve(size);
 		      container.resize(size);
+		    }
 		    /// \brief Clear the map.
 		    ///
 		    /// It erase all items from the map. It called by the observer notifier
 		    /// and it overrides the clear() member function of the observer base.
 		    virtual void clear() {
 		      container.clear();
+		    }
 		  private:
 		    Container container;
 		  };
+		}
 		#endif

lemon/color.cc

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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.
+		 *
 		 */
 		///\file
 		///\brief Color constants
 		#include<lemon/color.h>
 		namespace lemon {
 		  const Color WHITE(1,1,1);
 		  const Color BLACK(0,0,0);
 		  const Color RED(1,0,0);
 		  const Color GREEN(0,1,0);
 		  const Color BLUE(0,0,1);
 		  const Color YELLOW(1,1,0);
 		  const Color MAGENTA(1,0,1);
 		  const Color CYAN(0,1,1);
 		  const Color GREY(0,0,0);
 		  const Color DARK_RED(.5,0,0);
 		  const Color DARK_GREEN(0,.5,0);
 		  const Color DARK_BLUE(0,0,.5);
 		  const Color DARK_YELLOW(.5,.5,0);
 		  const Color DARK_MAGENTA(.5,0,.5);
 		  const Color DARK_CYAN(0,.5,.5);
 		} //namespace lemon

lemon/color.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_COLOR_H
 		#define LEMON_COLOR_H
 		#include<vector>
 		#include<lemon/math.h>
 		#include<lemon/maps.h>
 		///\ingroup misc
 		///\file
 		///\brief Tools to manage RGB colors.
 		namespace lemon {
 		  /// \addtogroup misc
 		  /// @{
 		  ///Data structure representing RGB colors.
 		  ///Data structure representing RGB colors.
 		  class Color
+		  {
 		    double _r,_g,_b;
 		  public:
 		    ///Default constructor
 		    Color() {}
 		    ///Constructor
 		    Color(double r,double g,double b) :_r(r),_g(g),_b(b) {};
 		    ///Set the red component
 		    double & red() {return _r;}
 		    ///Return the red component
 		    const double & red() const {return _r;}
 		    ///Set the green component
 		    double & green() {return _g;}
 		    ///Return the green component
 		    const double & green() const {return _g;}
 		    ///Set the blue component
 		    double & blue() {return _b;}
 		    ///Return the blue component
 		    const double & blue() const {return _b;}
 		    ///Set the color components
 		    void set(double r,double g,double b) { _r=r;_g=g;_b=b; };
 		  };
 		  /// White color constant
 		  extern const Color WHITE;
 		  /// Black color constant
 		  extern const Color BLACK;
 		  /// Red color constant
 		  extern const Color RED;
 		  /// Green color constant
 		  extern const Color GREEN;
 		  /// Blue color constant
 		  extern const Color BLUE;
 		  /// Yellow color constant
 		  extern const Color YELLOW;
 		  /// Magenta color constant
 		  extern const Color MAGENTA;
 		  /// Cyan color constant
 		  extern const Color CYAN;
 		  /// Grey color constant
 		  extern const Color GREY;
 		  /// Dark red color constant
 		  extern const Color DARK_RED;
 		  /// Dark green color constant
 		  extern const Color DARK_GREEN;
 		  /// Drak blue color constant
 		  extern const Color DARK_BLUE;
 		  /// Dark yellow color constant
 		  extern const Color DARK_YELLOW;
 		  /// Dark magenta color constant
 		  extern const Color DARK_MAGENTA;
 		  /// Dark cyan color constant
 		  extern const Color DARK_CYAN;
 		  ///Map <tt>int</tt>s to different \ref Color "Color"s
 		  ///This map assigns one of the predefined \ref Color "Color"s to
 		  ///each <tt>int</tt>. It is possible to change the colors as well as
 		  ///their number. The integer range is cyclically mapped to the
 		  ///provided set of colors.
 		  ///
 		  ///This is a true \ref concepts::ReferenceMap "reference map", so
 		  ///you can also change the actual colors.
 		  class Palette : public MapBase<int,Color>
+		  {
 		    std::vector<Color> colors;
 		  public:
 		    ///Constructor
 		    ///Constructor.
 		    ///\param have_white Indicates whether white is among the
 		    ///provided initial colors (\c true) or not (\c false). If it is true,
 		    ///white will be assigned to \c 0.
 		    ///\param num The number of the allocated colors. If it is \c -1,
 		    ///the default color configuration is set up (26 color plus optionaly the
 		    ///white).  If \c num is less then 26/27 then the default color
 		    ///list is cut. Otherwise the color list is filled repeatedly with
 		    ///the default color list.  (The colors can be changed later on.)
 		    Palette(bool have_white=false,int num=-1)
+		    {
 		      if (num==0) return;
 		      do {
 		        if(have_white) colors.push_back(Color(1,1,1));
 		        colors.push_back(Color(0,0,0));
 		        colors.push_back(Color(1,0,0));
 		        colors.push_back(Color(0,1,0));
 		        colors.push_back(Color(0,0,1));
 		        colors.push_back(Color(1,1,0));
 		        colors.push_back(Color(1,0,1));
 		        colors.push_back(Color(0,1,1));
 		        colors.push_back(Color(.5,0,0));
 		        colors.push_back(Color(0,.5,0));
 		        colors.push_back(Color(0,0,.5));
 		        colors.push_back(Color(.5,.5,0));
 		        colors.push_back(Color(.5,0,.5));
 		        colors.push_back(Color(0,.5,.5));
 		        colors.push_back(Color(.5,.5,.5));
 		        colors.push_back(Color(1,.5,.5));
 		        colors.push_back(Color(.5,1,.5));
 		        colors.push_back(Color(.5,.5,1));
 		        colors.push_back(Color(1,1,.5));
 		        colors.push_back(Color(1,.5,1));
 		        colors.push_back(Color(.5,1,1));
 		        colors.push_back(Color(1,.5,0));
 		        colors.push_back(Color(.5,1,0));
 		        colors.push_back(Color(1,0,.5));
 		        colors.push_back(Color(0,1,.5));
 		        colors.push_back(Color(0,.5,1));
 		        colors.push_back(Color(.5,0,1));
 		      } while(int(colors.size())<num);
 		      if(num>=0) colors.resize(num);
+		    }
 		    ///\e
 		    Color &operator[](int i)
+		    {
 		      return colors[i%colors.size()];
+		    }
 		    ///\e
 		    const Color &operator[](int i) const
+		    {
 		      return colors[i%colors.size()];
+		    }
 		    ///\e
 		    void set(int i,const Color &c)
+		    {
 		      colors[i%colors.size()]=c;
+		    }
 		    ///Adds a new color to the end of the color list.
 		    void add(const Color &c)
+		    {
 		      colors.push_back(c);
+		    }
 		    ///Sets the number of the existing colors.
 		    void resize(int s) { colors.resize(s);}
 		    ///Returns the number of the existing colors.
 		    int size() const { return int(colors.size());}
 		  };
 		  ///Returns a visibly distinct \ref Color
 		  ///Returns a \ref Color which is as different from the given parameter
 		  ///as it is possible.
 		  inline Color distantColor(const Color &c)
+		  {
 		    return Color(c.red()<.5?1:0,c.green()<.5?1:0,c.blue()<.5?1:0);
+		  }
 		  ///Returns black for light colors and white for the dark ones.
 		  ///Returns black for light colors and white for the dark ones.
 		  inline Color distantBW(const Color &c){
 		    return (.2125*c.red()+.7154*c.green()+.0721*c.blue())<.5 ? WHITE : BLACK;
+		  }
 		  /// @}
 		} //END OF NAMESPACE LEMON
 		#endif // LEMON_COLOR_H

lemon/concept_check.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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.
+		 *
 		 */
 		// This file contains a modified version of the concept checking
 		// utility from BOOST.
 		// See the appropriate copyright notice below.
 		// (C) Copyright Jeremy Siek 2000.
 		// Distributed under the Boost Software License, Version 1.0. (See
 		// accompanying file LICENSE_1_0.txt or copy at
 		// http://www.boost.org/LICENSE_1_0.txt)
 		//
 		// Revision History:
 		//   05 May   2001: Workarounds for HP aCC from Thomas Matelich. (Jeremy Siek)
 		//   02 April 2001: Removed limits header altogether. (Jeremy Siek)
 		//   01 April 2001: Modified to use new <boost/limits.hpp> header. (JMaddock)
 		//
 		// See http://www.boost.org/libs/concept_check for documentation.
 		///\file
 		///\brief Basic utilities for concept checking.
 		///
 		///\todo Are we still using BOOST concept checking utility?
 		///Is the BOOST copyright notice necessary?
 		#ifndef LEMON_CONCEPT_CHECK_H
 		#define LEMON_CONCEPT_CHECK_H
 		namespace lemon {
 		  /*
 		    "inline" is used for ignore_unused_variable_warning()
 		    and function_requires() to make sure there is no
 		    overtarget with g++.
 		  */
 		  template <class T> inline void ignore_unused_variable_warning(const T&) { }
 		  ///\e
 		  template <class Concept>
 		  inline void function_requires()
+		  {
 		#if !defined(NDEBUG)
 		    void (Concept::*x)() = & Concept::constraints;
 		    ignore_unused_variable_warning(x);
 		#endif
+		  }
 		  ///\e
 		  template <typename Concept, typename Type>
 		  inline void checkConcept() {
 		#if !defined(NDEBUG)
 		    typedef typename Concept::template Constraints<Type> ConceptCheck;
 		    void (ConceptCheck::*x)() = & ConceptCheck::constraints;
 		    ignore_unused_variable_warning(x);
 		#endif
+		  }
 		} // namespace lemon
 		#endif // LEMON_CONCEPT_CHECK_H

lemon/concepts/digraph.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_CONCEPT_DIGRAPH_H
 		#define LEMON_CONCEPT_DIGRAPH_H
 		///\ingroup graph_concepts
 		///\file
 		///\brief The concept of directed graphs.
 		#include <lemon/bits/invalid.h>
 		#include <lemon/bits/utility.h>
 		#include <lemon/concepts/maps.h>
 		#include <lemon/concept_check.h>
 		#include <lemon/concepts/graph_components.h>
 		namespace lemon {
 		  namespace concepts {
 		    /// \ingroup graph_concepts
 		    ///
 		    /// \brief Class describing the concept of directed graphs.
 		    ///
 		    /// This class describes the \ref concept "concept" of the
 		    /// immutable directed digraphs.
 		    ///
 		    /// Note that actual digraph implementation like @ref ListDigraph or
 		    /// @ref SmartDigraph may have several additional functionality.
 		    ///
 		    /// \sa concept
 		    class Digraph {
 		    private:
 		      ///Digraphs are \e not copy constructible. Use DigraphCopy() instead.
 		      ///Digraphs are \e not copy constructible. Use DigraphCopy() instead.
 		      ///
 		      Digraph(const Digraph &) {};
 		      ///\brief Assignment of \ref Digraph "Digraph"s to another ones are
 		      ///\e not allowed. Use DigraphCopy() instead.
 		      ///Assignment of \ref Digraph "Digraph"s to another ones are
 		      ///\e not allowed.  Use DigraphCopy() instead.
 		      void operator=(const Digraph &) {}
 		    public:
 		      ///\e
 		      /// Defalult constructor.
 		      /// Defalult constructor.
 		      ///
 		      Digraph() { }
 		      /// Class for identifying a node of the digraph
 		      /// This class identifies a node of the digraph. It also serves
 		      /// as a base class of the node iterators,
 		      /// thus they will convert to this type.
 		      class Node {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        Node() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        Node(const Node&) { }
 		        /// Invalid constructor \& conversion.
 		        /// This constructor initializes the iterator to be invalid.
 		        /// \sa Invalid for more details.
 		        Node(Invalid) { }
 		        /// Equality operator
 		        /// Two iterators are equal if and only if they point to the
 		        /// same object or both are invalid.
 		        bool operator==(Node) const { return true; }
 		        /// Inequality operator
 		        /// \sa operator==(Node n)
 		        ///
 		        bool operator!=(Node) const { return true; }
 			/// Artificial ordering operator.
 			/// To allow the use of digraph descriptors as key type in std::map or
 			/// similar associative container we require this.
 			///
 			/// \note This operator only have to define some strict ordering of
 			/// the items; this order has nothing to do with the iteration
 			/// ordering of the items.
 			bool operator<(Node) const { return false; }
 		      };
 		      /// This iterator goes through each node.
 		      /// This iterator goes through each node.
 		      /// Its usage is quite simple, for example you can count the number
 		      /// of nodes in digraph \c g of type \c Digraph like this:
 		      ///\code
 		      /// int count=0;
 		      /// for (Digraph::NodeIt n(g); n!=INVALID; ++n) ++count;
 		      ///\endcode
 		      class NodeIt : public Node {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        NodeIt() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        NodeIt(const NodeIt& n) : Node(n) { }
 		        /// Invalid constructor \& conversion.
 		        /// Initialize the iterator to be invalid.
 		        /// \sa Invalid for more details.
 		        NodeIt(Invalid) { }
 		        /// Sets the iterator to the first node.
 		        /// Sets the iterator to the first node of \c g.
 		        ///
 		        NodeIt(const Digraph&) { }
 		        /// Node -> NodeIt conversion.
 		        /// Sets the iterator to the node of \c the digraph pointed by
 			/// the trivial iterator.
 		        /// This feature necessitates that each time we
 		        /// iterate the arc-set, the iteration order is the same.
 		        NodeIt(const Digraph&, const Node&) { }
 		        /// Next node.
 		        /// Assign the iterator to the next node.
 		        ///
 		        NodeIt& operator++() { return *this; }
 		      };
 		      /// Class for identifying an arc of the digraph
 		      /// This class identifies an arc of the digraph. It also serves
 		      /// as a base class of the arc iterators,
 		      /// thus they will convert to this type.
 		      class Arc {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        Arc() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        Arc(const Arc&) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        Arc(Invalid) { }
 		        /// Equality operator
 		        /// Two iterators are equal if and only if they point to the
 		        /// same object or both are invalid.
 		        bool operator==(Arc) const { return true; }
 		        /// Inequality operator
 		        /// \sa operator==(Arc n)
 		        ///
 		        bool operator!=(Arc) const { return true; }
 			/// Artificial ordering operator.
 			/// To allow the use of digraph descriptors as key type in std::map or
 			/// similar associative container we require this.
 			///
 			/// \note This operator only have to define some strict ordering of
 			/// the items; this order has nothing to do with the iteration
 			/// ordering of the items.
 			bool operator<(Arc) const { return false; }
 		      };
 		      /// This iterator goes trough the outgoing arcs of a node.
 		      /// This iterator goes trough the \e outgoing arcs of a certain node
 		      /// of a digraph.
 		      /// Its usage is quite simple, for example you can count the number
 		      /// of outgoing arcs of a node \c n
 		      /// in digraph \c g of type \c Digraph as follows.
 		      ///\code
 		      /// int count=0;
 		      /// for (Digraph::OutArcIt e(g, n); e!=INVALID; ++e) ++count;
 		      ///\endcode
 		      class OutArcIt : public Arc {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        OutArcIt() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        OutArcIt(const OutArcIt& e) : Arc(e) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        OutArcIt(Invalid) { }
 		        /// This constructor sets the iterator to the first outgoing arc.
 		        /// This constructor sets the iterator to the first outgoing arc of
 		        /// the node.
 		        OutArcIt(const Digraph&, const Node&) { }
 		        /// Arc -> OutArcIt conversion
 		        /// Sets the iterator to the value of the trivial iterator.
 			/// This feature necessitates that each time we
 		        /// iterate the arc-set, the iteration order is the same.
 		        OutArcIt(const Digraph&, const Arc&) { }
 		        ///Next outgoing arc
 		        /// Assign the iterator to the next
 		        /// outgoing arc of the corresponding node.
 		        OutArcIt& operator++() { return *this; }
 		      };
 		      /// This iterator goes trough the incoming arcs of a node.
 		      /// This iterator goes trough the \e incoming arcs of a certain node
 		      /// of a digraph.
 		      /// Its usage is quite simple, for example you can count the number
 		      /// of outgoing arcs of a node \c n
 		      /// in digraph \c g of type \c Digraph as follows.
 		      ///\code

lemon/concepts/graph.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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 graph_concepts
 		///\file
 		///\brief The concept of Undirected Graphs.
 		#ifndef LEMON_CONCEPT_GRAPH_H
 		#define LEMON_CONCEPT_GRAPH_H
 		#include <lemon/concepts/graph_components.h>
 		#include <lemon/concepts/graph.h>
 		#include <lemon/bits/utility.h>
 		namespace lemon {
 		  namespace concepts {
 		    /// \ingroup graph_concepts
 		    ///
 		    /// \brief Class describing the concept of Undirected Graphs.
 		    ///
 		    /// This class describes the common interface of all Undirected
 		    /// Graphs.
 		    ///
 		    /// As all concept describing classes it provides only interface
 		    /// without any sensible implementation. So any algorithm for
 		    /// undirected graph should compile with this class, but it will not
 		    /// run properly, of course.
 		    ///
 		    /// The LEMON undirected graphs also fulfill the concept of
 		    /// directed graphs (\ref lemon::concepts::Digraph "Digraph
 		    /// Concept"). Each edges can be seen as two opposite
 		    /// directed arc and consequently the undirected graph can be
 		    /// seen as the direceted graph of these directed arcs. The
 		    /// Graph has the Edge inner class for the edges and
 		    /// the Arc type for the directed arcs. The Arc type is
 		    /// convertible to Edge or inherited from it so from a directed
 		    /// arc we can get the represented edge.
 		    ///
 		    /// In the sense of the LEMON each edge has a default
 		    /// direction (it should be in every computer implementation,
 		    /// because the order of edge's nodes defines an
 		    /// orientation). With the default orientation we can define that
 		    /// the directed arc is forward or backward directed. With the \c
 		    /// direction() and \c direct() function we can get the direction
 		    /// of the directed arc and we can direct an edge.
 		    ///
 		    /// The EdgeIt is an iterator for the edges. We can use
 		    /// the EdgeMap to map values for the edges. The InArcIt and
 		    /// OutArcIt iterates on the same edges but with opposite
 		    /// direction. The IncEdgeIt iterates also on the same edges
 		    /// as the OutArcIt and InArcIt but it is not convertible to Arc just
 		    /// to Edge.
 		    class Graph {
 		    public:
 		      /// \brief The undirected graph should be tagged by the
 		      /// UndirectedTag.
 		      ///
 		      /// The undirected graph should be tagged by the UndirectedTag. This
 		      /// tag helps the enable_if technics to make compile time
 		      /// specializations for undirected graphs.
 		      typedef True UndirectedTag;
 		      /// \brief The base type of node iterators,
 		      /// or in other words, the trivial node iterator.
 		      ///
 		      /// This is the base type of each node iterator,
 		      /// thus each kind of node iterator converts to this.
 		      /// More precisely each kind of node iterator should be inherited
 		      /// from the trivial node iterator.
 		      class Node {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        Node() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        Node(const Node&) { }
 		        /// Invalid constructor \& conversion.
 		        /// This constructor initializes the iterator to be invalid.
 		        /// \sa Invalid for more details.
 		        Node(Invalid) { }
 		        /// Equality operator
 		        /// Two iterators are equal if and only if they point to the
 		        /// same object or both are invalid.
 		        bool operator==(Node) const { return true; }
 		        /// Inequality operator
 		        /// \sa operator==(Node n)
 		        ///
 		        bool operator!=(Node) const { return true; }
 			/// Artificial ordering operator.
 			/// To allow the use of graph descriptors as key type in std::map or
 			/// similar associative container we require this.
 			///
 			/// \note This operator only have to define some strict ordering of
 			/// the items; this order has nothing to do with the iteration
 			/// ordering of the items.
 			bool operator<(Node) const { return false; }
 		      };
 		      /// This iterator goes through each node.
 		      /// This iterator goes through each node.
 		      /// Its usage is quite simple, for example you can count the number
 		      /// of nodes in graph \c g of type \c Graph like this:
 		      ///\code
 		      /// int count=0;
 		      /// for (Graph::NodeIt n(g); n!=INVALID; ++n) ++count;
 		      ///\endcode
 		      class NodeIt : public Node {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        NodeIt() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        NodeIt(const NodeIt& n) : Node(n) { }
 		        /// Invalid constructor \& conversion.
 		        /// Initialize the iterator to be invalid.
 		        /// \sa Invalid for more details.
 		        NodeIt(Invalid) { }
 		        /// Sets the iterator to the first node.
 		        /// Sets the iterator to the first node of \c g.
 		        ///
 		        NodeIt(const Graph&) { }
 		        /// Node -> NodeIt conversion.
 		        /// Sets the iterator to the node of \c the graph pointed by
 			/// the trivial iterator.
 		        /// This feature necessitates that each time we
 		        /// iterate the arc-set, the iteration order is the same.
 		        NodeIt(const Graph&, const Node&) { }
 		        /// Next node.
 		        /// Assign the iterator to the next node.
 		        ///
 		        NodeIt& operator++() { return *this; }
 		      };
 		      /// The base type of the edge iterators.
 		      /// The base type of the edge iterators.
 		      ///
 		      class Edge {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        Edge() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        Edge(const Edge&) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        Edge(Invalid) { }
 		        /// Equality operator
 		        /// Two iterators are equal if and only if they point to the
 		        /// same object or both are invalid.
 		        bool operator==(Edge) const { return true; }
 		        /// Inequality operator
 		        /// \sa operator==(Edge n)
 		        ///
 		        bool operator!=(Edge) const { return true; }
 			/// Artificial ordering operator.
 			/// To allow the use of graph descriptors as key type in std::map or
 			/// similar associative container we require this.
 			///
 			/// \note This operator only have to define some strict ordering of
 			/// the items; this order has nothing to do with the iteration
 			/// ordering of the items.
 			bool operator<(Edge) const { return false; }
 		      };
 		      /// This iterator goes through each edge.
 		      /// This iterator goes through each edge of a graph.
 		      /// Its usage is quite simple, for example you can count the number
 		      /// of edges in a graph \c g of type \c Graph as follows:
 		      ///\code
 		      /// int count=0;
 		      /// for(Graph::EdgeIt e(g); e!=INVALID; ++e) ++count;
 		      ///\endcode
 		      class EdgeIt : public Edge {
 		      public:
 		        /// Default constructor
 		        /// @warning The default constructor sets the iterator
 		        /// to an undefined value.
 		        EdgeIt() { }
 		        /// Copy constructor.
 		        /// Copy constructor.
 		        ///
 		        EdgeIt(const EdgeIt& e) : Edge(e) { }
 		        /// Initialize the iterator to be invalid.
 		        /// Initialize the iterator to be invalid.
 		        ///
 		        EdgeIt(Invalid) { }
 		        /// This constructor sets the iterator to the first edge.
 		        /// This constructor sets the iterator to the first edge.
 		        EdgeIt(const Graph&) { }
 		        /// Edge -> EdgeIt conversion
 		        /// Sets the iterator to the value of the trivial iterator.
 		        /// This feature necessitates that each time we
 		        /// iterate the edge-set, the iteration order is the
 			/// same.
 		        EdgeIt(const Graph&, const Edge&) { }
 		        /// Next edge
 		        /// Assign the iterator to the next edge.
 		        EdgeIt& operator++() { return *this; }
 		      };

lemon/concepts/graph_components.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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 graph_concepts
 		///\file
 		///\brief The concept of graph components.
 		#ifndef LEMON_CONCEPT_GRAPH_COMPONENTS_H
 		#define LEMON_CONCEPT_GRAPH_COMPONENTS_H
 		#include <lemon/bits/invalid.h>
 		#include <lemon/concepts/maps.h>
 		#include <lemon/bits/alteration_notifier.h>
 		namespace lemon {
 		  namespace concepts {
 		    /// \brief Skeleton class for graph Node and Arc types
 		    ///
 		    /// This class describes the interface of Node and Arc (and Edge
 		    /// in undirected graphs) subtypes of graph types.
 		    ///
 		    /// \note This class is a template class so that we can use it to
 		    /// create graph skeleton classes. The reason for this is than Node
 		    /// and Arc types should \em not derive from the same base class.
 		    /// For Node you should instantiate it with character 'n' and for Arc
 		    /// with 'a'.
 		#ifndef DOXYGEN
 		    template <char _selector = '0'>
 		#endif
 		    class GraphItem {
 		    public:
 		      /// \brief Default constructor.
 		      ///
 		      /// \warning The default constructor is not required to set
 		      /// the item to some well-defined value. So you should consider it
 		      /// as uninitialized.
 		      GraphItem() {}
 		      /// \brief Copy constructor.
 		      ///
 		      /// Copy constructor.
 		      ///
 		      GraphItem(const GraphItem &) {}
 		      /// \brief Invalid constructor \& conversion.
 		      ///
 		      /// This constructor initializes the item to be invalid.
 		      /// \sa Invalid for more details.
 		      GraphItem(Invalid) {}
 		      /// \brief Assign operator for nodes.
 		      ///
 		      /// The nodes are assignable.
 		      ///
 		      GraphItem& operator=(GraphItem const&) { return *this; }
 		      /// \brief Equality operator.
 		      ///
 		      /// Two iterators are equal if and only if they represents the
 		      /// same node in the graph or both are invalid.
 		      bool operator==(GraphItem) const { return false; }
 		      /// \brief Inequality operator.
 		      ///
 		      /// \sa operator==(const Node& n)
 		      ///
 		      bool operator!=(GraphItem) const { return false; }
 		      /// \brief Artificial ordering operator.
 		      ///
 		      /// To allow the use of graph descriptors as key type in std::map or
 		      /// similar associative container we require this.
 		      ///
 		      /// \note This operator only have to define some strict ordering of
 		      /// the items; this order has nothing to do with the iteration
 		      /// ordering of the items.
 		      bool operator<(GraphItem) const { return false; }
 		      template<typename _GraphItem>
 		      struct Constraints {
 			void constraints() {
 			  _GraphItem i1;
 			  _GraphItem i2 = i1;
 			  _GraphItem i3 = INVALID;
 			  i1 = i2 = i3;
 			  bool b;
 			  //	  b = (ia == ib) && (ia != ib) && (ia < ib);
 			  b = (ia == ib) && (ia != ib);
 			  b = (ia == INVALID) && (ib != INVALID);
 		          b = (ia < ib);
+			}
 			const _GraphItem &ia;
 			const _GraphItem &ib;
 		      };
 		    };
 		    /// \brief An empty base directed graph class.
 		    ///
 		    /// This class provides the minimal set of features needed for a
 		    /// directed graph structure. All digraph concepts have to be
 		    /// conform to this base directed graph. It just provides types
 		    /// for nodes and arcs and functions to get the source and the
 		    /// target of the arcs.
 		    class BaseDigraphComponent {
 		    public:
 		      typedef BaseDigraphComponent Digraph;
 		      /// \brief Node class of the digraph.
 		      ///
 		      /// This class represents the Nodes of the digraph.
 		      ///
 		      typedef GraphItem<'n'> Node;
 		      /// \brief Arc class of the digraph.
 		      ///
 		      /// This class represents the Arcs of the digraph.
 		      ///
 		      typedef GraphItem<'e'> Arc;
 		      /// \brief Gives back the target node of an arc.
 		      ///
 		      /// Gives back the target node of an arc.
 		      ///
 		      Node target(const Arc&) const { return INVALID;}
 		      /// \brief Gives back the source node of an arc.
 		      ///
 		      /// Gives back the source node of an arc.
 		      ///
 		      Node source(const Arc&) const { return INVALID;}
 		      /// \brief Gives back the opposite node on the given arc.
 		      ///
 		      /// Gives back the opposite node on the given arc.
 		      Node oppositeNode(const Node&, const Arc&) const {
 		        return INVALID;
+		      }
 		      template <typename _Digraph>
 		      struct Constraints {
 			typedef typename _Digraph::Node Node;
 			typedef typename _Digraph::Arc Arc;
 			void constraints() {
 			  checkConcept<GraphItem<'n'>, Node>();
 			  checkConcept<GraphItem<'a'>, Arc>();
+			  {
 			    Node n;
 			    Arc e(INVALID);
 			    n = digraph.source(e);
 			    n = digraph.target(e);
 		            n = digraph.oppositeNode(n, e);
+			  }
+			}
 			const _Digraph& digraph;
 		      };
 		    };
 		    /// \brief An empty base undirected graph class.
 		    ///
 		    /// This class provides the minimal set of features needed for an
 		    /// undirected graph structure. All undirected graph concepts have
 		    /// to be conform to this base graph. It just provides types for
 		    /// nodes, arcs and edges and functions to get the
 		    /// source and the target of the arcs and edges,
 		    /// conversion from arcs to edges and function to get
 		    /// both direction of the edges.
 		    class BaseGraphComponent : public BaseDigraphComponent {
 		    public:
 		      typedef BaseDigraphComponent::Node Node;
 		      typedef BaseDigraphComponent::Arc Arc;
 		      /// \brief Undirected arc class of the graph.
 		      ///
 		      /// This class represents the edges of the graph.
 		      /// The undirected graphs can be used as a directed graph which
 		      /// for each arc contains the opposite arc too so the graph is
 		      /// bidirected. The edge represents two opposite
 		      /// directed arcs.
 		      class Edge : public GraphItem<'u'> {
 		      public:
 		        typedef GraphItem<'u'> Parent;
 		        /// \brief Default constructor.
 		        ///
 		        /// \warning The default constructor is not required to set
 		        /// the item to some well-defined value. So you should consider it
 		        /// as uninitialized.
 		        Edge() {}
 		        /// \brief Copy constructor.
 		        ///
 		        /// Copy constructor.
 		        ///
 		        Edge(const Edge &) : Parent() {}
 		        /// \brief Invalid constructor \& conversion.
 		        ///
 		        /// This constructor initializes the item to be invalid.
 		        /// \sa Invalid for more details.
 		        Edge(Invalid) {}
 		        /// \brief Converter from arc to edge.
 		        ///
 		        /// Besides the core graph item functionality each arc should
 		        /// be convertible to the represented edge.
 		        Edge(const Arc&) {}
 		        /// \brief Assign arc to edge.
 		        ///
 		        /// Besides the core graph item functionality each arc should
 		        /// be convertible to the represented edge.
 		        Edge& operator=(const Arc&) { return *this; }
 		      };
 		      /// \brief Returns the direction of the arc.
 		      ///
 		      /// Returns the direction of the arc. Each arc represents an
 		      /// edge with a direction. It gives back the
 		      /// direction.
 		      bool direction(const Arc&) const { return true; }
 		      /// \brief Returns the directed arc.
 		      ///
 		      /// Returns the directed arc from its direction and the
 		      /// represented edge.
 		      Arc direct(const Edge&, bool) const { return INVALID;}
 		      /// \brief Returns the directed arc.
 		      ///
 		      /// Returns the directed arc from its source and the
 		      /// represented edge.
 		      Arc direct(const Edge&, const Node&) const { return INVALID;}
 		      /// \brief Returns the opposite arc.
 		      ///
 		      /// Returns the opposite arc. It is the arc representing the
 		      /// same edge and has opposite direction.
 		      Arc oppositeArc(const Arc&) const { return INVALID;}
 		      /// \brief Gives back one ending of an edge.
 		      ///
 		      /// Gives back one ending of an edge.
 		      Node u(const Edge&) const { return INVALID;}
 		      /// \brief Gives back the other ending of an edge.

lemon/concepts/heap.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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 concept
 		///\file
 		///\brief The concept of heaps.
 		#ifndef LEMON_CONCEPT_HEAP_H
 		#define LEMON_CONCEPT_HEAP_H
 		#include <lemon/bits/invalid.h>
 		namespace lemon {
 		  namespace concepts {
 		    /// \addtogroup concept
 		    /// @{
 		    /// \brief The heap concept.
 		    ///
 		    /// Concept class describing the main interface of heaps.
 		    template <typename Priority, typename ItemIntMap>
 		    class Heap {
 		    public:
 		      /// Type of the items stored in the heap.
 		      typedef typename ItemIntMap::Key Item;
 		      /// Type of the priorities.
 		      typedef Priority Prio;
 		      /// \brief Type to represent the states of the items.
 		      ///
 		      /// Each item has a state associated to it. It can be "in heap",
 		      /// "pre heap" or "post heap". The later two are indifferent
 		      /// from the point of view of the heap, but may be useful for
 		      /// the user.
 		      ///
 		      /// The \c ItemIntMap must be initialized in such a way, that it
 		      /// assigns \c PRE_HEAP (<tt>-1</tt>) to every item.
 		      enum State {
 			IN_HEAP = 0,
 			PRE_HEAP = -1,
 			POST_HEAP = -2
 		      };
 		      /// \brief The constructor.
 		      ///
 		      /// The constructor.
 		      /// \param map A map that assigns \c int values to keys of type
 		      /// \c Item. It is used internally by the heap implementations to
 		      /// handle the cross references. The assigned value must be
 		      /// \c PRE_HEAP (<tt>-1</tt>) for every item.
 		      explicit Heap(ItemIntMap &map) {}
 		      /// \brief The number of items stored in the heap.
 		      ///
 		      /// Returns the number of items stored in the heap.
 		      int size() const { return 0; }
 		      /// \brief Checks if the heap is empty.
 		      ///
 		      /// Returns \c true if the heap is empty.
 		      bool empty() const { return false; }
 		      /// \brief Makes the heap empty.
 		      ///
 		      /// Makes the heap empty.
 		      void clear();
 		      /// \brief Inserts an item into the heap with the given priority.
 		      ///
 		      /// Inserts the given item into the heap with the given priority.
 		      /// \param i The item to insert.
 		      /// \param p The priority of the item.
 		      void push(const Item &i, const Prio &p) {}
 		      /// \brief Returns the item having minimum priority.
 		      ///
 		      /// Returns the item having minimum priority.
 		      /// \pre The heap must be non-empty.
 		      Item top() const {}
 		      /// \brief The minimum priority.
 		      ///
 		      /// Returns the minimum priority.
 		      /// \pre The heap must be non-empty.
 		      Prio prio() const {}
 		      /// \brief Removes the item having minimum priority.
 		      ///
 		      /// Removes the item having minimum priority.
 		      /// \pre The heap must be non-empty.
 		      void pop() {}
 		      /// \brief Removes an item from the heap.
 		      ///
 		      /// Removes the given item from the heap if it is already stored.
 		      /// \param i The item to delete.
 		      void erase(const Item &i) {}
 		      /// \brief The priority of an item.
 		      ///
 		      /// Returns the priority of the given item.
 		      /// \pre \c i must be in the heap.
 		      /// \param i The item.
 		      Prio operator[](const Item &i) const {}
 		      /// \brief Sets the priority of an item or inserts it, if it is
 		      /// not stored in the heap.
 		      ///
 		      /// This method sets the priority of the given item if it is
 		      /// already stored in the heap.
 		      /// Otherwise it inserts the given item with the given priority.
 		      ///
 		      /// It may throw an \ref UnderflowPriorityException.
 		      /// \param i The item.
 		      /// \param p The priority.
 		      void set(const Item &i, const Prio &p) {}
 		      /// \brief Decreases the priority of an item to the given value.
 		      ///
 		      /// Decreases the priority of an item to the given value.
 		      /// \pre \c i must be stored in the heap with priority at least \c p.
 		      /// \param i The item.
 		      /// \param p The priority.
 		      void decrease(const Item &i, const Prio &p) {}
 		      /// \brief Increases the priority of an item to the given value.
 		      ///
 		      /// Increases the priority of an item to the given value.
 		      /// \pre \c i must be stored in the heap with priority at most \c p.
 		      /// \param i The item.
 		      /// \param p The priority.
 		      void increase(const Item &i, const Prio &p) {}
 		      /// \brief Returns if an item is in, has already been in, or has
 		      /// never been in the heap.
 		      ///
 		      /// This method returns \c PRE_HEAP if the given item has never
 		      /// been in the heap, \c IN_HEAP if it is in the heap at the moment,
 		      /// and \c POST_HEAP otherwise.
 		      /// In the latter case it is possible that the item will get back
 		      /// to the heap again.
 		      /// \param i The item.
 		      State state(const Item &i) const {}
 		      /// \brief Sets the state of an item in the heap.
 		      ///
 		      /// Sets the state of the given item in the heap. It can be used
 		      /// to manually clear the heap when it is important to achive the
 		      /// better time complexity.
 		      /// \param i The item.
 		      /// \param st The state. It should not be \c IN_HEAP.
 		      void state(const Item& i, State st) {}
 		      template <typename _Heap>
 		      struct Constraints {
 		      public:
 			void constraints() {
 			  typedef typename _Heap::Item OwnItem;
 			  typedef typename _Heap::Prio OwnPrio;
 			  typedef typename _Heap::State OwnState;
 			  Item item;
 			  Prio prio;
 			  item=Item();
 			  prio=Prio();
 			  ignore_unused_variable_warning(item);
 			  ignore_unused_variable_warning(prio);
 			  OwnItem own_item;
 			  OwnPrio own_prio;
 			  OwnState own_state;
 			  own_item=Item();
 			  own_prio=Prio();
 			  ignore_unused_variable_warning(own_item);
 			  ignore_unused_variable_warning(own_prio);
 			  ignore_unused_variable_warning(own_state);
 			  _Heap heap1(map);
 			  _Heap heap2 = heap1;
 			  ignore_unused_variable_warning(heap1);
 			  ignore_unused_variable_warning(heap2);
 			  int s = heap.size();
 			  ignore_unused_variable_warning(s);
 			  bool e = heap.empty();
 			  ignore_unused_variable_warning(e);
 			  prio = heap.prio();
 			  item = heap.top();
 			  prio = heap[item];
 			  own_prio = heap.prio();
 			  own_item = heap.top();
 			  own_prio = heap[own_item];
 			  heap.push(item, prio);
 			  heap.push(own_item, own_prio);
 			  heap.pop();
 			  heap.set(item, prio);
 			  heap.decrease(item, prio);
 			  heap.increase(item, prio);
 			  heap.set(own_item, own_prio);
 			  heap.decrease(own_item, own_prio);
 			  heap.increase(own_item, own_prio);
 			  heap.erase(item);
 			  heap.erase(own_item);
 			  heap.clear();
 			  own_state = heap.state(own_item);
 			  heap.state(own_item, own_state);
 			  own_state = _Heap::PRE_HEAP;
 			  own_state = _Heap::IN_HEAP;
 			  own_state = _Heap::POST_HEAP;
+			}
 			_Heap& heap;
 			ItemIntMap& map;
 		      };
 		    };
 		    /// @}
 		  } // namespace lemon
+		}
 		#endif // LEMON_CONCEPT_PATH_H

lemon/concepts/maps.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_CONCEPT_MAPS_H
 		#define LEMON_CONCEPT_MAPS_H
 		#include <lemon/bits/utility.h>
 		#include <lemon/concept_check.h>
 		///\ingroup concept
 		///\file
 		///\brief The concept of maps.
 		namespace lemon {
 		  namespace concepts {
 		    /// \addtogroup concept
 		    /// @{
 		    /// Readable map concept
 		    /// Readable map concept.
 		    ///
 		    template<typename K, typename T>
 		    class ReadMap
+		    {
 		    public:
 		      /// The key type of the map.
 		      typedef K Key;
 		      /// The value type of the map. (The type of objects associated with the keys).
 		      typedef T Value;
 		      /// Returns the value associated with the given key.
 		      Value operator[](const Key &) const {
 		        return *static_cast<Value *>(0);
+		      }
 		      template<typename _ReadMap>
 		      struct Constraints {
 			void constraints() {
 			  Value val = m[key];
 			  val = m[key];
 			  typename _ReadMap::Value own_val = m[own_key];
 			  own_val = m[own_key];
 			  ignore_unused_variable_warning(key);
 			  ignore_unused_variable_warning(val);
 			  ignore_unused_variable_warning(own_key);
 			  ignore_unused_variable_warning(own_val);
+			}
 			const Key& key;
 			const typename _ReadMap::Key& own_key;
 			const _ReadMap& m;
 		      };
 		    };
 		    /// Writable map concept
 		    /// Writable map concept.
 		    ///
 		    template<typename K, typename T>
 		    class WriteMap
+		    {
 		    public:
 		      /// The key type of the map.
 		      typedef K Key;
 		      /// The value type of the map. (The type of objects associated with the keys).
 		      typedef T Value;
 		      /// Sets the value associated with the given key.
 		      void set(const Key &, const Value &) {}
 		      /// Default constructor.
 		      WriteMap() {}
 		      template <typename _WriteMap>
 		      struct Constraints {
 			void constraints() {
 			  m.set(key, val);
 			  m.set(own_key, own_val);
 			  ignore_unused_variable_warning(key);
 			  ignore_unused_variable_warning(val);
 			  ignore_unused_variable_warning(own_key);
 			  ignore_unused_variable_warning(own_val);
+			}
 			const Key& key;
 			const Value& val;
 			const typename _WriteMap::Key& own_key;
 			const typename _WriteMap::Value& own_val;
 			_WriteMap& m;
 		      };
 		    };
 		    /// Read/writable map concept
 		    /// Read/writable map concept.
 		    ///
 		    template<typename K, typename T>
 		    class ReadWriteMap : public ReadMap<K,T>,
 					 public WriteMap<K,T>
+		    {
 		    public:
 		      /// The key type of the map.
 		      typedef K Key;
 		      /// The value type of the map. (The type of objects associated with the keys).
 		      typedef T Value;
 		      /// Returns the value associated with the given key.
 		      Value operator[](const Key &) const {
 		        return *static_cast<Value *>(0);
+		      }
 		      /// Sets the value associated with the given key.
 		      void set(const Key &, const Value &) {}
 		      template<typename _ReadWriteMap>
 		      struct Constraints {
 			void constraints() {
 			  checkConcept<ReadMap<K, T>, _ReadWriteMap >();
 			  checkConcept<WriteMap<K, T>, _ReadWriteMap >();
+			}
 		      };
 		    };
 		    /// Dereferable map concept
 		    /// Dereferable map concept.
 		    ///
 		    template<typename K, typename T, typename R, typename CR>
 		    class ReferenceMap : public ReadWriteMap<K,T>
+		    {
 		    public:
 		      /// Tag for reference maps.
 		      typedef True ReferenceMapTag;
 		      /// The key type of the map.
 		      typedef K Key;
 		      /// The value type of the map. (The type of objects associated with the keys).
 		      typedef T Value;
 		      /// The reference type of the map.
 		      typedef R Reference;
 		      /// The const reference type of the map.
 		      typedef CR ConstReference;
 		    public:
 		      /// Returns a reference to the value associated with the given key.
 		      Reference operator[](const Key &) {
 		        return *static_cast<Value *>(0);
+		      }
 		      /// Returns a const reference to the value associated with the given key.
 		      ConstReference operator[](const Key &) const {
 		        return *static_cast<Value *>(0);
+		      }
 		      /// Sets the value associated with the given key.
 		      void set(const Key &k,const Value &t) { operator[](k)=t; }
 		      template<typename _ReferenceMap>
 		      struct Constraints {
 			void constraints() {
 			  checkConcept<ReadWriteMap<K, T>, _ReferenceMap >();
 			  ref = m[key];
 			  m[key] = val;
 			  m[key] = ref;
 			  m[key] = cref;
 			  own_ref = m[own_key];
 			  m[own_key] = own_val;
 			  m[own_key] = own_ref;
 			  m[own_key] = own_cref;
 			  m[key] = m[own_key];
 			  m[own_key] = m[key];
+			}
 			const Key& key;
 			Value& val;
 			Reference ref;
 			ConstReference cref;
 			const typename _ReferenceMap::Key& own_key;
 			typename _ReferenceMap::Value& own_val;
 			typename _ReferenceMap::Reference own_ref;
 			typename _ReferenceMap::ConstReference own_cref;
 			_ReferenceMap& m;
 		      };
 		    };
 		    // @}
 		  } //namespace concepts
 		} //namespace lemon
 		#endif // LEMON_CONCEPT_MAPS_H

lemon/concepts/path.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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 concept
 		///\file
 		///\brief Classes for representing paths in digraphs.
 		///
 		///\todo Iterators have obsolete style
 		#ifndef LEMON_CONCEPT_PATH_H
 		#define LEMON_CONCEPT_PATH_H
 		#include <lemon/bits/invalid.h>
 		#include <lemon/bits/utility.h>
 		#include <lemon/concept_check.h>
 		namespace lemon {
 		  namespace concepts {
 		    /// \addtogroup concept
 		    /// @{
 		    /// \brief A skeleton structure for representing directed paths in
 		    /// a digraph.
 		    ///
 		    /// A skeleton structure for representing directed paths in a
 		    /// digraph.
 		    /// \tparam _Digraph The digraph type in which the path is.
 		    ///
 		    /// In a sense, the path can be treated as a list of arcs. The
 		    /// lemon path type stores just this list. As a consequence it
 		    /// cannot enumerate the nodes in the path and the zero length
 		    /// paths cannot store the source.
 		    ///
 		    template <typename _Digraph>
 		    class Path {
 		    public:
 		      /// Type of the underlying digraph.
 		      typedef _Digraph Digraph;
 		      /// Arc type of the underlying digraph.
 		      typedef typename Digraph::Arc Arc;
 		      class ArcIt;
 		      /// \brief Default constructor
 		      Path() {}
 		      /// \brief Template constructor
 		      template <typename CPath>
 		      Path(const CPath& cpath) {}
 		      /// \brief Template assigment
 		      template <typename CPath>
 		      Path& operator=(const CPath& cpath) {}
 		      /// Length of the path ie. the number of arcs in the path.
 		      int length() const { return 0;}
 		      /// Returns whether the path is empty.
 		      bool empty() const { return true;}
 		      /// Resets the path to an empty path.
 		      void clear() {}
 		      /// \brief Lemon style iterator for path arcs
 		      ///
 		      /// This class is used to iterate on the arcs of the paths.
 		      class ArcIt {
 		      public:
 			/// Default constructor
 			ArcIt() {}
 			/// Invalid constructor
 			ArcIt(Invalid) {}
 			/// Constructor for first arc
 			ArcIt(const Path &) {}
 		        /// Conversion to Arc
 			operator Arc() const { return INVALID; }
 			/// Next arc
 			ArcIt& operator++() {return *this;}
 			/// Comparison operator
 			bool operator==(const ArcIt&) const {return true;}
 			/// Comparison operator
 			bool operator!=(const ArcIt&) const {return true;}
 		 	/// Comparison operator
 		 	bool operator<(const ArcIt&) const {return false;}
 		      };
 		      template <typename _Path>
 		      struct Constraints {
 		        void constraints() {
 		          Path<Digraph> pc;
 		          _Path p, pp(pc);
 		          int l = p.length();
 		          int e = p.empty();
 		          p.clear();
 		          p = pc;
 		          typename _Path::ArcIt id, ii(INVALID), i(p);
 		          ++i;
 		          typename Digraph::Arc ed = i;
 		          e = (i == ii);
 		          e = (i != ii);
 		          e = (i < ii);
 		          ignore_unused_variable_warning(l);
 		          ignore_unused_variable_warning(pp);
 		          ignore_unused_variable_warning(e);
 		          ignore_unused_variable_warning(id);
 		          ignore_unused_variable_warning(ii);
 		          ignore_unused_variable_warning(ed);
+		        }
 		      };
 		    };
 		    namespace _path_bits {
 		      template <typename _Digraph, typename _Path, typename RevPathTag = void>
 		      struct PathDumperConstraints {
 		        void constraints() {
 		          int l = p.length();
 		          int e = p.empty();
 		          typename _Path::ArcIt id, i(p);
 		          ++i;
 		          typename _Digraph::Arc ed = i;
 		          e = (i == INVALID);
 		          e = (i != INVALID);
 		          ignore_unused_variable_warning(l);
 		          ignore_unused_variable_warning(e);
 		          ignore_unused_variable_warning(id);
 		          ignore_unused_variable_warning(ed);
+		        }
 		        _Path& p;
 		      };
 		      template <typename _Digraph, typename _Path>
 		      struct PathDumperConstraints<
 		        _Digraph, _Path,
 		        typename enable_if<typename _Path::RevPathTag, void>::type
 		      > {
 		        void constraints() {
 		          int l = p.length();
 		          int e = p.empty();
 		          typename _Path::RevArcIt id, i(p);
 		          ++i;
 		          typename _Digraph::Arc ed = i;
 		          e = (i == INVALID);
 		          e = (i != INVALID);
 		          ignore_unused_variable_warning(l);
 		          ignore_unused_variable_warning(e);
 		          ignore_unused_variable_warning(id);
 		          ignore_unused_variable_warning(ed);
+		        }
 		        _Path& p;
 		      };
+		    }
 		    /// \brief A skeleton structure for path dumpers.
 		    ///
 		    /// A skeleton structure for path dumpers. The path dumpers are
 		    /// the generalization of the paths. The path dumpers can
 		    /// enumerate the arcs of the path wheter in forward or in
 		    /// backward order.  In most time these classes are not used
 		    /// directly rather it used to assign a dumped class to a real
 		    /// path type.
 		    ///
 		    /// The main purpose of this concept is that the shortest path
 		    /// algorithms can enumerate easily the arcs in reverse order.
 		    /// If we would like to give back a real path from these
 		    /// algorithms then we should create a temporarly path object. In
 		    /// Lemon such algorithms gives back a path dumper what can
 		    /// assigned to a real path and the dumpers can be implemented as
 		    /// an adaptor class to the predecessor map.
 		    /// \tparam _Digraph  The digraph type in which the path is.
 		    ///
 		    /// The paths can be constructed from any path type by a
 		    /// template constructor or a template assignment operator.
 		    ///
 		    template <typename _Digraph>
 		    class PathDumper {
 		    public:
 		      /// Type of the underlying digraph.
 		      typedef _Digraph Digraph;
 		      /// Arc type of the underlying digraph.
 		      typedef typename Digraph::Arc Arc;
 		      /// Length of the path ie. the number of arcs in the path.
 		      int length() const { return 0;}
 		      /// Returns whether the path is empty.
 		      bool empty() const { return true;}
 		      /// \brief Forward or reverse dumping
 		      ///
 		      /// If the RevPathTag is defined and true then reverse dumping
 		      /// is provided in the path dumper. In this case instead of the
 		      /// ArcIt the RevArcIt iterator should be implemented in the
 		      /// dumper.
 		      typedef False RevPathTag;
 		      /// \brief Lemon style iterator for path arcs
 		      ///
 		      /// This class is used to iterate on the arcs of the paths.
 		      class ArcIt {
 		      public:
 			/// Default constructor
 			ArcIt() {}
 			/// Invalid constructor
 			ArcIt(Invalid) {}
 			/// Constructor for first arc
 			ArcIt(const PathDumper&) {}
 		        /// Conversion to Arc
 			operator Arc() const { return INVALID; }
 			/// Next arc
 			ArcIt& operator++() {return *this;}
 			/// Comparison operator
 			bool operator==(const ArcIt&) const {return true;}
 			/// Comparison operator
 			bool operator!=(const ArcIt&) const {return true;}
 		 	/// Comparison operator
 		 	bool operator<(const ArcIt&) const {return false;}

lemon/counter.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_COUNTER_H
 		#define LEMON_COUNTER_H
 		#include <string>
 		#include <iostream>
 		///\ingroup timecount
 		///\file
 		///\brief Tools for counting steps and events
 		namespace lemon
+		{
 		  template<class P> class _NoSubCounter;
 		  template<class P>
 		  class _SubCounter
+		  {
 		    P &_parent;
 		    std::string _title;
 		    std::ostream &_os;
 		    int count;
 		  public:
 		    typedef _SubCounter<_SubCounter<P> > SubCounter;
 		    typedef _NoSubCounter<_SubCounter<P> > NoSubCounter;
 		    _SubCounter(P &parent)
 		      : _parent(parent), _title(), _os(std::cerr), count(0) {}
 		    _SubCounter(P &parent,std::string title,std::ostream &os=std::cerr)
 		      : _parent(parent), _title(title), _os(os), count(0) {}
 		    _SubCounter(P &parent,const char *title,std::ostream &os=std::cerr)
 		      : _parent(parent), _title(title), _os(os), count(0) {}
 		    ~_SubCounter() {
 		      _os << _title << count <<std::endl;
 		      _parent+=count;
+		    }
 		    _SubCounter &operator++() { count++; return *this;}
 		    int operator++(int) { return count++; }
 		    _SubCounter &operator--() { count--; return *this;}
 		    int operator--(int) { return count--; }
 		    _SubCounter &operator+=(int c) { count+=c; return *this;}
 		    _SubCounter &operator-=(int c) { count-=c; return *this;}
 		    operator int() {return count;}
 		  };
 		  template<class P>
 		  class _NoSubCounter
+		  {
 		    P &_parent;
 		  public:
 		    typedef _NoSubCounter<_NoSubCounter<P> > SubCounter;
 		    typedef _NoSubCounter<_NoSubCounter<P> > NoSubCounter;
 		    _NoSubCounter(P &parent) :_parent(parent) {}
 		    _NoSubCounter(P &parent,std::string,std::ostream &)
 		      :_parent(parent) {}
 		    _NoSubCounter(P &parent,std::string)
 		      :_parent(parent) {}
 		    _NoSubCounter(P &parent,const char *,std::ostream &)
 		      :_parent(parent) {}
 		    _NoSubCounter(P &parent,const char *)
 		      :_parent(parent) {}
 		    ~_NoSubCounter() {}
 		    _NoSubCounter &operator++() { ++_parent; return *this;}
 		    int operator++(int) { _parent++; return 0;}
 		    _NoSubCounter &operator--() { --_parent; return *this;}
 		    int operator--(int) { _parent--; return 0;}
 		    _NoSubCounter &operator+=(int c) { _parent+=c; return *this;}
 		    _NoSubCounter &operator-=(int c) { _parent-=c; return *this;}
 		    operator int() {return 0;}
 		  };
 		  /// \addtogroup timecount
 		  /// @{
 		  /// A counter class
 		  /// This class makes it easier to count certain events (e.g. for debug
 		  /// reasons).
 		  /// You can increment or decrement the counter using \c operator++,
 		  /// \c operator--, \c operator+= and \c operator-=. You can also
 		  /// define subcounters for the different phases of the algorithm or
 		  /// for different types of operations.
 		  /// A report containing the given title and the value of the counter
 		  /// is automatically printed on destruction.
 		  ///
 		  /// The following example shows the usage of counters and subcounters.
 		  /// \code
 		  /// // Bubble sort
 		  /// std::vector<T> v;
 		  /// ...
 		  /// Counter op("Operations: ");
 		  /// Counter::SubCounter as(op, "Assignments: ");
 		  /// Counter::SubCounter co(op, "Comparisons: ");
 		  /// for (int i = v.size()-1; i > 0; --i) {
 		  ///   for (int j = 0; j < i; ++j) {
 		  ///     if (v[j] > v[j+1]) {
 		  ///       T tmp = v[j];
 		  ///       v[j] = v[j+1];
 		  ///       v[j+1] = tmp;
 		  ///       as += 3;          // three assignments
 		  ///     }
 		  ///     ++co;               // one comparison
 		  ///   }
 		  /// }
 		  /// \endcode
 		  ///
 		  /// This code prints out something like that:
 		  /// \code
 		  /// Comparisons: 45
 		  /// Assignments: 57
 		  /// Operations: 102
 		  /// \endcode
 		  ///
 		  /// \sa NoCounter
 		  class Counter
+		  {
 		    std::string _title;
 		    std::ostream &_os;
 		    int count;
 		  public:
 		    /// SubCounter class
 		    /// This class can be used to setup subcounters for a \ref Counter
 		    /// to have finer reports. A subcounter provides exactly the same
 		    /// operations as the main \ref Counter, but it also increments and
 		    /// decrements the value of its parent.
 		    /// Subcounters can also have subcounters.
 		    ///
 		    /// The parent counter must be given as the first parameter of the
 		    /// constructor. Apart from that a title and an \c ostream object
 		    /// can also be given just like for the main \ref Counter.
 		    ///
 		    /// A report containing the given title and the value of the
 		    /// subcounter is automatically printed on destruction. If you
 		    /// would like to turn off this report, use \ref NoSubCounter
 		    /// instead.
 		    ///
 		    /// \sa NoSubCounter
 		    typedef _SubCounter<Counter> SubCounter;
 		    /// SubCounter class without printing report on destruction
 		    /// This class can be used to setup subcounters for a \ref Counter.
 		    /// It is the same as \ref SubCounter but it does not print report
 		    /// on destruction. (It modifies the value of its parent, so 'No'
 		    /// only means 'do not print'.)
 		    ///
 		    /// Replacing \ref SubCounter "SubCounter"s with \ref NoSubCounter
 		    /// "NoSubCounter"s makes it possible to turn off reporting
 		    /// subcounter values without actually removing the definitions
 		    /// and the increment or decrement operators.
 		    ///
 		    /// \sa SubCounter
 		    typedef _NoSubCounter<Counter> NoSubCounter;
 		    /// Constructor.
 		    Counter() : _title(), _os(std::cerr), count(0) {}
 		    /// Constructor.
 		    Counter(std::string title,std::ostream &os=std::cerr)
 		      : _title(title), _os(os), count(0) {}
 		    /// Constructor.
 		    Counter(const char *title,std::ostream &os=std::cerr)
 		      : _title(title), _os(os), count(0) {}
 		    /// Destructor. Prints the given title and the value of the counter.
 		    ~Counter() {
 		      _os << _title << count <<std::endl;
+		    }
 		    ///\e
 		    Counter &operator++() { count++; return *this;}
 		    ///\e
 		    int operator++(int) { return count++;}
 		    ///\e
 		    Counter &operator--() { count--; return *this;}
 		    ///\e
 		    int operator--(int) { return count--;}
 		    ///\e
 		    Counter &operator+=(int c) { count+=c; return *this;}
 		    ///\e
 		    Counter &operator-=(int c) { count-=c; return *this;}
 		    /// Resets the counter to the given value.
 		    /// Resets the counter to the given value.
 		    /// \note This function does not reset the values of
 		    /// \ref SubCounter "SubCounter"s but it resets \ref NoSubCounter
 		    /// "NoSubCounter"s along with the main counter.
 		    void reset(int c=0) {count=c;}
 		    /// Returns the value of the counter.
 		    operator int() {return count;}
 		  };
 		  /// 'Do nothing' version of Counter.
 		  /// This class can be used in the same way as \ref Counter however it
 		  /// does not count at all and does not print report on destruction.
 		  ///
 		  /// Replacing a \ref Counter with a \ref NoCounter makes it possible
 		  /// to turn off all counting and reporting (SubCounters should also
 		  /// be replaced with NoSubCounters), so it does not affect the
 		  /// efficiency of the program at all.
 		  ///
 		  /// \sa Counter
 		  class NoCounter
+		  {
 		  public:
 		    typedef _NoSubCounter<NoCounter> SubCounter;
 		    typedef _NoSubCounter<NoCounter> NoSubCounter;
 		    NoCounter() {}
 		    NoCounter(std::string,std::ostream &) {}
 		    NoCounter(const char *,std::ostream &) {}
 		    NoCounter(std::string) {}
 		    NoCounter(const char *) {}
 		    NoCounter &operator++() { return *this; }
 		    int operator++(int) { return 0; }
 		    NoCounter &operator--() { return *this; }
 		    int operator--(int) { return 0; }
 		    NoCounter &operator+=(int) { return *this;}
 		    NoCounter &operator-=(int) { return *this;}
 		    void reset(int) {}
 		    void reset() {}
 		    operator int() {return 0;}
 		  };
 		  ///@}
+		}
 		#endif

lemon/dfs.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_DFS_H
 		#define LEMON_DFS_H
 		///\ingroup search
 		///\file
 		///\brief Dfs algorithm.
 		#include <lemon/list_graph.h>
 		#include <lemon/graph_utils.h>
 		#include <lemon/bits/path_dump.h>
 		#include <lemon/bits/invalid.h>
 		#include <lemon/error.h>
 		#include <lemon/maps.h>
 		#include <lemon/concept_check.h>
 		namespace lemon {
 		  ///Default traits class of Dfs class.
 		  ///Default traits class of Dfs class.
 		  ///\tparam GR Digraph type.
 		  template<class GR>
 		  struct DfsDefaultTraits
+		  {
 		    ///The digraph type the algorithm runs on.
 		    typedef GR Digraph;
 		    ///\brief The type of the map that stores the last
 		    ///arcs of the %DFS paths.
 		    ///
 		    ///The type of the map that stores the last
 		    ///arcs of the %DFS paths.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///
 		    typedef typename Digraph::template NodeMap<typename GR::Arc> PredMap;
 		    ///Instantiates a PredMap.
 		    ///This function instantiates a \ref PredMap.
 		    ///\param G is the digraph, to which we would like to define the PredMap.
 		    ///\todo The digraph alone may be insufficient to initialize
 		    static PredMap *createPredMap(const GR &G)
+		    {
 		      return new PredMap(G);
+		    }
 		    ///The type of the map that indicates which nodes are processed.
 		    ///The type of the map that indicates which nodes are processed.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///\todo named parameter to set this type, function to read and write.
 		    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
 		    ///Instantiates a ProcessedMap.
 		    ///This function instantiates a \ref ProcessedMap.
 		    ///\param g is the digraph, to which
 		    ///we would like to define the \ref ProcessedMap
 		#ifdef DOXYGEN
 		    static ProcessedMap *createProcessedMap(const GR &g)
 		#else
 		    static ProcessedMap *createProcessedMap(const GR &)
 		#endif
+		    {
 		      return new ProcessedMap();
+		    }
 		    ///The type of the map that indicates which nodes are reached.
 		    ///The type of the map that indicates which nodes are reached.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///\todo named parameter to set this type, function to read and write.
 		    typedef typename Digraph::template NodeMap<bool> ReachedMap;
 		    ///Instantiates a ReachedMap.
 		    ///This function instantiates a \ref ReachedMap.
 		    ///\param G is the digraph, to which
 		    ///we would like to define the \ref ReachedMap.
 		    static ReachedMap *createReachedMap(const GR &G)
+		    {
 		      return new ReachedMap(G);
+		    }
 		    ///The type of the map that stores the dists of the nodes.
 		    ///The type of the map that stores the dists of the nodes.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///
 		    typedef typename Digraph::template NodeMap<int> DistMap;
 		    ///Instantiates a DistMap.
 		    ///This function instantiates a \ref DistMap.
 		    ///\param G is the digraph, to which we would like to define the \ref DistMap
 		    static DistMap *createDistMap(const GR &G)
+		    {
 		      return new DistMap(G);
+		    }
 		  };
 		  ///%DFS algorithm class.
 		  ///\ingroup search
 		  ///This class provides an efficient implementation of the %DFS algorithm.
 		  ///
 		  ///\tparam GR The digraph type the algorithm runs on. The default value is
 		  ///\ref ListDigraph. The value of GR is not used directly by Dfs, it
 		  ///is only passed to \ref DfsDefaultTraits.
 		  ///\tparam TR Traits class to set various data types used by the algorithm.
 		  ///The default traits class is
 		  ///\ref DfsDefaultTraits "DfsDefaultTraits<GR>".
 		  ///See \ref DfsDefaultTraits for the documentation of
 		  ///a Dfs traits class.
 		#ifdef DOXYGEN
 		  template <typename GR,
 			    typename TR>
 		#else
 		  template <typename GR=ListDigraph,
 			    typename TR=DfsDefaultTraits<GR> >
 		#endif
 		  class Dfs {
 		  public:
 		    /**
 		     * \brief \ref Exception for uninitialized parameters.
+		     *
 		     * This error represents problems in the initialization
 		     * of the parameters of the algorithms.
 		     */
 		    class UninitializedParameter : public lemon::UninitializedParameter {
 		    public:
 		      virtual const char* what() const throw() {
 			return "lemon::Dfs::UninitializedParameter";
+		      }
 		    };
 		    typedef TR Traits;
 		    ///The type of the underlying digraph.
 		    typedef typename TR::Digraph Digraph;
 		    ///\e
 		    typedef typename Digraph::Node Node;
 		    ///\e
 		    typedef typename Digraph::NodeIt NodeIt;
 		    ///\e
 		    typedef typename Digraph::Arc Arc;
 		    ///\e
 		    typedef typename Digraph::OutArcIt OutArcIt;
 		    ///\brief The type of the map that stores the last
 		    ///arcs of the %DFS paths.
 		    typedef typename TR::PredMap PredMap;
 		    ///The type of the map indicating which nodes are reached.
 		    typedef typename TR::ReachedMap ReachedMap;
 		    ///The type of the map indicating which nodes are processed.
 		    typedef typename TR::ProcessedMap ProcessedMap;
 		    ///The type of the map that stores the dists of the nodes.
 		    typedef typename TR::DistMap DistMap;
 		  private:
 		    /// Pointer to the underlying digraph.
 		    const Digraph *G;
 		    ///Pointer to the map of predecessors arcs.
 		    PredMap *_pred;
 		    ///Indicates if \ref _pred is locally allocated (\c true) or not.
 		    bool local_pred;
 		    ///Pointer to the map of distances.
 		    DistMap *_dist;
 		    ///Indicates if \ref _dist is locally allocated (\c true) or not.
 		    bool local_dist;
 		    ///Pointer to the map of reached status of the nodes.
 		    ReachedMap *_reached;
 		    ///Indicates if \ref _reached is locally allocated (\c true) or not.
 		    bool local_reached;
 		    ///Pointer to the map of processed status of the nodes.
 		    ProcessedMap *_processed;
 		    ///Indicates if \ref _processed is locally allocated (\c true) or not.
 		    bool local_processed;
 		    std::vector<typename Digraph::OutArcIt> _stack;
 		    int _stack_head;
 		    ///Creates the maps if necessary.
 		    ///\todo Better memory allocation (instead of new).
 		    void create_maps()
+		    {
 		      if(!_pred) {
 			local_pred = true;
 			_pred = Traits::createPredMap(*G);
+		      }
 		      if(!_dist) {
 			local_dist = true;
 			_dist = Traits::createDistMap(*G);
+		      }
 		      if(!_reached) {
 			local_reached = true;
 			_reached = Traits::createReachedMap(*G);
+		      }
 		      if(!_processed) {
 			local_processed = true;
 			_processed = Traits::createProcessedMap(*G);
+		      }
+		    }
 		  protected:
 		    Dfs() {}
 		  public:
 		    typedef Dfs Create;
 		    ///\name Named template parameters
 		    ///@{
 		    template <class T>
 		    struct DefPredMapTraits : public Traits {
 		      typedef T PredMap;
 		      static PredMap *createPredMap(const Digraph &G)
+		      {
 			throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///PredMap type
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting PredMap type
 		    ///
 		    template <class T>
 		    struct DefPredMap : public Dfs<Digraph, DefPredMapTraits<T> > {
 		      typedef Dfs<Digraph, DefPredMapTraits<T> > Create;
 		    };
 		    template <class T>
 		    struct DefDistMapTraits : public Traits {
 		      typedef T DistMap;
 		      static DistMap *createDistMap(const Digraph &)
+		      {
 			throw UninitializedParameter();
+		      }
 		    };
 		    ///\brief \ref named-templ-param "Named parameter" for setting
 		    ///DistMap type
 		    ///
 		    ///\ref named-templ-param "Named parameter" for setting DistMap

lemon/dijkstra.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_DIJKSTRA_H
 		#define LEMON_DIJKSTRA_H
 		///\ingroup shortest_path
 		///\file
 		///\brief Dijkstra algorithm.
 		#include <limits>
 		#include <lemon/list_graph.h>
 		#include <lemon/bin_heap.h>
 		#include <lemon/bits/path_dump.h>
 		#include <lemon/bits/invalid.h>
 		#include <lemon/error.h>
 		#include <lemon/maps.h>
 		namespace lemon {
 		  /// \brief Default OperationTraits for the Dijkstra algorithm class.
 		  ///
 		  /// It defines all computational operations and constants which are
 		  /// used in the Dijkstra algorithm.
 		  template <typename Value>
 		  struct DijkstraDefaultOperationTraits {
 		    /// \brief Gives back the zero value of the type.
 		    static Value zero() {
 		      return static_cast<Value>(0);
+		    }
 		    /// \brief Gives back the sum of the given two elements.
 		    static Value plus(const Value& left, const Value& right) {
 		      return left + right;
+		    }
 		    /// \brief Gives back true only if the first value less than the second.
 		    static bool less(const Value& left, const Value& right) {
 		      return left < right;
+		    }
 		  };
 		  /// \brief Widest path OperationTraits for the Dijkstra algorithm class.
 		  ///
 		  /// It defines all computational operations and constants which are
 		  /// used in the Dijkstra algorithm for widest path computation.
 		  template <typename Value>
 		  struct DijkstraWidestPathOperationTraits {
 		    /// \brief Gives back the maximum value of the type.
 		    static Value zero() {
 		      return std::numeric_limits<Value>::max();
+		    }
 		    /// \brief Gives back the minimum of the given two elements.
 		    static Value plus(const Value& left, const Value& right) {
 		      return std::min(left, right);
+		    }
 		    /// \brief Gives back true only if the first value less than the second.
 		    static bool less(const Value& left, const Value& right) {
 		      return left < right;
+		    }
 		  };
 		  ///Default traits class of Dijkstra class.
 		  ///Default traits class of Dijkstra class.
 		  ///\tparam GR Digraph type.
 		  ///\tparam LM Type of length map.
 		  template<class GR, class LM>
 		  struct DijkstraDefaultTraits
+		  {
 		    ///The digraph type the algorithm runs on.
 		    typedef GR Digraph;
 		    ///The type of the map that stores the arc lengths.
 		    ///The type of the map that stores the arc lengths.
 		    ///It must meet the \ref concepts::ReadMap "ReadMap" concept.
 		    typedef LM LengthMap;
 		    //The type of the length of the arcs.
 		    typedef typename LM::Value Value;
 		    /// Operation traits for Dijkstra algorithm.
 		    /// It defines the used operation by the algorithm.
 		    /// \see DijkstraDefaultOperationTraits
 		    typedef DijkstraDefaultOperationTraits<Value> OperationTraits;
 		    /// The cross reference type used by heap.
 		    /// The cross reference type used by heap.
 		    /// Usually it is \c Digraph::NodeMap<int>.
 		    typedef typename Digraph::template NodeMap<int> HeapCrossRef;
 		    ///Instantiates a HeapCrossRef.
 		    ///This function instantiates a \c HeapCrossRef.
 		    /// \param G is the digraph, to which we would like to define the
 		    /// HeapCrossRef.
 		    static HeapCrossRef *createHeapCrossRef(const GR &G)
+		    {
 		      return new HeapCrossRef(G);
+		    }
 		    ///The heap type used by Dijkstra algorithm.
 		    ///The heap type used by Dijkstra algorithm.
 		    ///
 		    ///\sa BinHeap
 		    ///\sa Dijkstra
 		    typedef BinHeap<typename LM::Value, HeapCrossRef, std::less<Value> > Heap;
 		    static Heap *createHeap(HeapCrossRef& R)
+		    {
 		      return new Heap(R);
+		    }
 		    ///\brief The type of the map that stores the last
 		    ///arcs of the shortest paths.
 		    ///
 		    ///The type of the map that stores the last
 		    ///arcs of the shortest paths.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///
 		    typedef typename Digraph::template NodeMap<typename GR::Arc> PredMap;
 		    ///Instantiates a PredMap.
 		    ///This function instantiates a \c PredMap.
 		    ///\param G is the digraph, to which we would like to define the PredMap.
 		    ///\todo The digraph alone may be insufficient for the initialization
 		    static PredMap *createPredMap(const GR &G)
+		    {
 		      return new PredMap(G);
+		    }
 		    ///The type of the map that stores whether a nodes is processed.
 		    ///The type of the map that stores whether a nodes is processed.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///By default it is a NullMap.
 		    ///\todo If it is set to a real map,
 		    ///Dijkstra::processed() should read this.
 		    ///\todo named parameter to set this type, function to read and write.
 		    typedef NullMap<typename Digraph::Node,bool> ProcessedMap;
 		    ///Instantiates a ProcessedMap.
 		    ///This function instantiates a \c ProcessedMap.
 		    ///\param g is the digraph, to which
 		    ///we would like to define the \c ProcessedMap
 		#ifdef DOXYGEN
 		    static ProcessedMap *createProcessedMap(const GR &g)
 		#else
 		    static ProcessedMap *createProcessedMap(const GR &)
 		#endif
+		    {
 		      return new ProcessedMap();
+		    }
 		    ///The type of the map that stores the dists of the nodes.
 		    ///The type of the map that stores the dists of the nodes.
 		    ///It must meet the \ref concepts::WriteMap "WriteMap" concept.
 		    ///
 		    typedef typename Digraph::template NodeMap<typename LM::Value> DistMap;
 		    ///Instantiates a DistMap.
 		    ///This function instantiates a \ref DistMap.
 		    ///\param G is the digraph, to which we would like to define the \ref DistMap
 		    static DistMap *createDistMap(const GR &G)
+		    {
 		      return new DistMap(G);
+		    }
 		  };
 		  ///%Dijkstra algorithm class.
 		  /// \ingroup shortest_path
 		  ///This class provides an efficient implementation of %Dijkstra algorithm.
 		  ///The arc lengths are passed to the algorithm using a
 		  ///\ref concepts::ReadMap "ReadMap",
 		  ///so it is easy to change it to any kind of length.
 		  ///
 		  ///The type of the length is determined by the
 		  ///\ref concepts::ReadMap::Value "Value" of the length map.
 		  ///
 		  ///It is also possible to change the underlying priority heap.
 		  ///
 		  ///\tparam GR The digraph type the algorithm runs on. The default value
 		  ///is \ref ListDigraph. The value of GR is not used directly by
 		  ///Dijkstra, it is only passed to \ref DijkstraDefaultTraits.
 		  ///\tparam LM This read-only ArcMap determines the lengths of the
 		  ///arcs. It is read once for each arc, so the map may involve in
 		  ///relatively time consuming process to compute the arc length if
 		  ///it is necessary. The default map type is \ref
 		  ///concepts::Digraph::ArcMap "Digraph::ArcMap<int>".  The value
 		  ///of LM is not used directly by Dijkstra, it is only passed to \ref
 		  ///DijkstraDefaultTraits.
 		  ///\tparam TR Traits class to set
 		  ///various data types used by the algorithm.  The default traits
 		  ///class is \ref DijkstraDefaultTraits
 		  ///"DijkstraDefaultTraits<GR,LM>".  See \ref
 		  ///DijkstraDefaultTraits for the documentation of a Dijkstra traits
 		  ///class.
 		#ifdef DOXYGEN
 		  template <typename GR, typename LM, typename TR>
 		#else
 		  template <typename GR=ListDigraph,
 			    typename LM=typename GR::template ArcMap<int>,
 			    typename TR=DijkstraDefaultTraits<GR,LM> >
 		#endif
 		  class Dijkstra {
 		  public:
 		    /**
 		     * \brief \ref Exception for uninitialized parameters.
+		     *
 		     * This error represents problems in the initialization
 		     * of the parameters of the algorithms.
 		     */
 		    class UninitializedParameter : public lemon::UninitializedParameter {
 		    public:
 		      virtual const char* what() const throw() {
 			return "lemon::Dijkstra::UninitializedParameter";
+		      }
 		    };
 		    typedef TR Traits;
 		    ///The type of the underlying digraph.
 		    typedef typename TR::Digraph Digraph;
 		    ///\e
 		    typedef typename Digraph::Node Node;
 		    ///\e
 		    typedef typename Digraph::NodeIt NodeIt;
 		    ///\e
 		    typedef typename Digraph::Arc Arc;
 		    ///\e
 		    typedef typename Digraph::OutArcIt OutArcIt;
 		    ///The type of the length of the arcs.
 		    typedef typename TR::LengthMap::Value Value;
 		    ///The type of the map that stores the arc lengths.
 		    typedef typename TR::LengthMap LengthMap;
 		    ///\brief The type of the map that stores the last
 		    ///arcs of the shortest paths.
 		    typedef typename TR::PredMap PredMap;
 		    ///The type of the map indicating if a node is processed.
 		    typedef typename TR::ProcessedMap ProcessedMap;
 		    ///The type of the map that stores the dists of the nodes.
 		    typedef typename TR::DistMap DistMap;
 		    ///The cross reference type used for the current heap.
 		    typedef typename TR::HeapCrossRef HeapCrossRef;

lemon/dim2.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_DIM2_H
 		#define LEMON_DIM2_H
 		#include <iostream>
 		#include <lemon/bits/utility.h>
 		///\ingroup misc
 		///\file
 		///\brief A simple two dimensional vector and a bounding box implementation
 		///
 		/// The class \ref lemon::dim2::Point "dim2::Point" implements
 		/// a two dimensional vector with the usual operations.
 		///
 		/// The class \ref lemon::dim2::BoundingBox "dim2::BoundingBox"
 		/// can be used to determine
 		/// the rectangular bounding box of a set of
 		/// \ref lemon::dim2::Point "dim2::Point"'s.
 		namespace lemon {
 		  ///Tools for handling two dimensional coordinates
 		  ///This namespace is a storage of several
 		  ///tools for handling two dimensional coordinates
 		  namespace dim2 {
 		  /// \addtogroup misc
 		  /// @{
 		  /// A simple two dimensional vector (plainvector) implementation
 		  /// A simple two dimensional vector (plainvector) implementation
 		  /// with the usual vector operations.
 		  template<typename T>
 		    class Point {
 		    public:
 		      typedef T Value;
 		      ///First coordinate
 		      T x;
 		      ///Second coordinate
 		      T y;
 		      ///Default constructor
 		      Point() {}
 		      ///Construct an instance from coordinates
 		      Point(T a, T b) : x(a), y(b) { }
 		      ///Returns the dimension of the vector (i.e. returns 2).
 		      ///The dimension of the vector.
 		      ///This function always returns 2.
 		      int size() const { return 2; }
 		      ///Subscripting operator
 		      ///\c p[0] is \c p.x and \c p[1] is \c p.y
 		      ///
 		      T& operator[](int idx) { return idx == 0 ? x : y; }
 		      ///Const subscripting operator
 		      ///\c p[0] is \c p.x and \c p[1] is \c p.y
 		      ///
 		      const T& operator[](int idx) const { return idx == 0 ? x : y; }
 		      ///Conversion constructor
 		      template<class TT> Point(const Point<TT> &p) : x(p.x), y(p.y) {}
 		      ///Give back the square of the norm of the vector
 		      T normSquare() const {
 		        return x*x+y*y;
+		      }
 		      ///Increment the left hand side by \c u
 		      Point<T>& operator +=(const Point<T>& u) {
 		        x += u.x;
 		        y += u.y;
 		        return *this;
+		      }
 		      ///Decrement the left hand side by \c u
 		      Point<T>& operator -=(const Point<T>& u) {
 		        x -= u.x;
 		        y -= u.y;
 		        return *this;
+		      }
 		      ///Multiply the left hand side with a scalar
 		      Point<T>& operator *=(const T &u) {
 		        x *= u;
 		        y *= u;
 		        return *this;
+		      }
 		      ///Divide the left hand side by a scalar
 		      Point<T>& operator /=(const T &u) {
 		        x /= u;
 		        y /= u;
 		        return *this;
+		      }
 		      ///Return the scalar product of two vectors
 		      T operator *(const Point<T>& u) const {
 		        return x*u.x+y*u.y;
+		      }
 		      ///Return the sum of two vectors
 		      Point<T> operator+(const Point<T> &u) const {
 		        Point<T> b=*this;
 		        return b+=u;
+		      }
 		      ///Return the negative of the vector
 		      Point<T> operator-() const {
 		        Point<T> b=*this;
 		        b.x=-b.x; b.y=-b.y;
 		        return b;
+		      }
 		      ///Return the difference of two vectors
 		      Point<T> operator-(const Point<T> &u) const {
 		        Point<T> b=*this;
 		        return b-=u;
+		      }
 		      ///Return a vector multiplied by a scalar
 		      Point<T> operator*(const T &u) const {
 		        Point<T> b=*this;
 		        return b*=u;
+		      }
 		      ///Return a vector divided by a scalar
 		      Point<T> operator/(const T &u) const {
 		        Point<T> b=*this;
 		        return b/=u;
+		      }
 		      ///Test equality
 		      bool operator==(const Point<T> &u) const {
 		        return (x==u.x) && (y==u.y);
+		      }
 		      ///Test inequality
 		      bool operator!=(Point u) const {
 		        return  (x!=u.x) || (y!=u.y);
+		      }
 		    };
 		  ///Return a Point
 		  ///Return a Point.
 		  ///\relates Point
 		  template <typename T>
 		  inline Point<T> makePoint(const T& x, const T& y) {
 		    return Point<T>(x, y);
+		  }
 		  ///Return a vector multiplied by a scalar
 		  ///Return a vector multiplied by a scalar.
 		  ///\relates Point
 		  template<typename T> Point<T> operator*(const T &u,const Point<T> &x) {
 		    return x*u;
+		  }
 		  ///Read a plainvector from a stream
 		  ///Read a plainvector from a stream.
 		  ///\relates Point
 		  ///
 		  template<typename T>
 		  inline std::istream& operator>>(std::istream &is, Point<T> &z) {
 		    char c;
 		    if (is >> c) {
 		      if (c != '(') is.putback(c);
 		    } else {
 		      is.clear();
+		    }
 		    if (!(is >> z.x)) return is;
 		    if (is >> c) {
 		      if (c != ',') is.putback(c);
 		    } else {
 		      is.clear();
+		    }
 		    if (!(is >> z.y)) return is;
 		    if (is >> c) {
 		      if (c != ')') is.putback(c);
 		    } else {
 		      is.clear();
+		    }
 		    return is;
+		  }
 		  ///Write a plainvector to a stream
 		  ///Write a plainvector to a stream.
 		  ///\relates Point
 		  ///
 		  template<typename T>
 		  inline std::ostream& operator<<(std::ostream &os, const Point<T>& z)
+		  {
 		    os << "(" << z.x << ", " << z.y << ")";
 		    return os;
+		  }
 		  ///Rotate by 90 degrees
 		  ///Returns the parameter rotated by 90 degrees in positive direction.
 		  ///\relates Point
 		  ///
 		  template<typename T>
 		  inline Point<T> rot90(const Point<T> &z)
+		  {
 		    return Point<T>(-z.y,z.x);
+		  }
 		  ///Rotate by 180 degrees
 		  ///Returns the parameter rotated by 180 degrees.
 		  ///\relates Point
 		  ///
 		  template<typename T>
 		  inline Point<T> rot180(const Point<T> &z)
+		  {
 		    return Point<T>(-z.x,-z.y);
+		  }
 		  ///Rotate by 270 degrees
 		  ///Returns the parameter rotated by 90 degrees in negative direction.
 		  ///\relates Point
 		  ///
 		  template<typename T>
 		  inline Point<T> rot270(const Point<T> &z)
+		  {
 		    return Point<T>(z.y,-z.x);

lemon/error.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_ERROR_H
 		#define LEMON_ERROR_H
 		/// \ingroup exceptions
 		/// \file
 		/// \brief Basic exception classes and error handling.
 		#include <exception>
 		#include <string>
 		#include <sstream>
 		#include <iostream>
 		#include <cstdlib>
 		#include <memory>
 		namespace lemon {
 		  /// \addtogroup exceptions
 		  /// @{
 		  /// \brief Exception safe wrapper class.
 		  ///
 		  /// Exception safe wrapper class to implement the members of exceptions.
 		  template <typename _Type>
 		  class ExceptionMember {
 		  public:
 		    typedef _Type Type;
 		    ExceptionMember() throw() {
 		      try {
 			ptr.reset(new Type());
 		      } catch (...) {}
+		    }
 		    ExceptionMember(const Type& type) throw() {
 		      try {
 			ptr.reset(new Type());
 			if (ptr.get() == 0) return;
 			*ptr = type;
 		      } catch (...) {}
+		    }
 		    ExceptionMember(const ExceptionMember& copy) throw() {
 		      try {
 			if (!copy.valid()) return;
 			ptr.reset(new Type());
 			if (ptr.get() == 0) return;
 			*ptr = copy.get();
 		      } catch (...) {}
+		    }
 		    ExceptionMember& operator=(const ExceptionMember& copy) throw() {
 		      if (ptr.get() == 0) return;
 		      try {
 			if (!copy.valid()) return;
 		 	*ptr = copy.get();
 		      } catch (...) {}
+		    }
 		    void set(const Type& type) throw() {
 		      if (ptr.get() == 0) return;
 		      try {
 			*ptr = type;
 		      } catch (...) {}
+		    }
 		    const Type& get() const {
 		      return *ptr;
+		    }
 		    bool valid() const throw() {
 		      return ptr.get() != 0;
+		    }
 		  private:
 		    std::auto_ptr<_Type> ptr;
 		  };
 		  /// Exception-safe convenient error message builder class.
 		  /// Helper class which provides a convenient ostream-like (operator <<
 		  /// based) interface to create a string message. Mostly useful in
 		  /// exception classes (therefore the name).
 		  class ErrorMessage {
 		  protected:
 		    ///\e
 		    ///\todo The good solution is boost::shared_ptr...
 		    ///
 		    mutable std::auto_ptr<std::ostringstream> buf;
 		    ///\e
 		    bool init() throw() {
 		      try {
 			buf.reset(new std::ostringstream);
+		      }
 		      catch(...) {
 			buf.reset();
+		      }
 		      return buf.get();
+		    }
 		  public:
 		    ///\e
 		    ErrorMessage() throw() { init(); }
 		    ErrorMessage(const ErrorMessage& em) throw() : buf(em.buf) { }
 		    ///\e
 		    ErrorMessage(const char *msg) throw() {
 		      init();
 		      *this << msg;
+		    }
 		    ///\e
 		    ErrorMessage(const std::string &msg) throw() {
 		      init();
 		      *this << msg;
+		    }
 		    ///\e
 		    template <typename T>
 		    ErrorMessage& operator<<(const T &t) throw() {
 		      if( ! buf.get() ) return *this;
 		      try {
 			*buf << t;
+		      }
 		      catch(...) {
 			buf.reset();
+		      }
 		      return *this;
+		    }
 		    ///\e
 		    const char* message() throw() {
 		      if( ! buf.get() ) return 0;
 		      const char* mes = 0;
 		      try {
 			mes = buf->str().c_str();
+		      }
 		      catch(...) {}
 		      return mes;
+		    }
 		  };
 		  /// Generic exception class.
 		  /// Base class for exceptions used in LEMON.
 		  ///
 		  class Exception : public std::exception {
 		  public:
 		    ///\e
 		    Exception() {}
 		    ///\e
 		    virtual ~Exception() throw() {}
 		    ///\e
 		    virtual const char* what() const throw() {
 		      return "lemon::Exception";
+		    }
 		  };
 		  /// One of the two main subclasses of \ref Exception.
 		  /// Logic errors represent problems in the internal logic of a program;
 		  /// in theory, these are preventable, and even detectable before the
 		  /// program runs (e.g. violations of class invariants).
 		  ///
 		  /// A typical example for this is \ref UninitializedParameter.
 		  class LogicError : public Exception {
 		  public:
 		    virtual const char* what() const throw() {
 		      return "lemon::LogicError";
+		    }
 		  };
 		  /// \ref Exception for uninitialized parameters.
 		  /// This error represents problems in the initialization
 		  /// of the parameters of the algorithms.
 		  class UninitializedParameter : public LogicError {
 		  public:
 		    virtual const char* what() const throw() {
 		      return "lemon::UninitializedParameter";
+		    }
 		  };
 		  /// One of the two main subclasses of \ref Exception.
 		  /// Runtime errors represent problems outside the scope of a program;
 		  /// they cannot be easily predicted and can generally only be caught
 		  /// as the program executes.
 		  class RuntimeError : public Exception {
 		  public:
 		    virtual const char* what() const throw() {
 		      return "lemon::RuntimeError";
+		    }
 		  };
 		  ///\e
 		  class RangeError : public RuntimeError {
 		  public:
 		    virtual const char* what() const throw() {
 		      return "lemon::RangeError";
+		    }
 		  };
 		  ///\e
 		  class IoError : public RuntimeError {
 		  public:
 		    virtual const char* what() const throw() {
 		      return "lemon::IoError";
+		    }
 		  };
 		  ///\e
 		  class DataFormatError : public IoError {
 		  protected:
 		    ExceptionMember<std::string> _message;
 		    ExceptionMember<std::string> _file;
 		    int _line;
 		    mutable ExceptionMember<std::string> _message_holder;
 		  public:
 		    DataFormatError(const DataFormatError &dfe) :
 		      IoError(dfe), _message(dfe._message), _file(dfe._file),
 		      _line(dfe._line) {}
 		    ///\e
 		    explicit DataFormatError(const char *the_message)
 		      : _message(the_message), _line(0) {}
 		    ///\e
 		    DataFormatError(const std::string &file_name, int line_num,
 				    const char *the_message)
 		      : _message(the_message), _line(line_num) { file(file_name); }

lemon/graph_to_eps.h

Show inline comments

 		/* -*- C++ -*-
+		/* -*- mode: C++; indent-tabs-mode: nil; -*-
+		 *
 		 * This file is a part of LEMON, a generic C++ optimization library
+		 * This file is a part of LEMON, a generic C++ optimization library.
+		 *
 		 * Copyright (C) 2003-2008
 		 * 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_GRAPH_TO_EPS_H
 		#define LEMON_GRAPH_TO_EPS_H
 		#include<iostream>
 		#include<fstream>
 		#include<sstream>
 		#include<algorithm>
 		#include<vector>
 		#ifndef WIN32
 		#include<sys/time.h>
 		#include<ctime>
 		#else
 		#define WIN32_LEAN_AND_MEAN
 		#define NOMINMAX
 		#include<windows.h>
 		#endif
 		#include<lemon/math.h>
 		#include<lemon/bits/invalid.h>
 		#include<lemon/dim2.h>
 		#include<lemon/maps.h>
 		#include<lemon/color.h>
 		#include<lemon/bits/bezier.h>
 		///\ingroup eps_io
 		///\file
 		///\brief A well configurable tool for visualizing graphs
 		namespace lemon {
 		  namespace _graph_to_eps_bits {
 		    template<class MT>
 		    class _NegY {
 		    public:
 		      typedef typename MT::Key Key;
 		      typedef typename MT::Value Value;
 		      const MT &map;
 		      int yscale;
 		      _NegY(const MT &m,bool b) : map(m), yscale(1-b*2) {}
 		      Value operator[](Key n) { return Value(map[n].x,map[n].y*yscale);}
 		    };
+		  }
 		///Default traits class of \ref GraphToEps
 		///Default traits class of \ref GraphToEps.
 		///
 		///\c G is the type of the underlying graph.
 		template<class G>
 		struct DefaultGraphToEpsTraits
+		{
 		  typedef G Graph;
 		  typedef typename Graph::Node Node;
 		  typedef typename Graph::NodeIt NodeIt;
 		  typedef typename Graph::Arc Arc;
 		  typedef typename Graph::ArcIt ArcIt;
 		  typedef typename Graph::InArcIt InArcIt;
 		  typedef typename Graph::OutArcIt OutArcIt;
 		  const Graph &g;
 		  std::ostream& os;
 		  typedef ConstMap<typename Graph::Node,dim2::Point<double> > CoordsMapType;
 		  CoordsMapType _coords;
 		  ConstMap<typename Graph::Node,double > _nodeSizes;
 		  ConstMap<typename Graph::Node,int > _nodeShapes;
 		  ConstMap<typename Graph::Node,Color > _nodeColors;
 		  ConstMap<typename Graph::Arc,Color > _arcColors;
 		  ConstMap<typename Graph::Arc,double > _arcWidths;
 		  double _arcWidthScale;
 		  double _nodeScale;
 		  double _xBorder, _yBorder;
 		  double _scale;
 		  double _nodeBorderQuotient;
 		  bool _drawArrows;
 		  double _arrowLength, _arrowWidth;
 		  bool _showNodes, _showArcs;
 		  bool _enableParallel;
 		  double _parArcDist;
 		  bool _showNodeText;
 		  ConstMap<typename Graph::Node,bool > _nodeTexts;
 		  double _nodeTextSize;
 		  bool _showNodePsText;
 		  ConstMap<typename Graph::Node,bool > _nodePsTexts;
 		  char *_nodePsTextsPreamble;
 		  bool _undirected;
 		  bool _pleaseRemoveOsStream;
 		  bool _scaleToA4;
 		  std::string _title;
 		  std::string _copyright;
 		  enum NodeTextColorType
 		    { DIST_COL=0, DIST_BW=1, CUST_COL=2, SAME_COL=3 } _nodeTextColorType;
 		  ConstMap<typename Graph::Node,Color > _nodeTextColors;
 		  bool _autoNodeScale;
 		  bool _autoArcWidthScale;
 		  bool _absoluteNodeSizes;
 		  bool _absoluteArcWidths;
 		  bool _negY;
 		  bool _preScale;
 		  ///Constructor
 		  ///Constructor
 		  ///\param _g  Reference to the graph to be printed.
 		  ///\param _os Reference to the output stream.
 		  ///\param _os Reference to the output stream. By default it is <tt>std::cout</tt>.
 		  ///\param _pros If it is \c true, then the \c ostream referenced by \c _os
 		  ///will be explicitly deallocated by the destructor.
 		  DefaultGraphToEpsTraits(const G &_g,std::ostream& _os=std::cout,
 					  bool _pros=false) :
 		    g(_g), os(_os),
 		    _coords(dim2::Point<double>(1,1)), _nodeSizes(1), _nodeShapes(0),
 		    _nodeColors(WHITE), _arcColors(BLACK),
 		    _arcWidths(1.0), _arcWidthScale(0.003),
 		    _nodeScale(.01), _xBorder(10), _yBorder(10), _scale(1.0),
 		    _nodeBorderQuotient(.1),
 		    _drawArrows(false), _arrowLength(1), _arrowWidth(0.3),
 		    _showNodes(true), _showArcs(true),
 		    _enableParallel(false), _parArcDist(1),
 		    _showNodeText(false), _nodeTexts(false), _nodeTextSize(1),
 		    _showNodePsText(false), _nodePsTexts(false), _nodePsTextsPreamble(0),
 		    _undirected(lemon::UndirectedTagIndicator<G>::value),
 		    _pleaseRemoveOsStream(_pros), _scaleToA4(false),
 		    _nodeTextColorType(SAME_COL), _nodeTextColors(BLACK),
 		    _autoNodeScale(false),
 		    _autoArcWidthScale(false),
 		    _absoluteNodeSizes(false),
 		    _absoluteArcWidths(false),
 		    _negY(false),
 		    _preScale(true)
 		  {}
 		};
 		///Auxiliary class to implement the named parameters of \ref graphToEps()
 		///Auxiliary class to implement the named parameters of \ref graphToEps().
 		///
 		///For detailed examples see the \ref graph_to_eps_demo.cc demo file.
 		template<class T> class GraphToEps : public T
+		{
 		  // Can't believe it is required by the C++ standard
 		  using T::g;
 		  using T::os;
 		  using T::_coords;
 		  using T::_nodeSizes;
 		  using T::_nodeShapes;
 		  using T::_nodeColors;
 		  using T::_arcColors;
 		  using T::_arcWidths;
 		  using T::_arcWidthScale;
 		  using T::_nodeScale;
 		  using T::_xBorder;
 		  using T::_yBorder;
 		  using T::_scale;
 		  using T::_nodeBorderQuotient;
 		  using T::_drawArrows;
 		  using T::_arrowLength;
 		  using T::_arrowWidth;
 		  using T::_showNodes;
 		  using T::_showArcs;
 		  using T::_enableParallel;
 		  using T::_parArcDist;
 		  using T::_showNodeText;
 		  using T::_nodeTexts;
 		  using T::_nodeTextSize;
 		  using T::_showNodePsText;
 		  using T::_nodePsTexts;
 		  using T::_nodePsTextsPreamble;
 		  using T::_undirected;
 		  using T::_pleaseRemoveOsStream;
 		  using T::_scaleToA4;
 		  using T::_title;
 		  using T::_copyright;
 		  using T::NodeTextColorType;
 		  using T::CUST_COL;
 		  using T::DIST_COL;
 		  using T::DIST_BW;
 		  using T::_nodeTextColorType;
 		  using T::_nodeTextColors;
 		  using T::_autoNodeScale;
 		  using T::_autoArcWidthScale;
 		  using T::_absoluteNodeSizes;
 		  using T::_absoluteArcWidths;
 		  using T::_negY;
 		  using T::_preScale;
 		  // dradnats ++C eht yb deriuqer si ti eveileb t'naC
 		  typedef typename T::Graph Graph;
 		  typedef typename Graph::Node Node;
 		  typedef typename Graph::NodeIt NodeIt;
 		  typedef typename Graph::Arc Arc;
 		  typedef typename Graph::ArcIt ArcIt;
 		  typedef typename Graph::InArcIt InArcIt;
 		  typedef typename Graph::OutArcIt OutArcIt;
 		  static const int INTERPOL_PREC;
 		  static const double A4HEIGHT;
 		  static const double A4WIDTH;
 		  static const double A4BORDER;
 		  bool dontPrint;
 		public:

RhodeCode

Login to your account

Changeset was too big and was cut off... Show full diff

Changeset was too big and was cut off... Show full diff

1		/* -- C++ --
	1	/* -- mode: C++; indent-tabs-mode: nil; --
2	2	*
3		* This file is a part of LEMON, a generic C++ optimization library
	3	* This file is a part of LEMON, a generic C++ optimization library.
4	4	*
5	5	* Copyright (C) 2003-2008
6	6	* Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
7	7	* (Egervary Research Group on Combinatorial Optimization, EGRES).
8	8	*
9	9	* Permission to use, modify and distribute this software is granted
10	10	* provided that this copyright notice appears in all copies. For
11	11	* precise terms see the accompanying LICENSE file.
12	12	*
13	13	* This software is provided "AS IS" with no warranty of any kind,
14	14	* express or implied, and with no claim as to its suitability for any
15	15	* purpose.
16	16	*
17	17	*/
18	18
19	19	/**
20	20
21	21	\page license License Terms
22	22
23	23	\verbinclude LICENSE
24	24
25	25	*/