RhodeCode

      /// Default constructor.

      /// You have to call save() to actually make a snapshot.

      Snapshot()

        : digraph(0), node_observer_proxy(*this),

          arc_observer_proxy(*this) {}

      /// \brief Constructor that immediately makes a snapshot.

      ///

      /// This constructor immediately makes a snapshot of the given digraph.

      Snapshot(ListDigraph &gr)

        : node_observer_proxy(*this),

          arc_observer_proxy(*this) {

        attach(gr);

      }

      /// \brief Make a snapshot.

      ///

      /// This function makes a snapshot of the given digraph.

      /// It can be called more than once. In case of a repeated

      /// call, the previous snapshot gets lost.

      void save(ListDigraph &gr) {

        if (attached()) {

          detach();

          clear();

        }

        attach(gr);

      }

      /// \brief Undo the changes until the last snapshot.

      ///

      /// This function undos the changes until the last snapshot

      /// created by save() or Snapshot(ListDigraph&).

      void restore() {

        detach();

        for(std::list<Arc>::iterator it = added_arcs.begin();

            it != added_arcs.end(); ++it) {

          digraph->erase(*it);

        }

        for(std::list<Node>::iterator it = added_nodes.begin();

            it != added_nodes.end(); ++it) {

          digraph->erase(*it);

        }

        clear();

      }

      /// \brief Returns \c true if the snapshot is valid.

      ///

      /// This function returns \c true if the snapshot is valid.

      bool valid() const {

        return attached();

      }

    };

  };

  ///@}

  class ListGraphBase {

  protected:

    struct NodeT {

      int first_out;

      int prev, next;

      /// Default constructor.

      /// You have to call save() to actually make a snapshot.

      Snapshot()

        : graph(0), node_observer_proxy(*this),

          edge_observer_proxy(*this) {}

      /// \brief Constructor that immediately makes a snapshot.

      ///

      /// This constructor immediately makes a snapshot of the given graph.

      Snapshot(ListGraph &gr)

        : node_observer_proxy(*this),

          edge_observer_proxy(*this) {

        attach(gr);

      }

      /// \brief Make a snapshot.

      ///

      /// This function makes a snapshot of the given graph.

      /// It can be called more than once. In case of a repeated

      /// call, the previous snapshot gets lost.

      void save(ListGraph &gr) {

        if (attached()) {

          detach();

          clear();

        }

        attach(gr);

      }

      /// \brief Undo the changes until the last snapshot.

      ///

      /// This function undos the changes until the last snapshot

      /// created by save() or Snapshot(ListGraph&).

      void restore() {

        detach();

        for(std::list<Edge>::iterator it = added_edges.begin();

            it != added_edges.end(); ++it) {

          graph->erase(*it);

        }

        for(std::list<Node>::iterator it = added_nodes.begin();

            it != added_nodes.end(); ++it) {

          graph->erase(*it);

        }

        clear();

      }

      /// \brief Returns \c true if the snapshot is valid.

      ///

      /// This function returns \c true if the snapshot is valid.

      bool valid() const {

        return attached();

      }

    };

  };

  /// @}

} //namespace lemon

#endif

  G.addArc(n3, n);

  G.addArc(n, n3);

  checkGraphNodeList(G, 4);

  checkGraphArcList(G, 6);

  snapshot.restore();

  checkGraphNodeList(G, 3);

  checkGraphArcList(G, 4);

  checkGraphOutArcList(G, n1, 1);

  checkGraphOutArcList(G, n2, 3);

  checkGraphOutArcList(G, n3, 0);

  checkGraphInArcList(G, n1, 1);

  checkGraphInArcList(G, n2, 1);

  checkGraphInArcList(G, n3, 2);

  checkGraphConArcList(G, 4);

  checkNodeIds(G);

  checkArcIds(G);

  checkGraphNodeMap(G);

  checkGraphArcMap(G);

  G.addNode();

  snapshot.save(G);

  G.addArc(G.addNode(), G.addNode());

  snapshot.restore();

  checkGraphNodeList(G, 4);

  checkGraphArcList(G, 4);

}

void checkConcepts() {

  { // Checking digraph components

    checkConcept<BaseDigraphComponent, BaseDigraphComponent >();

    checkConcept<IDableDigraphComponent<>,

      IDableDigraphComponent<> >();

    checkConcept<IterableDigraphComponent<>,

      IterableDigraphComponent<> >();

    checkConcept<MappableDigraphComponent<>,

      MappableDigraphComponent<> >();

  }

  { // Checking skeleton digraph

    checkConcept<Digraph, Digraph>();

  }

  { // Checking ListDigraph

    checkConcept<Digraph, ListDigraph>();

    checkConcept<AlterableDigraphComponent<>, ListDigraph>();

    checkConcept<ExtendableDigraphComponent<>, ListDigraph>();

    checkConcept<ClearableDigraphComponent<>, ListDigraph>();

    checkConcept<ErasableDigraphComponent<>, ListDigraph>();

  }

  { // Checking SmartDigraph

    checkConcept<Digraph, SmartDigraph>();

    checkConcept<AlterableDigraphComponent<>, SmartDigraph>();

    checkConcept<ExtendableDigraphComponent<>, SmartDigraph>();

  G.addEdge(n3, n2);

  checkGraphNodeList(G, 4);

  checkGraphEdgeList(G, 6);

  checkGraphArcList(G, 12);

  snapshot.restore();

  checkGraphNodeList(G, 3);

  checkGraphEdgeList(G, 3);

  checkGraphArcList(G, 6);

  checkGraphIncEdgeArcLists(G, n1, 2);

  checkGraphIncEdgeArcLists(G, n2, 3);

  checkGraphIncEdgeArcLists(G, n3, 1);

  checkGraphConEdgeList(G, 3);

  checkGraphConArcList(G, 6);

  checkNodeIds(G);

  checkEdgeIds(G);

  checkArcIds(G);

  checkGraphNodeMap(G);

  checkGraphEdgeMap(G);

  checkGraphArcMap(G);

  G.addNode();

  snapshot.save(G);

  G.addEdge(G.addNode(), G.addNode());

  snapshot.restore();

  checkGraphNodeList(G, 4);

  checkGraphEdgeList(G, 3);

  checkGraphArcList(G, 6);

}

void checkFullGraph(int num) {

  typedef FullGraph Graph;

  GRAPH_TYPEDEFS(Graph);

  Graph G(num);

  check(G.nodeNum() == num && G.edgeNum() == num * (num - 1) / 2,

        "Wrong size");

  G.resize(num);

  check(G.nodeNum() == num && G.edgeNum() == num * (num - 1) / 2,

        "Wrong size");

  checkGraphNodeList(G, num);

  checkGraphEdgeList(G, num * (num - 1) / 2);

  for (NodeIt n(G); n != INVALID; ++n) {

    checkGraphOutArcList(G, n, num - 1);

    checkGraphInArcList(G, n, num - 1);

    checkGraphIncEdgeList(G, n, num - 1);

  }

  checkGraphConArcList(G, num * (num - 1));

  checkGraphConEdgeList(G, num * (num - 1) / 2);

  checkArcDirections(G);