Changeset 1910:f95eea8c34b0 in lemon-0.x for lemon/bits/static_map.h

Timestamp:

01/26/06 17:24:40 (18 years ago)

Author:

Balazs Dezso

Branch:

default

Phase:

public

Convert:

svn:c9d7d8f5-90d6-0310-b91f-818b3a526b0e/lemon/trunk@2485

Message:

Bipartite => Bp
Upper => A
Lower => B

+ some bug fix

File:

• lemon/bits/static_map.h (modified) (16 diffs)

lemon/bits/static_map.h

@@ -3 +3 @@
  *
  * 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
@@ -28 +28 @@
 #include <lemon/concept/maps.h>
 
-/// \ingroup graphmaps
+/// \ingroin graphmaps
 ///
 ///\file
@@ -35 +35 @@
 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.
@@ -55 +55 @@
   public:
 
-    /// \brief Exception class for unsupported exceptions.
-    class UnsupportedOperation : public lemon::LogicError {
+    /// \brief Exception class for unsinported exceptions.
+    class UnsinportedOperation : public lemon::LogicError {
     public:
       virtual const char* exceptionName() const {
-        return "lemon::StaticMap::UnsupportedOperation";
+        return "lemon::StaticMap::UnsinportedOperation";
       }
     };
@@ -186 +186 @@
      
     void add(const Key&) {
-      throw UnsupportedOperation();
+      throw UnsinportedOperation();
     }
 
@@ -194 +194 @@
     /// and it overrides the erase() member function of the observer base.     
     void erase(const Key&) {
-      throw UnsupportedOperation();
+      throw UnsinportedOperation();
     }
 
@@ -347 +347 @@
 
   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::LowerNode LowerNode;
+    typedef typename Parent::ANode ANode;
+    typedef typename Parent::BNode BNode;
     typedef typename Parent::Edge Edge;
     typedef typename Parent::UEdge UEdge;
     
     template <typename _Value>
-    class UpperNodeMap 
-      : public IterableMapExtender<StaticMap<Graph, UpperNode, _Value> > {
-    public:
-      typedef StaticMappableUBipartiteGraphExtender Graph;
-      typedef IterableMapExtender<StaticMap<Graph, UpperNode, _Value> > 
+    class ANodeMap 
+      : public IterableMapExtender<StaticMap<Graph, ANode, _Value> > {
+    public:
+      typedef StaticMappableBpUGraphExtender Graph;
+      typedef IterableMapExtender<StaticMap<Graph, ANode, _Value> > 
       Parent;
     
-      UpperNodeMap(const Graph& _g) 
-        : Parent(_g) {}
-      UpperNodeMap(const Graph& _g, const _Value& _v) 
-        : Parent(_g, _v) {}
-    
-      UpperNodeMap& operator=(const UpperNodeMap& cmap) {
-        return operator=<UpperNodeMap>(cmap);
+      ANodeMap(const Graph& _g) 
+        : Parent(_g) {}
+      ANodeMap(const Graph& _g, const _Value& _v) 
+        : Parent(_g, _v) {}
+    
+      ANodeMap& operator=(const ANodeMap& cmap) {
+        return operator=<ANodeMap>(cmap);
       }
     
@@ -381 +381 @@
       /// 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) {
-        checkConcept<concept::ReadMap<UpperNode, _Value>, CMap>();
-        const typename Parent::Graph* graph = Parent::getGraph();
-        UpperNode it;
-        for (graph->first(it); it != INVALID; graph->next(it)) {
-          Parent::set(it, cmap[it]);
-        }
-        return *this;
-      }
-    
-    };
-
-    template <typename _Value>
-    class LowerNodeMap 
-      : public IterableMapExtender<StaticMap<Graph, LowerNode, _Value> > {
-    public:
-      typedef StaticMappableUBipartiteGraphExtender Graph;
-      typedef IterableMapExtender<StaticMap<Graph, LowerNode, _Value> > 
+      ANodeMap& operator=(const CMap& cmap) {
+        checkConcept<concept::ReadMap<ANode, _Value>, CMap>();
+        const typename Parent::Graph* graph = Parent::getGraph();
+        ANode it;
+        for (graph->first(it); it != INVALID; graph->next(it)) {
+          Parent::set(it, cmap[it]);
+        }
+        return *this;
+      }
+    
+    };
+
+    template <typename _Value>
+    class BNodeMap 
+      : public IterableMapExtender<StaticMap<Graph, BNode, _Value> > {
+    public:
+      typedef StaticMappableBpUGraphExtender Graph;
+      typedef IterableMapExtender<StaticMap<Graph, BNode, _Value> > 
       Parent;
     
-      LowerNodeMap(const Graph& _g) 
-        : Parent(_g) {}
-      LowerNodeMap(const Graph& _g, const _Value& _v) 
-        : Parent(_g, _v) {}
-    
-      LowerNodeMap& operator=(const LowerNodeMap& cmap) {
-        return operator=<LowerNodeMap>(cmap);
+      BNodeMap(const Graph& _g) 
+        : Parent(_g) {}
+      BNodeMap(const Graph& _g, const _Value& _v) 
+        : Parent(_g, _v) {}
+    
+      BNodeMap& operator=(const BNodeMap& cmap) {
+        return operator=<BNodeMap>(cmap);
       }
     
@@ -418 +418 @@
       /// 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) {
-        checkConcept<concept::ReadMap<LowerNode, _Value>, CMap>();
-        const typename Parent::Graph* graph = Parent::getGraph();
-        LowerNode it;
+      BNodeMap& operator=(const CMap& cmap) {
+        checkConcept<concept::ReadMap<BNode, _Value>, CMap>();
+        const typename Parent::Graph* graph = Parent::getGraph();
+        BNode it;
         for (graph->first(it); it != INVALID; graph->next(it)) {
           Parent::set(it, cmap[it]);
@@ -438 +438 @@
     class NodeMapBase : public Parent::NodeNotifier::ObserverBase {
     public:
-      typedef StaticMappableUBipartiteGraphExtender Graph;
+      typedef StaticMappableBpUGraphExtender Graph;
 
       typedef Node Key;
@@ -444 +444 @@
 
       /// 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), 
-          upperMap(_g, _v) {
+        : graph(&_g), bNodeMap(_g, _v), 
+          aNodeMap(_g, _v) {
         Parent::NodeNotifier::ObserverBase::attach(_g.getNotifier(Node()));
       }
@@ -474 +474 @@
     
       ConstReference operator[](const Key& node) const {
-        if (Parent::upper(node)) {
-          return upperMap[node];
+        if (Parent::aNode(node)) {
+          return aNodeMap[node];
         } else {
-          return lowerMap[node];
+          return bNodeMap[node];
         }
       } 
 
       Reference operator[](const Key& node) {
-        if (Parent::upper(node)) {
-          return upperMap[node];
+        if (Parent::aNode(node)) {
+          return aNodeMap[node];
         } else {
-          return lowerMap[node];
+          return bNodeMap[node];
         }
       }
 
       void set(const Key& node, const Value& value) {
-        if (Parent::upper(node)) {
-          upperMap.set(node, value);
+        if (Parent::aNode(node)) {
+          aNodeMap.set(node, value);
         } else {
-          lowerMap.set(node, value);
+          bNodeMap.set(node, value);
         }
       }
@@ -508 +508 @@
     private:
       const Graph* graph;
-      LowerNodeMap<_Value> lowerMap;
-      UpperNodeMap<_Value> upperMap;
+      BNodeMap<_Value> bNodeMap;
+      ANodeMap<_Value> aNodeMap;
     };
     
@@ -518 +518 @@
       : public IterableMapExtender<NodeMapBase<_Value> > {
     public:
-      typedef StaticMappableUBipartiteGraphExtender Graph;
+      typedef StaticMappableBpUGraphExtender Graph;
       typedef IterableMapExtender< NodeMapBase<_Value> > Parent;
     
@@ -556 +556 @@
       : public IterableMapExtender<StaticMap<Graph, Edge, _Value> > {
     public:
-      typedef StaticMappableUBipartiteGraphExtender Graph;
+      typedef StaticMappableBpUGraphExtender Graph;
       typedef IterableMapExtender<StaticMap<Graph, Edge, _Value> > Parent;
     
@@ -584 +584 @@
       : public IterableMapExtender<StaticMap<Graph, UEdge, _Value> > {
     public:
-      typedef StaticMappableUBipartiteGraphExtender Graph;
+      typedef StaticMappableBpUGraphExtender Graph;
       typedef IterableMapExtender<StaticMap<Graph, UEdge, _Value> > 
       Parent;