Changeset 987:87f7c54892df in lemon-0.x for src/work

Timestamp:

11/13/04 18:07:10 (20 years ago)

Author:

Alpar Juttner

Branch:

default

Phase:

public

Convert:

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

Message:

Naming changes:

• ValueType? -> Value
• KeyType? -> Key
• ReferenceType? ->Reference
• PointerType? -> Pointer

Location:

src/work

Files:

• alpar/boolmap_iter.cc (modified) (2 diffs)
• alpar/dijkstra.h (modified) (8 diffs)
• alpar/f_ed_ka.h (modified) (2 diffs)
• alpar/rw_nonref_map.cc (modified) (4 diffs)
• athos/mincostflow.h (modified) (2 diffs)
• athos/old/minlengthpaths.h (modified) (2 diffs)
• athos/union_find.h (modified) (4 diffs)
• deba/dijkstra.h (modified) (6 diffs)
• klao/iter_map.h (modified) (7 diffs)
• marci/augmenting_flow.h (modified) (1 diff)
• marci/bfs_mm.h (modified) (4 diffs)
• marci/bipartite_graph_wrapper.h (modified) (5 diffs)
• marci/experiment/list_graph.h (modified) (2 diffs)
• marci/graph_concept.h (modified) (2 diffs)
• marci/leda/leda_graph_wrapper.h (modified) (4 diffs)
• peter/edgepathgraph.h (modified) (2 diffs)
• peter/hierarchygraph.h (modified) (2 diffs)
• sage_graph.h (modified) (2 diffs)

src/work/alpar/boolmap_iter.cc

@@ -14 +14 @@
   typedef typename GG::Edge Edge;
   
-  typedef Edge KeyType;
-  typedef bool ValueType;
+  typedef Edge Key;
+  typedef bool Value;
   
   friend class RefType;
@@ -68 +68 @@
     RefType(BoolIterEdgeMap &_M,Edge _e) : M(_M), e(_e) { }
     
-    operator ValueType() const 
+    operator Value() const 
     {
       return M.isTrue(e);
       
     }
-    ValueType operator = (ValueType v) const
+    Value operator = (Value v) const
     {
       if(v) M.setTrue(e); 

src/work/alpar/dijkstra.h

@@ -47 +47 @@
     typedef LM LengthMap;
     //The type of the length of the edges.
-    typedef typename LM::ValueType ValueType;
+    typedef typename LM::Value Value;
     ///The heap type used by Dijkstra algorithm.
 
@@ -55 +55 @@
     ///\sa Dijkstra
     typedef BinHeap<typename Graph::Node,
-                    typename LM::ValueType,
+                    typename LM::Value,
                     typename GR::template NodeMap<int>,
-                    std::less<ValueType> > Heap;
+                    std::less<Value> > Heap;
 
     ///\brief The type of the map that stores the last
@@ -91 +91 @@
     ///It must meet the \ref concept::WriteMap "WriteMap" concept.
     ///
-    typedef typename Graph::template NodeMap<typename LM::ValueType> DistMap;
+    typedef typename Graph::template NodeMap<typename LM::Value> DistMap;
     ///Instantiates a DistMap.
  
@@ -110 +110 @@
   ///
   ///The type of the length is determined by the
-  ///\ref concept::ReadMap::ValueType "ValueType" of the length map.
+  ///\ref concept::ReadMap::Value "Value" of the length map.
   ///
   ///It is also possible to change the underlying priority heap.
@@ -159 +159 @@
     
     ///The type of the length of the edges.
-    typedef typename TR::LengthMap::ValueType ValueType;
+    typedef typename TR::LengthMap::Value Value;
     ///The type of the map that stores the edge lengths.
     typedef typename TR::LengthMap LengthMap;
@@ -388 +388 @@
         
         Node v=heap.top(); 
-        ValueType oldvalue=heap[v];
+        Value oldvalue=heap[v];
         heap.pop();
         distance->set(v, oldvalue);
@@ -421 +421 @@
     ///\warning If node \c v in unreachable from the root the return value
     ///of this funcion is undefined.
-    ValueType dist(Node v) const { return (*distance)[v]; }
+    Value dist(Node v) const { return (*distance)[v]; }
 
     ///Returns the 'previous edge' of the shortest path tree.
@@ -498 +498 @@
     typedef typename TR::LengthMap LengthMap;
     ///The type of the length of the edges.
-    typedef typename LengthMap::ValueType ValueType;
+    typedef typename LengthMap::Value Value;
     ///\brief The type of the map that stores the last
     ///edges of the shortest paths.

src/work/alpar/f_ed_ka.h

@@ -14 +14 @@
 namespace lemon {
   template <typename Graph, typename FlowMap, typename CapacityMap>
-  typename FlowMap::ValueType maxFlow(Graph &G,
+  typename FlowMap::Value maxFlow(Graph &G,
                                       FlowMap &f,
                                       CapacityMap &c,
@@ -26 +26 @@
     typedef typename Graph::OutEdgeIt OutEdgeIt;
     typedef typename Graph::InEdgeIt InEdgeIt;
-    typedef typename FlowMap::ValueType T;
+    typedef typename FlowMap::Value T;
     
     T flow_val = 0;

src/work/alpar/rw_nonref_map.cc

@@ -11 +11 @@
   typedef typename GG::Edge Edge;
   
-  typedef Edge KeyType;
-  typedef TT ValueType;
+  typedef Edge Key;
+  typedef TT Value;
   
   class RefType 
@@ -21 +21 @@
     RefType(Graph &_G,Edge _e) : G(_G), e(_e) { }
     
-    operator ValueType() const 
+    operator Value() const 
     {
-      ValueType tmp;
+      Value tmp;
       std::cout << G.id(G.source(e)) << "->"
                 << G.id(G.target(e)) << ": ";
@@ -29 +29 @@
       return tmp;
     }
-    ValueType operator = (ValueType v) const
+    Value operator = (Value v) const
     {
       std::cout << G.id(G.source(e)) << "->"
@@ -48 +48 @@
 {
 public:
-  typedef K KeyType;
-  typedef T ValueType;
+  typedef K Key;
+  typedef T Value;
   
   class RefType 
   {
-    ValueType val;
+    Value val;
   public:
-    RefType(ValueType v) : val(v) { }   
-    operator ValueType() const { return val; }
-    ValueType operator = (ValueType v) const { return val; }
+    RefType(Value v) : val(v) { }   
+    operator Value() const { return val; }
+    Value operator = (Value v) const { return val; }
   };
   
 private:
-  ValueType val;
+  Value val;
 public:
-  NullMap(ValueType v) : val(v) { }
-  RefType operator[] (KeyType e) const { return RefType(v);}  
+  NullMap(Value v) : val(v) { }
+  RefType operator[] (Key e) const { return RefType(v);}  
 };
 

src/work/athos/mincostflow.h

@@ -44 +44 @@
   class MinCostFlow {
 
-    typedef typename CostMap::ValueType Cost;
-
-
-    typedef typename SupplyDemandMap::ValueType SupplyDemand;
+    typedef typename CostMap::Value Cost;
+
+
+    typedef typename SupplyDemandMap::Value SupplyDemand;
     
     typedef typename Graph::Node Node;
@@ -69 +69 @@
       const NodeMap &pot;
     public :
-      typedef typename CostMap::KeyType KeyType;
-      typedef typename CostMap::ValueType ValueType;
+      typedef typename CostMap::Key Key;
+      typedef typename CostMap::Value Value;
         
-      ValueType operator[](typename ResGraph::Edge e) const {     
+      Value operator[](typename ResGraph::Edge e) const {     
         if (res_graph.forward(e))
           return  ol[e]-(pot[res_graph.target(e)]-pot[res_graph.source(e)]);   

src/work/athos/old/minlengthpaths.h

@@ -31 +31 @@
   class MinLengthPaths {
 
-    typedef typename LengthMap::ValueType Length;
+    typedef typename LengthMap::Value Length;
     
     typedef typename Graph::Node Node;
@@ -50 +50 @@
       const NodeMap &pot;
     public :
-      typedef typename LengthMap::KeyType KeyType;
-      typedef typename LengthMap::ValueType ValueType;
-        
-      ValueType operator[](typename ResGraphType::Edge e) const {     
+      typedef typename LengthMap::Key Key;
+      typedef typename LengthMap::Value Value;
+        
+      Value operator[](typename ResGraphType::Edge e) const {     
         //if ( (1-2*rev[e])*ol[e]-(pot[G.target(e)]-pot[G.source(e)] ) <0 ){
         //  std::cout<<"Negative length!!"<<std::endl;

src/work/athos/union_find.h

@@ -16 +16 @@
 namespace lemon {
   
-  template <typename KeyType, typename KeyIntMap>
+  template <typename Key, typename KeyIntMap>
     class UnionFind {
     KeyIntMap& pointmap;
@@ -35 +35 @@
     
     //Give a component of one point to the structure
-    int addPoint(KeyType u){
+    int addPoint(Key u){
       int _index = container.size();
       VectorElementType buf(_index,1);
@@ -44 +44 @@
     
     //Finds the big boss of u
-    int find(KeyType u){
+    int find(Key u){
       if (pointmap.get(u)==-1){
         int whoami = addPoint(u);
@@ -62 +62 @@
 
     //Finds u and v in the structures and merges the comopnents, if not equal
-    bool findAndMerge(KeyType u,KeyType v){
+    bool findAndMerge(Key u,Key v){
       int bu = find(u);
       int bv = find(v);

src/work/deba/dijkstra.h

@@ -22 +22 @@
   ///so it is easy to change it to any kind of length.
   ///
-  ///The type of the length is determined by the \c ValueType of the length map.
+  ///The type of the length is determined by the \c Value of the length map.
   ///
   ///It is also possible to change the underlying priority heap.
@@ -60 +60 @@
     
     ///The type of the length of the edges.
-    typedef typename LM::ValueType ValueType;
+    typedef typename LM::Value Value;
     ///The type of the map that stores the edge lengths.
     typedef LM LengthMap;
@@ -70 +70 @@
     typedef typename Graph::template NodeMap<Node> PredNodeMap;
     ///The type of the map that stores the dists of the nodes.
-    typedef typename Graph::template NodeMap<ValueType> DistMap;
+    typedef typename Graph::template NodeMap<Value> DistMap;
 
   private:
@@ -217 +217 @@
       typename GR::template NodeMap<int> heap_map(*G,-1);
       
-      typedef Heap<Node, ValueType, typename GR::template NodeMap<int>,
-      std::less<ValueType> > 
+      typedef Heap<Node, Value, typename GR::template NodeMap<int>,
+      std::less<Value> > 
       HeapType;
       
@@ -228 +228 @@
         
         Node v=heap.top(); 
-        ValueType oldvalue=heap[v];
+        Value oldvalue=heap[v];
         heap.pop();
         distance->set(v, oldvalue);
@@ -262 +262 @@
     ///\warning If node \c v in unreachable from the root the return value
     ///of this funcion is undefined.
-    ValueType dist(Node v) const { return (*distance)[v]; }
+    Value dist(Node v) const { return (*distance)[v]; }
 
     ///Returns the 'previous edge' of the shortest path tree.

src/work/klao/iter_map.h

@@ -26 +26 @@
   public:
 
-    typedef typename KeyIntMap::KeyType KeyType;
-    typedef Val ValueType;
+    typedef typename KeyIntMap::Key Key;
+    typedef Val Value;
 
-    typedef typename std::vector<KeyType>::const_iterator iterator;
+    typedef typename std::vector<Key>::const_iterator iterator;
 
   protected:
     KeyIntMap &base;
-    std::vector<KeyType> data;
+    std::vector<Key> data;
     size_t bounds[N];
     Val def_val;
@@ -56 +56 @@
       if(m != n) {
         size_t orig_a = a;
-        KeyType orig_key = data[a];
+        Key orig_key = data[a];
         while(m > n) {
           --m;
@@ -81 +81 @@
     }
 
-    Val operator[](const KeyType& k) const {
+    Val operator[](const Key& k) const {
       return find(base[k]);
     }
 
-    void set(const KeyType& k, Val n) {
+    void set(const Key& k, Val n) {
       // FIXME: range check?
       size_t a = base[k];
@@ -96 +96 @@
     }
 
-    void insert(const KeyType& k, Val n) {
+    void insert(const Key& k, Val n) {
       data.push_back(k);
       base.set(k, move(bounds[N-1]++, N-1, n));
@@ -103 +103 @@
     /// This func is not very usable, but necessary to implement 
     /// dynamic map behaviour.
-    void remove(const KeyType& k) {
+    void remove(const Key& k) {
       size_t a = base[k];
       if(a < bounds[N-1]) {
@@ -131 +131 @@
 
     /// For use as an iterator...
-    KeyType& first(KeyType &k, Val n) {
+    Key& first(Key &k, Val n) {
       size_t i = (n ? bounds[n-1] : 0);
       if( i < bounds[n] ) {
@@ -143 +143 @@
 
     /// For use as an iterator...
-    KeyType& next(KeyType &k) {
+    Key& next(Key &k) {
       size_t i = base[k];
       uint8_t n = find(i);

src/work/marci/augmenting_flow.h

@@ -113 +113 @@
       int* number_of_augmentations;
     public:
-      typedef Node KeyType;
-      typedef bool ValueType;
+      typedef Node Key;
+      typedef bool Value;
       TrickyReachedMap(IntMap& _map, int& _number_of_augmentations) : 
         map(&_map), number_of_augmentations(&_number_of_augmentations) { }

src/work/marci/bfs_mm.h

@@ -141 +141 @@
     /// Guess what?
     /// \deprecated 
-    typename ReachedMap::ValueType reached(const Node& n) const { 
+    typename ReachedMap::Value reached(const Node& n) const { 
       return (*reached_map)[n]; 
     }
@@ -243 +243 @@
     /// Guess what?
     /// \deprecated 
-    typename PredMap::ValueType pred(const Node& n) const { 
+    typename PredMap::Value pred(const Node& n) const { 
       return (*pred_map)[n]; 
     }
@@ -251 +251 @@
     /// Guess what?
     /// \deprecated 
-    typename PredNodeMap::ValueType predNode(const Node& n) const { 
+    typename PredNodeMap::Value predNode(const Node& n) const { 
       return (*pred_node_map)[n]; 
     }
@@ -259 +259 @@
     /// Guess what?
     /// \deprecated 
-    typename DistMap::ValueType dist(const Node& n) const { 
+    typename DistMap::Value dist(const Node& n) const { 
       return (*dist_map)[n]; 
     }

src/work/marci/bipartite_graph_wrapper.h

@@ -795 +795 @@
     template<typename NM> class NodeMapWrapper { 
     public:
-      typedef Node KeyType;
-      typedef typename NM::ValueType ValueType;
+      typedef Node Key;
+      typedef typename NM::Value Value;
     protected:
       NM* nm;
-      ValueType* s_value, t_value;
-    public:
-      NodeMapWrapper(NM& _nm, ValueType& _s_value, ValueType& _t_value) : 
+      Value* s_value, t_value;
+    public:
+      NodeMapWrapper(NM& _nm, Value& _s_value, Value& _t_value) : 
         nm(&_nm), s_value(&_s_value), t_value(&_t_value) { }
-      ValueType operator[](const Node& n) const { 
+      Value operator[](const Node& n) const { 
         switch (n.getSpec()) {
         case 0: 
@@ -814 +814 @@
         }
       }
-      void set(const Node& n, ValueType t) { 
+      void set(const Node& n, Value t) { 
         switch (n.getSpec()) {
         case 0: 
@@ -874 +874 @@
     class EdgeMapWrapper {
     public: 
-      typedef Edge KeyType;
-      typedef typename EM::ValueType ValueType;
+      typedef Edge Key;
+      typedef typename EM::Value Value;
     protected:
       EM* em;
@@ -881 +881 @@
     public:
       EdgeMapWrapper(EM& _em, NM& _nm) : em(&_em), nm(&_nm) { }
-      ValueType operator[](const Edge& e) const { 
+      Value operator[](const Edge& e) const { 
         switch (e.getSpec()) {
         case 0: 
@@ -892 +892 @@
         }
       }
-      void set(const Edge& e, ValueType t) { 
+      void set(const Edge& e, Value t) { 
         switch (e.getSpec()) {
         case 0: 

src/work/marci/experiment/list_graph.h

@@ -39 +39 @@
       std::vector<T> container;
     public:
-      typedef T ValueType;
-      typedef Node KeyType;
+      typedef T Value;
+      typedef Node Key;
       NodeMap(const ListGraph& _G) : G(_G), container(G.node_id) { }
       NodeMap(const ListGraph& _G, T a) : 
@@ -60 +60 @@
       std::vector<T> container;
     public:
-      typedef T ValueType;
-      typedef Edge KeyType;
+      typedef T Value;
+      typedef Edge Key;
       EdgeMap(const ListGraph& _G) : G(_G), container(G.edge_id) { }
       EdgeMap(const ListGraph& _G, T a) : 

src/work/marci/graph_concept.h

@@ -168 +168 @@
     {
     public:
-      typedef T ValueType;
-      typedef Node KeyType;
+      typedef T Value;
+      typedef Node Key;
 
       NodeMap(const GraphConcept& g) { }
@@ -206 +206 @@
     {
     public:
-      typedef T ValueType;
-      typedef Edge KeyType;
+      typedef T Value;
+      typedef Edge Key;
 
       EdgeMap(const GraphConcept& g) {}

src/work/marci/leda/leda_graph_wrapper.h

@@ -262 +262 @@
       leda_node_map<T> leda_stuff;
     public:
-      typedef T ValueType;
-      typedef Node KeyType;
+      typedef T Value;
+      typedef Node Key;
 
       NodeMap(const LedaGraphWrapper &G) : leda_stuff(*(G.l_graph)) {}
@@ -282 +282 @@
       leda_edge_map<T> leda_stuff;
     public:
-      typedef T ValueType;
-      typedef Edge KeyType;
+      typedef T Value;
+      typedef Edge Key;
 
       EdgeMap(const LedaGraphWrapper &G) : leda_stuff(*(G.l_graph)) {}
@@ -304 +304 @@
       leda_node_array<T>* leda_stuff;
     public:
-      typedef T ValueType;
-      typedef Node KeyType;
+      typedef T Value;
+      typedef Node Key;
 
       NodeMapWrapper(leda_node_array<T>& _leda_stuff) : 
@@ -326 +326 @@
       leda_edge_array<T>* leda_stuff;
     public:
-      typedef T ValueType;
-      typedef Edge KeyType;
+      typedef T Value;
+      typedef Edge Key;
 
       EdgeMapWrapper(leda_edge_array<T>& _leda_stuff) : 

src/work/peter/edgepathgraph.h

@@ -307 +307 @@
     {
     public:
-      typedef T ValueType;
-      typedef Node KeyType;
+      typedef T Value;
+      typedef Node Key;
 
       NodeMap(const EdgePathGraph &) {}
@@ -345 +345 @@
     {
     public:
-      typedef T ValueType;
-      typedef Edge KeyType;
+      typedef T Value;
+      typedef Edge Key;
 
       EdgeMap(const EdgePathGraph &) {}

src/work/peter/hierarchygraph.h

@@ -434 +434 @@
     {
     public:
-      typedef T ValueType;
-      typedef Node KeyType;
+      typedef T Value;
+      typedef Node Key;
 
       NodeMap (const HierarchyGraph &)
@@ -490 +490 @@
     {
     public:
-      typedef T ValueType;
-      typedef Edge KeyType;
+      typedef T Value;
+      typedef Edge Key;
 
       EdgeMap (const HierarchyGraph &)

src/work/sage_graph.h

@@ -39 +39 @@
       std::vector<T> container;
     public:
-      typedef T ValueType;
-      typedef Node KeyType;
+      typedef T Value;
+      typedef Node Key;
       NodeMap(const SageGraph& _G) : G(_G), container(G.node_id) { }
       NodeMap(const SageGraph& _G, T a) : 
@@ -60 +60 @@
       std::vector<T> container;
     public:
-      typedef T ValueType;
-      typedef Edge KeyType;
+      typedef T Value;
+      typedef Edge Key;
       EdgeMap(const SageGraph& _G) : G(_G), container(G.edge_id) { }
       EdgeMap(const SageGraph& _G, T a) :