lemon-0.x: comparison lemon/graph

equal deleted inserted replaced

-:b970e4c777ab
+:346747910baa
 typedef EdgeNumTagIndicator<Graph> EdgeNumTag;
 int edgeNum() const { return graph->edgeNum(); }
 typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
-Edge findEdge(const Node& source, const Node& target,
+Edge findEdge(const Node& u, const Node& v,
 		  const Edge& prev = INVALID) {
-return graph->findEdge(source, target, prev);
+return graph->findEdge(u, v, prev);
 }
 Node addNode() const {
 return Node(graph->addNode());
 }
-Edge addEdge(const Node& source, const Node& target) const {
+Edge addEdge(const Node& u, const Node& v) const {
-return Edge(graph->addEdge(source, target));
+return Edge(graph->addEdge(u, v));
 }
 void erase(const Node& i) const { graph->erase(i); }
 void erase(const Edge& i) const { graph->erase(i); }
 void clear() const { graph->clear(); }
 int id(const Node& v) const { return graph->id(v); }
 int id(const Edge& e) const { return graph->id(e); }
-Node fromNodeId(int id) const {
+Node fromNodeId(int ix) const {
-return graph->fromNodeId(id);
+return graph->fromNodeId(ix);
 }
-Edge fromEdgeId(int id) const {
+Edge fromEdgeId(int ix) const {
-return graph->fromEdgeId(id);
+return graph->fromEdgeId(ix);
 }
 int maxNodeId() const {
 return graph->maxNodeId();
 }
 Node source(const Edge& e) const { return Parent::target(e); }
 Node target(const Edge& e) const { return Parent::source(e); }
 typedef FindEdgeTagIndicator<Graph> FindEdgeTag;
-Edge findEdge(const Node& source, const Node& target,
+Edge findEdge(const Node& u, const Node& v,
 		  const Edge& prev = INVALID) {
-return Parent::findEdge(target, source, prev);
+return Parent::findEdge(v, u, prev);
 }
 };
 public:
 typedef Adaptor Graph;
 typedef SubMapExtender<Adaptor, typename Parent::
 template NodeMap<_Value> > Parent;
-NodeMap(const Graph& graph)
+NodeMap(const Graph& g)
-	: Parent(graph) {}
+	: Parent(g) {}
-NodeMap(const Graph& graph, const _Value& value)
+NodeMap(const Graph& g, const _Value& v)
-	: Parent(graph, value) {}
+	: Parent(g, v) {}
 NodeMap& operator=(const NodeMap& cmap) {
 	return operator=<NodeMap>(cmap);
 }
 public:
 typedef Adaptor Graph;
 typedef SubMapExtender<Adaptor, typename Parent::
 template EdgeMap<_Value> > Parent;
-EdgeMap(const Graph& graph)
+EdgeMap(const Graph& g)
-	: Parent(graph) {}
+	: Parent(g) {}
-EdgeMap(const Graph& graph, const _Value& value)
+EdgeMap(const Graph& g, const _Value& v)
-	: Parent(graph, value) {}
+	: Parent(g, v) {}
 EdgeMap& operator=(const EdgeMap& cmap) {
 	return operator=<EdgeMap>(cmap);
 }
 public:
 typedef Adaptor Graph;
 typedef SubMapExtender<Adaptor, typename Parent::
 template NodeMap<_Value> > Parent;
-NodeMap(const Graph& graph)
+NodeMap(const Graph& g)
-	: Parent(graph) {}
+	: Parent(g) {}
-NodeMap(const Graph& graph, const _Value& value)
+NodeMap(const Graph& g, const _Value& v)
-	: Parent(graph, value) {}
+	: Parent(g, v) {}
 NodeMap& operator=(const NodeMap& cmap) {
 	return operator=<NodeMap>(cmap);
 }
 public:
 typedef Adaptor Graph;
 typedef SubMapExtender<Adaptor, typename Parent::
 template EdgeMap<_Value> > Parent;
-EdgeMap(const Graph& graph)
+EdgeMap(const Graph& g)
-	: Parent(graph) {}
+	: Parent(g) {}
-EdgeMap(const Graph& graph, const _Value& value)
+EdgeMap(const Graph& g, const _Value& v)
-	: Parent(graph, value) {}
+	: Parent(g, v) {}
 EdgeMap& operator=(const EdgeMap& cmap) {
 	return operator=<EdgeMap>(cmap);
 }
 {
 public:
 typedef Adaptor Graph;
 typedef SubMapExtender<Adaptor, EdgeMapBase<_Value> > Parent;
-EdgeMap(const Graph& graph)
+EdgeMap(const Graph& g)
-	: Parent(graph) {}
+	: Parent(g) {}
-EdgeMap(const Graph& graph, const _Value& value)
+EdgeMap(const Graph& g, const _Value& v)
-	: Parent(graph, value) {}
+	: Parent(g, v) {}
 EdgeMap& operator=(const EdgeMap& cmap) {
 	return operator=<EdgeMap>(cmap);
 }
 protected:
 AlterableUndirGraphAdaptor()
 : Parent(), edge_notifier(*this), edge_notifier_proxy(*this) {}
-void setGraph(_Graph& graph) {
+void setGraph(_Graph& g) {
-Parent::setGraph(graph);
+Parent::setGraph(g);
-edge_notifier_proxy.setNotifier(graph.notifier(GraphEdge()));
+edge_notifier_proxy.setNotifier(g.notifier(GraphEdge()));
 }
 public:
 ~AlterableUndirGraphAdaptor() {
 if (Parent::attached()) {
 Parent::detach();
 }
 }
-void setNotifier(typename Graph::EdgeNotifier& notifier) {
+void setNotifier(typename Graph::EdgeNotifier& nf) {
-Parent::attach(notifier);
+Parent::attach(nf);
 }
 protected:
 edges.push_back(AdaptorBase::Parent::direct(ge, false));
 adaptor->notifier(Edge()).add(edges);
 }
 virtual void add(const std::vector<GraphEdge>& ge) {
 std::vector<Edge> edges;
-for (int i = 0; i < (int)ge.size(); ++i) {
+for (int i = 0; i < int(ge.size()); ++i) {
 edges.push_back(AdaptorBase::Parent::direct(ge[i], true));
 edges.push_back(AdaptorBase::Parent::direct(ge[i], false));
 }
 adaptor->notifier(Edge()).add(edges);
 }
 edges.push_back(AdaptorBase::Parent::direct(ge, false));
 adaptor->notifier(Edge()).erase(edges);
 }
 virtual void erase(const std::vector<GraphEdge>& ge) {
 std::vector<Edge> edges;
-for (int i = 0; i < (int)ge.size(); ++i) {
+for (int i = 0; i < int(ge.size()); ++i) {
 edges.push_back(AdaptorBase::Parent::direct(ge[i], true));
 edges.push_back(AdaptorBase::Parent::direct(ge[i], false));
 }
 adaptor->notifier(Edge()).erase(edges);
 }
 operator GraphEdge() const { return item.first(); }
 operator GraphNode() const { return item.second(); }
 };
-void first(Node& node) const {
+void first(Node& n) const {
-Parent::first(node);
+Parent::first(n);
-node.in_node = true;
+n.in_node = true;
 }
-void next(Node& node) const {
+void next(Node& n) const {
-if (node.in_node) {
+if (n.in_node) {
-	node.in_node = false;
+	n.in_node = false;
 } else {
-	node.in_node = true;
+	n.in_node = true;
-	Parent::next(node);
+	Parent::next(n);
 }
 }
-void first(Edge& edge) const {
+void first(Edge& e) const {
-edge.item.setSecond();
+e.item.setSecond();
-Parent::first(edge.item.second());
+Parent::first(e.item.second());
-if (edge.item.second() == INVALID) {
+if (e.item.second() == INVALID) {
-edge.item.setFirst();
+e.item.setFirst();
-	Parent::first(edge.item.first());
+	Parent::first(e.item.first());
 }
 }
-void next(Edge& edge) const {
+void next(Edge& e) const {
-if (edge.item.secondState()) {
+if (e.item.secondState()) {
-	Parent::next(edge.item.second());
+	Parent::next(e.item.second());
-if (edge.item.second() == INVALID) {
+if (e.item.second() == INVALID) {
-edge.item.setFirst();
+e.item.setFirst();
-Parent::first(edge.item.first());
+Parent::first(e.item.first());
 }
 } else {
-	Parent::next(edge.item.first());
+	Parent::next(e.item.first());
 }
 }
-void firstOut(Edge& edge, const Node& node) const {
+void firstOut(Edge& e, const Node& n) const {
-if (node.in_node) {
+if (n.in_node) {
-edge.item.setSecond(node);
+e.item.setSecond(n);
 } else {
-edge.item.setFirst();
+e.item.setFirst();
-	Parent::firstOut(edge.item.first(), node);
+	Parent::firstOut(e.item.first(), n);
 }
 }
-void nextOut(Edge& edge) const {
+void nextOut(Edge& e) const {
-if (!edge.item.firstState()) {
+if (!e.item.firstState()) {
-	edge.item.setFirst(INVALID);
+	e.item.setFirst(INVALID);
 } else {
-	Parent::nextOut(edge.item.first());
+	Parent::nextOut(e.item.first());
 }
 }
-void firstIn(Edge& edge, const Node& node) const {
+void firstIn(Edge& e, const Node& n) const {
-if (!node.in_node) {
+if (!n.in_node) {
-edge.item.setSecond(node);
+e.item.setSecond(n);
 } else {
-edge.item.setFirst();
+e.item.setFirst();
-	Parent::firstIn(edge.item.first(), node);
+	Parent::firstIn(e.item.first(), n);
 }
 }
-void nextIn(Edge& edge) const {
+void nextIn(Edge& e) const {
-if (!edge.item.firstState()) {
+if (!e.item.firstState()) {
-	edge.item.setFirst(INVALID);
+	e.item.setFirst(INVALID);
 } else {
-	Parent::nextIn(edge.item.first());
+	Parent::nextIn(e.item.first());
 }
 }
-Node source(const Edge& edge) const {
+Node source(const Edge& e) const {
-if (edge.item.firstState()) {
+if (e.item.firstState()) {
-	return Node(Parent::source(edge.item.first()), false);
+	return Node(Parent::source(e.item.first()), false);
 } else {
-	return Node(edge.item.second(), true);
+	return Node(e.item.second(), true);
 }
 }
-Node target(const Edge& edge) const {
+Node target(const Edge& e) const {
-if (edge.item.firstState()) {
+if (e.item.firstState()) {
-	return Node(Parent::target(edge.item.first()), true);
+	return Node(Parent::target(e.item.first()), true);
 } else {
-	return Node(edge.item.second(), false);
+	return Node(e.item.second(), false);
 }
 }
-int id(const Node& node) const {
+int id(const Node& n) const {
-return (Parent::id(node) << 1) | (node.in_node ? 0 : 1);
+return (Parent::id(n) << 1) | (n.in_node ? 0 : 1);
 }
-Node nodeFromId(int id) const {
+Node nodeFromId(int ix) const {
-return Node(Parent::nodeFromId(id >> 1), (id & 1) == 0);
+return Node(Parent::nodeFromId(ix >> 1), (ix & 1) == 0);
 }
 int maxNodeId() const {
 return 2 * Parent::maxNodeId() + 1;
 }
-int id(const Edge& edge) const {
+int id(const Edge& e) const {
-if (edge.item.firstState()) {
+if (e.item.firstState()) {
-return Parent::id(edge.item.first()) << 1;
+return Parent::id(e.item.first()) << 1;
 } else {
-return (Parent::id(edge.item.second()) << 1) | 1;
+return (Parent::id(e.item.second()) << 1) | 1;
 }
 }
-Edge edgeFromId(int id) const {
+Edge edgeFromId(int ix) const {
-if ((id & 1) == 0) {
+if ((ix & 1) == 0) {
-return Edge(Parent::edgeFromId(id >> 1));
+return Edge(Parent::edgeFromId(ix >> 1));
 } else {
-return Edge(Parent::nodeFromId(id >> 1));
+return Edge(Parent::nodeFromId(ix >> 1));
 }
 }
 int maxEdgeId() const {
 return std::max(Parent::maxNodeId() << 1,
 (Parent::maxEdgeId() << 1) | 1);
 }
 /// \brief Returns true when the node is in-node.
 ///
 /// Returns true when the node is in-node.
-static bool inNode(const Node& node) {
+static bool inNode(const Node& n) {
-return node.in_node;
+return n.in_node;
 }
 /// \brief Returns true when the node is out-node.
 ///
 /// Returns true when the node is out-node.
-static bool outNode(const Node& node) {
+static bool outNode(const Node& n) {
-return !node.in_node;
+return !n.in_node;
 }
 /// \brief Returns true when the edge is edge in the original graph.
 ///
 /// Returns true when the edge is edge in the original graph.
-static bool origEdge(const Edge& edge) {
+static bool origEdge(const Edge& e) {
-return edge.item.firstState();
+return e.item.firstState();
 }
 /// \brief Returns true when the edge binds an in-node and an out-node.
 ///
 /// Returns true when the edge binds an in-node and an out-node.
-static bool bindEdge(const Edge& edge) {
+static bool bindEdge(const Edge& e) {
-return edge.item.secondState();
+return e.item.secondState();
 }
 /// \brief Gives back the in-node created from the \c node.
 ///
 /// Gives back the in-node created from the \c node.
-static Node inNode(const GraphNode& node) {
+static Node inNode(const GraphNode& n) {
-return Node(node, true);
+return Node(n, true);
 }
 /// \brief Gives back the out-node created from the \c node.
 ///
 /// Gives back the out-node created from the \c node.
-static Node outNode(const GraphNode& node) {
+static Node outNode(const GraphNode& n) {
-return Node(node, false);
+return Node(n, false);
 }
 /// \brief Gives back the edge binds the two part of the node.
 ///
 /// Gives back the edge binds the two part of the node.
-static Edge edge(const GraphNode& node) {
+static Edge edge(const GraphNode& n) {
-return Edge(node);
+return Edge(n);
 }
 /// \brief Gives back the edge of the original edge.
 ///
 /// Gives back the edge of the original edge.
-static Edge edge(const GraphEdge& edge) {
+static Edge edge(const GraphEdge& e) {
-return Edge(edge);
+return Edge(e);
 }
 typedef True NodeNumTag;
 int nodeNum() const {
 return countEdges(*Parent::graph) + countNodes(*Parent::graph);
 }
 typedef True FindEdgeTag;
-Edge findEdge(const Node& source, const Node& target,
+Edge findEdge(const Node& u, const Node& v,
 		  const Edge& prev = INVALID) const {
-if (inNode(source)) {
+if (inNode(u)) {
-if (outNode(target)) {
+if (outNode(v)) {
-if ((GraphNode&)source == (GraphNode&)target && prev == INVALID) {
+if (static_cast<const GraphNode&>(u) ==
-return Edge(source);
+static_cast<const GraphNode&>(v) && prev == INVALID) {
+return Edge(u);
 }
 }
 } else {
-if (inNode(target)) {
+if (inNode(v)) {
-return Edge(findEdge(*Parent::graph, source, target, prev));
+return Edge(findEdge(*Parent::graph, u, v, prev));
 }
 }
 return INVALID;
 }
 adaptor->notifier(Node()).add(nodes);
 }
 virtual void add(const std::vector<GraphNode>& gn) {
 std::vector<Node> nodes;
-for (int i = 0; i < (int)gn.size(); ++i) {
+for (int i = 0; i < int(gn.size()); ++i) {
 nodes.push_back(AdaptorBase::Parent::inNode(gn[i]));
 nodes.push_back(AdaptorBase::Parent::outNode(gn[i]));
 }
 adaptor->notifier(Node()).add(nodes);
 }
 adaptor->notifier(Node()).erase(nodes);
 }
 virtual void erase(const std::vector<GraphNode>& gn) {
 std::vector<Node> nodes;
-for (int i = 0; i < (int)gn.size(); ++i) {
+for (int i = 0; i < int(gn.size()); ++i) {
 nodes.push_back(AdaptorBase::Parent::inNode(gn[i]));
 nodes.push_back(AdaptorBase::Parent::outNode(gn[i]));
 }
 adaptor->notifier(Node()).erase(nodes);
 }
 AlterableSplitGraphAdaptor()
 : Parent(), node_notifier(*this), edge_notifier(*this),
 node_notifier_proxy(*this), edge_notifier_proxy(*this) {}
-void setGraph(_Graph& graph) {
+void setGraph(_Graph& g) {
-Parent::setGraph(graph);
+Parent::setGraph(g);
-node_notifier_proxy.setNotifier(graph.notifier(GraphNode()));
+node_notifier_proxy.setNotifier(g.notifier(GraphNode()));
-edge_notifier_proxy.setNotifier(graph.notifier(GraphEdge()));
+edge_notifier_proxy.setNotifier(g.notifier(GraphEdge()));
 }
 public:
 ~AlterableSplitGraphAdaptor() {
 adaptor->notifier(Edge()).add(AdaptorBase::Parent::edge(gn));
 }
 virtual void add(const std::vector<GraphNode>& gn) {
 std::vector<Node> nodes;
 std::vector<Edge> edges;
-for (int i = 0; i < (int)gn.size(); ++i) {
+for (int i = 0; i < int(gn.size()); ++i) {
 edges.push_back(AdaptorBase::Parent::edge(gn[i]));
 nodes.push_back(AdaptorBase::Parent::inNode(gn[i]));
 nodes.push_back(AdaptorBase::Parent::outNode(gn[i]));
 }
 adaptor->notifier(Node()).add(nodes);
 adaptor->notifier(Node()).erase(nodes);
 }
 virtual void erase(const std::vector<GraphNode>& gn) {
 std::vector<Node> nodes;
 std::vector<Edge> edges;
-for (int i = 0; i < (int)gn.size(); ++i) {
+for (int i = 0; i < int(gn.size()); ++i) {
 edges.push_back(AdaptorBase::Parent::edge(gn[i]));
 nodes.push_back(AdaptorBase::Parent::inNode(gn[i]));
 nodes.push_back(AdaptorBase::Parent::outNode(gn[i]));
 }
 adaptor->notifier(Edge()).erase(edges);
 adaptor->notifier(Node()).erase(nodes);
 }
 virtual void build() {
 std::vector<Edge> edges;
-const typename Parent::Notifier* notifier = Parent::notifier();
+const typename Parent::Notifier* nf = Parent::notifier();
 GraphNode it;
-for (notifier->first(it); it != INVALID; notifier->next(it)) {
+for (nf->first(it); it != INVALID; nf->next(it)) {
 edges.push_back(AdaptorBase::Parent::edge(it));
 }
 adaptor->notifier(Node()).build();
 adaptor->notifier(Edge()).add(edges);
 }
 virtual void clear() {
 std::vector<Edge> edges;
-const typename Parent::Notifier* notifier = Parent::notifier();
+const typename Parent::Notifier* nf = Parent::notifier();
 GraphNode it;
-for (notifier->first(it); it != INVALID; notifier->next(it)) {
+for (nf->first(it); it != INVALID; nf->next(it)) {
 edges.push_back(AdaptorBase::Parent::edge(it));
 }
 adaptor->notifier(Edge()).erase(edges);
 adaptor->notifier(Node()).clear();
 }
 virtual void add(const GraphEdge& ge) {
 adaptor->notifier(Edge()).add(AdaptorBase::edge(ge));
 }
 virtual void add(const std::vector<GraphEdge>& ge) {
 std::vector<Edge> edges;
-for (int i = 0; i < (int)ge.size(); ++i) {
+for (int i = 0; i < int(ge.size()); ++i) {
 edges.push_back(AdaptorBase::edge(ge[i]));
 }
 adaptor->notifier(Edge()).add(edges);
 }
 virtual void erase(const GraphEdge& ge) {
 adaptor->notifier(Edge()).erase(AdaptorBase::edge(ge));
 }
 virtual void erase(const std::vector<GraphEdge>& ge) {
 std::vector<Edge> edges;
-for (int i = 0; i < (int)ge.size(); ++i) {
+for (int i = 0; i < int(ge.size()); ++i) {
 edges.push_back(AdaptorBase::edge(ge[i]));
 }
 adaptor->notifier(Edge()).erase(edges);
 }
 virtual void build() {
 std::vector<Edge> edges;
-const typename Parent::Notifier* notifier = Parent::notifier();
+const typename Parent::Notifier* nf = Parent::notifier();
 GraphEdge it;
-for (notifier->first(it); it != INVALID; notifier->next(it)) {
+for (nf->first(it); it != INVALID; nf->next(it)) {
 edges.push_back(AdaptorBase::Parent::edge(it));
 }
 adaptor->notifier(Edge()).add(edges);
 }
 virtual void clear() {
 std::vector<Edge> edges;
-const typename Parent::Notifier* notifier = Parent::notifier();
+const typename Parent::Notifier* nf = Parent::notifier();
 GraphEdge it;
-for (notifier->first(it); it != INVALID; notifier->next(it)) {
+for (nf->first(it); it != INVALID; nf->next(it)) {
 edges.push_back(AdaptorBase::Parent::edge(it));
 }
 adaptor->notifier(Edge()).erase(edges);
 }
 typedef typename Parent::Edge Edge;
 /// \brief Constructor of the adaptor.
 ///
 /// Constructor of the adaptor.
-SplitGraphAdaptor(_Graph& graph) {
+SplitGraphAdaptor(_Graph& g) {
-Parent::setGraph(graph);
+Parent::setGraph(g);
 }
 /// \brief NodeMap combined from two original NodeMap
 ///
 /// This class adapt two of the original graph NodeMap to

changeset 2386	81b47fc5c444
parent 2384	805c5a2a36dd
child 2391	14a343be7a5a