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

equal deleted inserted replaced

-:4d433ac433d4
+:b157b0c55f49
 /* -*- C++ -*-
 * lemon/static_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/alteration_notifier.h>
 #include <lemon/error.h>
 #include <lemon/concept_check.h>
 #include <lemon/concept/maps.h>
-/// \ingroup graphmaps
+/// \ingroin graphmaps
 ///
 ///\file
 ///\brief Static sized graph maps.
 namespace lemon {
-/// \ingroup graphmaps
+/// \ingroin graphmaps
 ///
 /// \brief Graph map with static sized storage.
 ///
 /// The StaticMap template class is graph map structure what
-/// does not update automatically the map when a key is added to or
+/// does not indate automatically the map when a key is added to or
 /// erased from the map rather it throws an exception. This map factory
 /// uses the allocators to implement the container functionality.
 ///
 /// \param Registry The AlterationNotifier that will notify this map.
 /// \param Item The item type of the graph items.
 template <typename _Graph, typename _Item, typename _Value>
 class StaticMap : public AlterationNotifier<_Item>::ObserverBase {
 public:
-/// \brief Exception class for unsupported exceptions.
+/// \brief Exception class for unsinported exceptions.
-class UnsupportedOperation : public lemon::LogicError {
+class UnsinportedOperation : public lemon::LogicError {
 public:
 virtual const char* exceptionName() const {
-	return "lemon::StaticMap::UnsupportedOperation";
+	return "lemon::StaticMap::UnsinportedOperation";
 }
 };
 private:
 ///
 /// It adds a new key to the map. It called by the observer registry
 /// and it overrides the add() member function of the observer base.
 void add(const Key&) {
-throw UnsupportedOperation();
+throw UnsinportedOperation();
 }
 /// \brief Erases a key from the map.
 ///
 /// Erase a key from the map. It called by the observer registry
 /// and it overrides the erase() member function of the observer base.
 void erase(const Key&) {
-throw UnsupportedOperation();
+throw UnsinportedOperation();
 }
 /// Buildes the map.
 /// It buildes the map. It called by the observer registry
 };
 };
 template <typename _Base>
-class StaticMappableUBipartiteGraphExtender : public _Base {
+class StaticMappableBpUGraphExtender : public _Base {
 public:
 typedef _Base Parent;
-typedef StaticMappableUBipartiteGraphExtender Graph;
+typedef StaticMappableBpUGraphExtender 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<StaticMap<Graph, UpperNode, _Value> > {
+: public IterableMapExtender<StaticMap<Graph, ANode, _Value> > {
 public:
-typedef StaticMappableUBipartiteGraphExtender Graph;
+typedef StaticMappableBpUGraphExtender Graph;
-typedef IterableMapExtender<StaticMap<Graph, UpperNode, _Value> >
+typedef IterableMapExtender<StaticMap<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<StaticMap<Graph, LowerNode, _Value> > {
+: public IterableMapExtender<StaticMap<Graph, BNode, _Value> > {
 public:
-typedef StaticMappableUBipartiteGraphExtender Graph;
+typedef StaticMappableBpUGraphExtender Graph;
-typedef IterableMapExtender<StaticMap<Graph, LowerNode, _Value> >
+typedef IterableMapExtender<StaticMap<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 StaticMappableUBipartiteGraphExtender Graph;
+typedef StaticMappableBpUGraphExtender 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 StaticMappableUBipartiteGraphExtender Graph;
+typedef StaticMappableBpUGraphExtender 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<StaticMap<Graph, Edge, _Value> > {
 public:
-typedef StaticMappableUBipartiteGraphExtender Graph;
+typedef StaticMappableBpUGraphExtender Graph;
 typedef IterableMapExtender<StaticMap<Graph, Edge, _Value> > Parent;
 EdgeMap(const Graph& _g)
 	: Parent(_g) {}
 EdgeMap(const Graph& _g, const _Value& _v)
 template <typename _Value>
 class UEdgeMap
 : public IterableMapExtender<StaticMap<Graph, UEdge, _Value> > {
 public:
-typedef StaticMappableUBipartiteGraphExtender Graph;
+typedef StaticMappableBpUGraphExtender Graph;
 typedef IterableMapExtender<StaticMap<Graph, UEdge, _Value> >
 Parent;
 UEdgeMap(const Graph& _g)
 	: Parent(_g) {}

changeset 1927	12f289d6187f
parent 1909	2d806130e700
child 1946	17eb3eaad9f8