lemon-0.x: comparison lemon/bits/default

equal deleted inserted replaced

-:0f3ca6c0d6a1
+:62446984e996
 /* -*- C++ -*-
 * lemon/default_map.h - Part of LEMON, a generic C++ optimization library
 *
 * Copyright (C) 2006 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport
-* (Egervary Research Group on Combinatorial Optimization, EGRES).
+* (Egervary Research Groin 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.
 *
 #include <lemon/bits/array_map.h>
 #include <lemon/bits/vector_map.h>
-///\ingroup graphmapfactory
+///\ingroin graphmapfactory
 ///\file
 ///\brief Graph maps that construct and destruct
 ///their elements dynamically.
 namespace lemon {
 };
 template <typename _Base>
-class MappableUBipartiteGraphExtender : public _Base {
+class MappableBpUGraphExtender : public _Base {
 public:
 typedef _Base Parent;
-typedef MappableUBipartiteGraphExtender Graph;
+typedef MappableBpUGraphExtender Graph;
 typedef typename Parent::Node Node;
-typedef typename Parent::UpperNode UpperNode;
+typedef typename Parent::ANode ANode;
-typedef typename Parent::LowerNode LowerNode;
+typedef typename Parent::BNode BNode;
 typedef typename Parent::Edge Edge;
 typedef typename Parent::UEdge UEdge;
 template <typename _Value>
-class UpperNodeMap
+class ANodeMap
-: public IterableMapExtender<DefaultMap<Graph, UpperNode, _Value> > {
+: public IterableMapExtender<DefaultMap<Graph, ANode, _Value> > {
 public:
-typedef MappableUBipartiteGraphExtender Graph;
+typedef MappableBpUGraphExtender Graph;
-typedef IterableMapExtender<DefaultMap<Graph, UpperNode, _Value> >
+typedef IterableMapExtender<DefaultMap<Graph, ANode, _Value> >
 Parent;
-UpperNodeMap(const Graph& _g)
+ANodeMap(const Graph& _g)
 	: Parent(_g) {}
-UpperNodeMap(const Graph& _g, const _Value& _v)
+ANodeMap(const Graph& _g, const _Value& _v)
 	: Parent(_g, _v) {}
-UpperNodeMap& operator=(const UpperNodeMap& cmap) {
+ANodeMap& operator=(const ANodeMap& cmap) {
-	return operator=<UpperNodeMap>(cmap);
+	return operator=<ANodeMap>(cmap);
 }
 /// \brief Template assign operator.
 ///
 /// The given parameter should be conform to the ReadMap
 /// concept and could be indiced by the current item set of
-/// the UpperNodeMap. In this case the value for each item
+/// the ANodeMap. In this case the value for each item
 /// is assigned by the value of the given ReadMap.
 template <typename CMap>
-UpperNodeMap& operator=(const CMap& cmap) {
+ANodeMap& operator=(const CMap& cmap) {
-	checkConcept<concept::ReadMap<UpperNode, _Value>, CMap>();
+	checkConcept<concept::ReadMap<ANode, _Value>, CMap>();
 	const typename Parent::Graph* graph = Parent::getGraph();
-	UpperNode it;
+	ANode it;
 	for (graph->first(it); it != INVALID; graph->next(it)) {
 	  Parent::set(it, cmap[it]);
 	}
 	return *this;
 }
 };
 template <typename _Value>
-class LowerNodeMap
+class BNodeMap
-: public IterableMapExtender<DefaultMap<Graph, LowerNode, _Value> > {
+: public IterableMapExtender<DefaultMap<Graph, BNode, _Value> > {
 public:
-typedef MappableUBipartiteGraphExtender Graph;
+typedef MappableBpUGraphExtender Graph;
-typedef IterableMapExtender<DefaultMap<Graph, LowerNode, _Value> >
+typedef IterableMapExtender<DefaultMap<Graph, BNode, _Value> >
 Parent;
-LowerNodeMap(const Graph& _g)
+BNodeMap(const Graph& _g)
 	: Parent(_g) {}
-LowerNodeMap(const Graph& _g, const _Value& _v)
+BNodeMap(const Graph& _g, const _Value& _v)
 	: Parent(_g, _v) {}
-LowerNodeMap& operator=(const LowerNodeMap& cmap) {
+BNodeMap& operator=(const BNodeMap& cmap) {
-	return operator=<LowerNodeMap>(cmap);
+	return operator=<BNodeMap>(cmap);
 }
 /// \brief Template assign operator.
 ///
 /// The given parameter should be conform to the ReadMap
 /// concept and could be indiced by the current item set of
-/// the LowerNodeMap. In this case the value for each item
+/// the BNodeMap. In this case the value for each item
 /// is assigned by the value of the given ReadMap.
 template <typename CMap>
-LowerNodeMap& operator=(const CMap& cmap) {
+BNodeMap& operator=(const CMap& cmap) {
-	checkConcept<concept::ReadMap<LowerNode, _Value>, CMap>();
+	checkConcept<concept::ReadMap<BNode, _Value>, CMap>();
 	const typename Parent::Graph* graph = Parent::getGraph();
-	LowerNode it;
+	BNode it;
 	for (graph->first(it); it != INVALID; graph->next(it)) {
 	  Parent::set(it, cmap[it]);
 	}
 	return *this;
 }
 protected:
 template <typename _Value>
 class NodeMapBase : public Parent::NodeNotifier::ObserverBase {
 public:
-typedef MappableUBipartiteGraphExtender Graph;
+typedef MappableBpUGraphExtender Graph;
 typedef Node Key;
 typedef _Value Value;
 /// The reference type of the map;
-typedef typename LowerNodeMap<_Value>::Reference Reference;
+typedef typename BNodeMap<_Value>::Reference Reference;
 /// The pointer type of the map;
-typedef typename LowerNodeMap<_Value>::Pointer Pointer;
+typedef typename BNodeMap<_Value>::Pointer Pointer;
 /// The const value type of the map.
 typedef const Value ConstValue;
 /// The const reference type of the map;
-typedef typename LowerNodeMap<_Value>::ConstReference ConstReference;
+typedef typename BNodeMap<_Value>::ConstReference ConstReference;
 /// The pointer type of the map;
-typedef typename LowerNodeMap<_Value>::ConstPointer ConstPointer;
+typedef typename BNodeMap<_Value>::ConstPointer ConstPointer;
 typedef True ReferenceMapTag;
 NodeMapBase(const Graph& _g)
-	: graph(&_g), lowerMap(_g), upperMap(_g) {
+	: graph(&_g), bNodeMap(_g), aNodeMap(_g) {
 	Parent::NodeNotifier::ObserverBase::attach(_g.getNotifier(Node()));
 }
 NodeMapBase(const Graph& _g, const _Value& _v)
-	: graph(&_g), lowerMap(_g, _v),
+	: graph(&_g), bNodeMap(_g, _v),
-	  upperMap(_g, _v) {
+	  aNodeMap(_g, _v) {
 	Parent::NodeNotifier::ObserverBase::attach(_g.getNotifier(Node()));
 }
 virtual ~NodeMapBase() {
 	if (Parent::NodeNotifier::ObserverBase::attached()) {
 	  Parent::NodeNotifier::ObserverBase::detach();
 	}
 }
 ConstReference operator[](const Key& node) const {
-	if (Parent::upper(node)) {
+	if (Parent::aNode(node)) {
-	  return upperMap[node];
+	  return aNodeMap[node];
 	} else {
-	  return lowerMap[node];
+	  return bNodeMap[node];
 	}
 }
 Reference operator[](const Key& node) {
-	if (Parent::upper(node)) {
+	if (Parent::aNode(node)) {
-	  return upperMap[node];
+	  return aNodeMap[node];
 	} else {
-	  return lowerMap[node];
+	  return bNodeMap[node];
 	}
 }
 void set(const Key& node, const Value& value) {
-	if (Parent::upper(node)) {
+	if (Parent::aNode(node)) {
-	  upperMap.set(node, value);
+	  aNodeMap.set(node, value);
 	} else {
-	  lowerMap.set(node, value);
+	  bNodeMap.set(node, value);
 	}
 }
 protected:
 const Graph* getGraph() const { return graph; }
 private:
 const Graph* graph;
-LowerNodeMap<_Value> lowerMap;
+BNodeMap<_Value> bNodeMap;
-UpperNodeMap<_Value> upperMap;
+ANodeMap<_Value> aNodeMap;
 };
 public:
 template <typename _Value>
 class NodeMap
 : public IterableMapExtender<NodeMapBase<_Value> > {
 public:
-typedef MappableUBipartiteGraphExtender Graph;
+typedef MappableBpUGraphExtender Graph;
 typedef IterableMapExtender< NodeMapBase<_Value> > Parent;
 NodeMap(const Graph& _g)
 	: Parent(_g) {}
 NodeMap(const Graph& _g, const _Value& _v)
 template <typename _Value>
 class EdgeMap
 : public IterableMapExtender<DefaultMap<Graph, Edge, _Value> > {
 public:
-typedef MappableUBipartiteGraphExtender Graph;
+typedef MappableBpUGraphExtender Graph;
 typedef IterableMapExtender<DefaultMap<Graph, Edge, _Value> > Parent;
 EdgeMap(const Graph& _g)
 	: Parent(_g) {}
 EdgeMap(const Graph& _g, const _Value& _v)
 template <typename _Value>
 class UEdgeMap
 : public IterableMapExtender<DefaultMap<Graph, UEdge, _Value> > {
 public:
-typedef MappableUBipartiteGraphExtender Graph;
+typedef MappableBpUGraphExtender Graph;
 typedef IterableMapExtender<DefaultMap<Graph, UEdge, _Value> >
 Parent;
 UEdgeMap(const Graph& _g)
 	: Parent(_g) {}

changeset 1913	49fe71fce7fb
parent 1909	2d806130e700
child 1946	17eb3eaad9f8