source: lemon-0.x/src/lemon/concept/undir_graph.h @ 1022:567f392d1d2e

/* -*- C++ -*-
 *
 * src/lemon/concept/undir_graph_component.h - Part of LEMON, a generic
 * C++ optimization library
 *
 * Copyright (C) 2004 Egervary Jeno Kombinatorikus Optimalizalasi
 * Kutatocsoport (Egervary Combinatorial Optimization Research Group,
 * 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 Undirected graphs and components of.


#ifndef LEMON_CONCEPT_UNDIR_GRAPH_H
#define LEMON_CONCEPT_UNDIR_GRAPH_H

#include <lemon/concept/graph_component.h>

namespace lemon {
  namespace concept {

    /// \todo to be done

    struct BaseIterableUndirGraphConcept {

      template <typename Graph>
      struct Constraints {

        typedef typename Graph::UndirEdge UndirEdge;
        typedef typename Graph::Edge Edge;
        typedef typename Graph::Node Node;

        void constraints() {
          checkConcept<BaseIterableGraphComponent, Graph>();
          checkConcept<GraphItem<'u'>, UndirEdge >();

          /// \bug this should be base_and_derived:
          UndirEdge ue = e;
          ue = e;

          Node n;
          n = graph.target(ue);
          n = graph.source(ue);

          graph.first(ue);
          graph.next(ue);
        }
        const Graph &graph;
        Edge e;
      };

    };


    struct IterableUndirGraphConcept {

      template <typename Graph>
      struct Constraints {
        void constraints() {
          /// \todo we don't need the iterable component to be base iterable
          /// Don't we really???
          //checkConcept< BaseIterableUndirGraphConcept, Graph > ();

          checkConcept<IterableGraphComponent, Graph> ();

          typedef typename Graph::UndirEdge UndirEdge;
          typedef typename Graph::UndirEdgeIt UndirEdgeIt;
          typedef typename Graph::UndirIncEdgeIt UndirIncEdgeIt;

          checkConcept<GraphIterator<Graph, UndirEdge>, UndirEdgeIt>();
          checkConcept<GraphIncIterator<Graph, UndirEdge>, UndirIncEdgeIt>();
        }
      };

    };

    struct MappableUndirGraphConcept {

      template <typename Graph>
      struct Constraints {

        struct Dummy {
          int value;
          Dummy() : value(0) {}
          Dummy(int _v) : value(_v) {}
        };

        void constraints() {
          checkConcept<MappableGraphComponent, Graph>();

          typedef typename Graph::template UndirEdgeMap<int> IntMap;
          checkConcept<GraphMap<Graph, typename Graph::UndirEdge, int>,
            IntMap >();

          typedef typename Graph::template UndirEdgeMap<bool> BoolMap;
          checkConcept<GraphMap<Graph, typename Graph::UndirEdge, bool>,
            BoolMap >();

          typedef typename Graph::template UndirEdgeMap<Dummy> DummyMap;
          checkConcept<GraphMap<Graph, typename Graph::UndirEdge, Dummy>,
            DummyMap >();
        }
      };

    };

    struct ExtendableUndirGraphConcept {

      template <typename Graph>
      struct Constraints {
        void constraints() {
          node_a = graph.addNode();
          uedge = graph.addEdge(node_a, node_b);
        }
        typename Graph::Node node_a, node_b;
        typename Graph::UndirEdge uedge;
        Graph graph;
      };

    };

    struct ErasableUndirGraphConcept {

      template <typename Graph>
      struct Constraints {
        void constraints() {
          graph.erase(n);
          graph.erase(e);
        }
        Graph graph;
        typename Graph::Node n;
        typename Graph::UndirEdge e;
      };

    };

    class UndirGraph {
    public:

      template <typename Graph>
      struct Constraints {
        void constraints() {
          checkConcept<BaseIterableUndirGraphConcept, Graph>();
          checkConcept<IterableUndirGraphConcept, Graph>();
          checkConcept<MappableUndirGraphConcept, Graph>();
        }
      };

    };

    class ExtendableUndirGraph : public UndirGraph {
    public:

      template <typename Graph>
      struct Constraints {
        void constraints() {
          checkConcept<BaseIterableUndirGraphConcept, Graph>();
          checkConcept<IterableUndirGraphConcept, Graph>();
          checkConcept<MappableUndirGraphConcept, Graph>();

          checkConcept<UndirGraph, Graph>();
          checkConcept<ExtendableUndirGraphConcept, Graph>();
          checkConcept<ClearableGraphComponent, Graph>();
        }
      };

    };

    class ErasableUndirGraph : public ExtendableUndirGraph {
    public:

      template <typename Graph>
      struct Constraints {
        void constraints() {
          checkConcept<ExtendableUndirGraph, Graph>();
          checkConcept<ErasableUndirGraphConcept, Graph>();
        }
      };

    };

  }

}

#endif