RhodeCode

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

 *

 * 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 named-param Named Parameters

\section named-func-param Named Function Parameters

Several modern languages provide a convenient way to refer the

function parameters by name also when you call the function. It is

especially comfortable in case of a function having tons of parameters

with natural default values. Sadly, C++ lack this amenity.

However, with a crafty trick and with some little

inconvenience, it is possible to emulate is.

The example below shows how to do it.

\code

class namedFn

{

  int _id;

  double _val;

  int _dim;

  public:

  namedFn() : _id(0), _val(1), _dim(2) {}

  namedFn& id(int p)     { _id  = p ; return *this; }

  namedFn& val(double p) { _val = p ; return *this; }

  namedFn& dim(int p)    { _dim = p ; return *this; }

  run() {

    std::cout << "Here comes the function itself\n" <<

              << "With parameters "

              << _id << ", " << _val << ", " << _dim << std::endl;

  }

};

\endcode

Then you can use it like this.

\code

namedFn().id(3).val(2).run();

\endcode

The trick is obvious, each "named parameter" changes one component of

the underlying class, then gives back a reference to it. Finally,

<tt>run()</tt> executes the algorithm itself.

\note Although it is a class, namedFn is used pretty much like as it were

a function. That it why we called it namedFn instead of \c NamedFn.

\note In fact, the final <tt>.run()</tt> could be made unnecessary,

because the algorithm could also be implemented in the destructor of

\c namedFn instead. This however would make it impossible to implement

functions with return values, and would also cause serious problems when

implementing \ref named-templ-func-param "named template parameters".

<b>Therefore, by convention, <tt>.run()</tt> must be used

explicitly to execute a function having named parameters

everywhere in LEMON.</b>

\section named-templ-func-param Named Function Template Parameters

A named parameter can also be a template function. The usage is

exactly the same, but the implementation behind is a kind of black

magic and they are the dirtiest part of the LEMON code.

You will probably never need to know how it works, but if you really

committed, have a look at \ref lemon/graph_to_eps.h for an example.

\section traits-classes Traits Classes

A similar game can also be played when defining classes. In this case

the type of the class attributes can be changed. Initially we have to

define a special class called <em>Traits Class</em> defining the

default type of the attributes. Then the types of these attributes can

be changed in the same way as described in the next section.

See \ref lemon::DijkstraDefaultTraits for an

example how a traits class implementation looks like.

\section named-templ-param Named Class Template Parameters

If we would like to change the type of an attribute in a class that

was instantiated by using a traits class as a template parameter, and

the class contains named parameters, we do not have to instantiate again

the class with new traits class, but instead adaptor classes can

be used as shown in the following example.

\code

Dijkstra<>::SetPredMap<NullMap<Node,Arc> >::Create

\endcode

It can also be used in conjunction with other named template

parameters in arbitrary order.

\code

Dijkstra<>::SetDistMap<MyMap>::SetPredMap<NullMap<Node,Arc> >::Create

\endcode

The result will be an instantiated Dijkstra class, in which the

DistMap and the PredMap is modified.

*/

#! /usr/bin/env python

import sys

import os

if len(sys.argv)>1 and sys.argv[1] in ["-h","--help"]:

    print """

This utility just prints the length of the longest path

in the revision graph from revison 0 to the current one.

"""

    exit(0)

plist = os.popen("hg parents --template='{rev}\n'").readlines()

if len(plist)>1:

    print "You are in the process of merging"

    exit(1)

PAR = int(plist[0])

f = os.popen("hg log -r 0:tip --template='{rev} {parents}\n'").readlines()

REV = -1

lengths=[]

for l in f:

    REV+=1

    s = l.split()

    rev = int(s[0])

    if REV != rev:

        print "Something is seriously wrong"

        exit(1)

    if len(s) == 1:

        par1 = par2 = rev - 1

    elif len(s) == 2:

        par1 = par2 = int(s[1].split(":")[0])

    else:

        par1 = int(s[1].split(":")[0])

        par2 = int(s[2].split(":")[0])

    if rev == 0:

        lengths.append(0)

    else:

        lengths.append(max(lengths[par1],lengths[par2])+1)

print lengths[PAR]

SET(PROJECT_VERSION "hg-tip" CACHE STRING "The version string.")

    "${PROJECT_NAME} ${PROJECT_VERSION}")

    "${PROJECT_NAME} ${PROJECT_VERSION}")

20XX-XX-XX Version 1.0 released

	This is the first stable release of LEMON. Compared to the 0.x

	release series, it features a considerably smaller but more

	matured set of tools. The API has also completely revised and

	changed in several places.

	* The major name changes compared to the 0.x series

          * Graph -> Digraph, UGraph -> Graph

          * Edge -> Arc, UEdge -> Edge

	  * source(UEdge)/target(UEdge) -> u(Edge)/v(Edge)

	* Other improvements

	  * Better documentation

	  * Reviewed and cleaned up codebase

	  * CMake based build system (along with the autotools based one)

	* Contents of the library (ported from 0.x)

	  * Algorithms

       	    * breadth-first search (bfs.h)

       	    * depth-first search (dfs.h)

       	    * Dijkstra's algorithm (dijkstra.h)

       	    * Kruskal's algorithm (kruskal.h)

    	  * Data structures

       	    * graph data structures (list_graph.h, smart_graph.h)

       	    * path data structures (path.h)

       	    * binary heap data structure (bin_heap.h)

       	    * union-find data structures (unionfind.h)

       	    * miscellaneous property maps (maps.h)

       	    * two dimensional vector and bounding box (dim2.h)

          * Concepts

       	    * graph structure concepts (concepts/digraph.h, concepts/graph.h,

              concepts/graph_components.h)

       	    * concepts for other structures (concepts/heap.h, concepts/maps.h,

	      concepts/path.h)

    	  * Tools

       	    * Mersenne twister random number generator (random.h)

       	    * tools for measuring cpu and wall clock time (time_measure.h)

       	    * tools for counting steps and events (counter.h)

       	    * tool for parsing command line arguments (arg_parser.h)

       	    * tool for visualizing graphs (graph_to_eps.h)

       	    * tools for reading and writing data in LEMON Graph Format

              (lgf_reader.h, lgf_writer.h)

            * tools to handle the anomalies of calculations with

	      floating point numbers (tolerance.h)

            * tools to manage RGB colors (color.h)

    	  * Infrastructure

       	    * extended assertion handling (assert.h)

       	    * exception classes and error handling (error.h)

      	    * concept checking (concept_check.h)

       	    * commonly used mathematical constants (math.h)

m4_define([lemon_version_number],

	[m4_normalize(esyscmd([echo ${LEMON_VERSION}]))])

dnl m4_define([lemon_version_number], [])

m4_define([lemon_hg_path], [m4_normalize(esyscmd([./scripts/chg-len.py]))])

m4_define([lemon_version], [ifelse(lemon_version_number(),

			   [],

			   [lemon_hg_path().lemon_hg_revision()],

			   [lemon_version_number()])])

	doc/named-param.dox \

#ifndef LEMON_ARG_PARSER_H

#define LEMON_ARG_PARSER_H

#endif // LEMON_ARG_PARSER_H

  inline void assert_fail_abort(const char *file, int line,

                                const char *function, const char* message,

                                const char *assertion)

#if (defined(LEMON_ASSERT_ABORT) ? 1 : 0) +               \

#if ((defined(LEMON_ASSERT_ABORT) ? 1 : 0) +            \

#if defined LEMON_ASSERT_ABORT

#  elif __STDC_VERSION__ >= 199901L

#    define LEMON_FUNCTION_NAME (__func__)

#    define LEMON_FUNCTION_NAME ("<unknown>")

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

/// As a default behaviour the failed assertion prints a short log message to

/// the standard error and aborts the execution.

/// However, the following modes can be used in the assertion system:

/// - \c LEMON_ASSERT_ABORT The failed assertion prints a short log message to

///   the standard error and aborts the program. It is the default behaviour.

  private:

  public:

    private:

    private:

    private:

    private:

    private:

  private:

  public:

  private:

  public:

  private:

      private:

      private:

      private:

      private:

      private:

    private:

    public:

          // _Map b(c);

          // ReadMap<Key, Value> cmap;

          // b = cmap;

          ignore_unused_variable_warning(a);

          // ignore_unused_variable_warning(b);

      private:

      private:

      private:

  check(cnt == 1, "The custom assert handler does not work");

    // map = constMap<Node>(12);

    // for (NodeIt it(G); it != INVALID; ++it) {

    //   check(map[it] == 12, "Wrong operator[].");

    // }

    // map = constMap<Arc>(12);

    // for (ArcIt it(G); it != INVALID; ++it) {

    //   check(map[it] == 12, "Wrong operator[].");

    // }

    // map = constMap<Edge>(12);

    // for (EdgeIt it(G); it != INVALID; ++it) {

    //   check(map[it] == 12, "Wrong operator[].");

    // }