RhodeCode

EXTRA_DIST += \

	lemon/lemon.pc.in \

	lemon/CMakeLists.txt

pkgconfig_DATA += lemon/lemon.pc

lib_LTLIBRARIES += lemon/libemon.la

lemon_libemon_la_SOURCES = \

        lemon/arg_parser.cc \

        lemon/base.cc \

        lemon/color.cc \

        lemon/random.cc \

	lemon/bits/windows.cc

#lemon_libemon_la_CXXFLAGS = $(GLPK_CFLAGS) $(CPLEX_CFLAGS) $(SOPLEX_CXXFLAGS)

#lemon_libemon_la_LDFLAGS = $(GLPK_LIBS) $(CPLEX_LIBS) $(SOPLEX_LIBS)

lemon_HEADERS += \

        lemon/arg_parser.h \

	lemon/assert.h \

        lemon/bfs.h \

        lemon/bin_heap.h \

        lemon/color.h \

	lemon/concept_check.h \

        lemon/counter.h \

	lemon/core.h \

        lemon/dfs.h \

        lemon/dijkstra.h \

        lemon/dim2.h \

	lemon/error.h \

        lemon/graph_to_eps.h \

	lemon/kruskal.h \

	lemon/lgf_reader.h \

	lemon/lgf_writer.h \

	lemon/list_graph.h \

	lemon/maps.h \

	lemon/math.h \

	lemon/path.h \

        lemon/random.h \

	lemon/smart_graph.h \

        lemon/time_measure.h \

        lemon/tolerance.h \

	lemon/unionfind.h \

	lemon/bits/windows.h

bits_HEADERS += \

	lemon/bits/alteration_notifier.h \

	lemon/bits/array_map.h \

	lemon/bits/base_extender.h \

        lemon/bits/bezier.h \

	lemon/bits/default_map.h \

        lemon/bits/enable_if.h \

	lemon/bits/graph_extender.h \

	lemon/bits/map_extender.h \

	lemon/bits/path_dump.h \

	lemon/bits/traits.h \

	lemon/bits/vector_map.h

concept_HEADERS += \

	lemon/concepts/digraph.h \

	lemon/concepts/graph.h \

	lemon/concepts/graph_components.h \

	lemon/concepts/heap.h \

	lemon/concepts/maps.h \

	lemon/concepts/path.h

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

 *

 */

#ifndef LEMON_CORE_H

#define LEMON_CORE_H

#include <vector>

#include <algorithm>

#include <lemon/bits/enable_if.h>

#include <lemon/bits/traits.h>

#include <lemon/assert.h>

///\file

///\brief LEMON core utilities.

///

///This header file contains core utilities for LEMON.

///It is automatically included by all graph types, therefore it usually

///do not have to be included directly.

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.

#ifdef LEMON_ONLY_TEMPLATES

  const Invalid INVALID = Invalid();

#else

  extern const Invalid INVALID;

#endif

  /// \addtogroup gutils

  /// @{

  ///Create convenience typedefs for the digraph types and iterators

  ///This \c \#define creates convenient type definitions for the following

  ///types of \c Digraph: \c Node,  \c NodeIt, \c Arc, \c ArcIt, \c InArcIt,

  ///\c OutArcIt, \c BoolNodeMap, \c IntNodeMap, \c DoubleNodeMap,

  ///\c BoolArcMap, \c IntArcMap, \c DoubleArcMap.

  ///

  ///\note If the graph type is a dependent type, ie. the graph type depend

  ///on a template parameter, then use \c TEMPLATE_DIGRAPH_TYPEDEFS()

  ///macro.

#define DIGRAPH_TYPEDEFS(Digraph)                                       \

  typedef Digraph::Node Node;                                           \

  typedef Digraph::NodeIt NodeIt;                                       \

  typedef Digraph::Arc Arc;                                             \

  typedef Digraph::ArcIt ArcIt;                                         \

  typedef Digraph::InArcIt InArcIt;                                     \

  typedef Digraph::OutArcIt OutArcIt;                                   \

  typedef Digraph::NodeMap<bool> BoolNodeMap;                           \

  typedef Digraph::NodeMap<int> IntNodeMap;                             \

  typedef Digraph::NodeMap<double> DoubleNodeMap;                       \

  typedef Digraph::ArcMap<bool> BoolArcMap;                             \

  typedef Digraph::ArcMap<int> IntArcMap;                               \

  typedef Digraph::ArcMap<double> DoubleArcMap

  ///Create convenience typedefs for the digraph types and iterators

  ///\see DIGRAPH_TYPEDEFS

  ///

  ///\note Use this macro, if the graph type is a dependent type,

  ///ie. the graph type depend on a template parameter.

#define TEMPLATE_DIGRAPH_TYPEDEFS(Digraph)                              \

  typedef typename Digraph::Node Node;                                  \

  typedef typename Digraph::NodeIt NodeIt;                              \

  typedef typename Digraph::Arc Arc;                                    \

  typedef typename Digraph::ArcIt ArcIt;                                \

  typedef typename Digraph::InArcIt InArcIt;                            \

  typedef typename Digraph::OutArcIt OutArcIt;                          \

  typedef typename Digraph::template NodeMap<bool> BoolNodeMap;         \

  typedef typename Digraph::template NodeMap<int> IntNodeMap;           \

  typedef typename Digraph::template NodeMap<double> DoubleNodeMap;     \

  typedef typename Digraph::template ArcMap<bool> BoolArcMap;           \

  typedef typename Digraph::template ArcMap<int> IntArcMap;             \

  typedef typename Digraph::template ArcMap<double> DoubleArcMap

  ///Create convenience typedefs for the graph types and iterators

  ///This \c \#define creates the same convenient type definitions as defined

  ///by \ref DIGRAPH_TYPEDEFS(Graph) and six more, namely it creates

  ///\c Edge, \c EdgeIt, \c IncEdgeIt, \c BoolEdgeMap, \c IntEdgeMap,

  ///\c DoubleEdgeMap.

  ///

  ///\note If the graph type is a dependent type, ie. the graph type depend

  ///on a template parameter, then use \c TEMPLATE_GRAPH_TYPEDEFS()

  ///macro.

#define GRAPH_TYPEDEFS(Graph)                                           \

  DIGRAPH_TYPEDEFS(Graph);                                              \

  typedef Graph::Edge Edge;                                             \

  typedef Graph::EdgeIt EdgeIt;                                         \

  typedef Graph::IncEdgeIt IncEdgeIt;                                   \

  typedef Graph::EdgeMap<bool> BoolEdgeMap;                             \

  typedef Graph::EdgeMap<int> IntEdgeMap;                               \

  typedef Graph::EdgeMap<double> DoubleEdgeMap

  ///Create convenience typedefs for the graph types and iterators

  ///\see GRAPH_TYPEDEFS

  ///

  ///\note Use this macro, if the graph type is a dependent type,

  ///ie. the graph type depend on a template parameter.

#define TEMPLATE_GRAPH_TYPEDEFS(Graph)                                  \

  TEMPLATE_DIGRAPH_TYPEDEFS(Graph);                                     \

  typedef typename Graph::Edge Edge;                                    \

  typedef typename Graph::EdgeIt EdgeIt;                                \

  typedef typename Graph::IncEdgeIt IncEdgeIt;                          \

  typedef typename Graph::template EdgeMap<bool> BoolEdgeMap;           \

  typedef typename Graph::template EdgeMap<int> IntEdgeMap;             \

  typedef typename Graph::template EdgeMap<double> DoubleEdgeMap

  /// \brief Function to count the items in a graph.

  ///

  /// This function counts the items (nodes, arcs etc.) in a graph.

  /// The complexity of the function is linear because

  /// it iterates on all of the items.

  template <typename Graph, typename Item>

  inline int countItems(const Graph& g) {

    typedef typename ItemSetTraits<Graph, Item>::ItemIt ItemIt;

    int num = 0;

    for (ItemIt it(g); it != INVALID; ++it) {

      ++num;

    }

    return num;