Category

Development Platform
Home > SourceCode/Document > Mathimatics-Numerical algorithms > View Code
graph_map.h
Package: leda.tar.gz　[view]
Upload User: gzelex
Upload Date: 2007-01-07
Package Size: 707k
Code Size: 3k
Category:

Mathimatics-Numerical algorithms

Development Platform:

MultiPlatform

graph_map.h：Code Content
  1. /*******************************************************************************
  2. +
  3. +  LEDA-R  3.2.3
  4. +
  5. +  graph_map.h
  6. +
  7. +  Copyright (c) 1995  by  Max-Planck-Institut fuer Informatik
  8. +  Im Stadtwald, 66123 Saarbruecken, Germany     
  9. +  All rights reserved.
  10. + 
  11. *******************************************************************************/
  14. #ifndef LEDA_GRAPH_MAP_H
  15. #define LEDA_GRAPH_MAP_H
  17. #include <LEDA/basic.h>
  20. //------------------------------------------------------------------------------
  21. // graph_map:  base type for node/edge arrays and node/edge maps
  22. //------------------------------------------------------------------------------
  25. class graph_map {
  27. friend class graph;
  29. virtual void init_entry(GenPtr&)  const {}
  30. virtual void clear_entry(GenPtr&) const {}
  31. virtual void copy_entry(GenPtr&)  const {}
  33. GenPtr* table;
  34. int table_size;
  35. const graph*  g;
  37. int  next_power(int) const;
  38. void resize_table(int sz);
  41. protected:
  43. void init_table(GenPtr*, GenPtr*);
  44. void init_table() { init_table(table,table+table_size); }
  45. void clear_table();
  47. public:
  48. virtual int  cmp_entry(GenPtr,GenPtr) const  { return 0; }
  50. int     size() const { return table_size; }
  51. GenPtr& access(int i)     { return table[i]; }
  52. GenPtr  read(int i) const { return table[i]; }
  55. GenPtr& array_access(node v)
  56. { 
  57. #if ! defined(LEDA_CHECKING_OFF)
  58. if (index(v) >= table_size || graph_of(v) != g) 
  59.    error_handler(999,"node_array: illegal node");
  60. #endif
  61.   return table[index(v)]; 
  62.  }
  64. GenPtr& array_access(edge e)
  65. { 
  66. #if ! defined(LEDA_CHECKING_OFF)
  67. if (index(e) >= table_size || graph_of(e) != g) 
  68.    error_handler(999,"edge_array: illegal edge");
  69. #endif
  70.   return table[index(e)]; 
  71.  }
  73. GenPtr array_read(node v) const
  74. { 
  75. #if ! defined(LEDA_CHECKING_OFF)
  76. if (index(v) >= table_size || graph_of(v) != g) 
  77.    error_handler(999,"node_array: illegal node");
  78. #endif
  79.   return table[index(v)]; 
  80.  }
  82. GenPtr array_read(edge e) const
  83. { 
  84. #if ! defined(LEDA_CHECKING_OFF)
  85. if (index(e) >= table_size || graph_of(e) != g) 
  86.    error_handler(999,"edge_array: illegal edge");
  87. #endif
  88.   return table[index(e)]; 
  89.  }
  92. GenPtr& map_access(node v)
  93. { 
  94. #if ! defined(LEDA_CHECKING_OFF)
  95. if (graph_of(v) != g) error_handler(999,"node_map: illegal node");
  96. #endif
  97.   int i = index(v);
  98.   if (i >= table_size) resize_table(next_power(i+1));
  99.   return table[i]; 
  100. }
  102. GenPtr& map_access(edge e)
  103. {
  104. #if ! defined(LEDA_CHECKING_OFF)
  105. if (graph_of(e) != g) error_handler(999,"edge_map: illegal edge");
  106. #endif
  107.   int i = index(e);
  108.   if (i >= table_size) resize_table(next_power(i+1));
  109.   return table[i]; 
  110. }
  113. GenPtr map_read(node v) const
  114. { 
  115. #if ! defined(LEDA_CHECKING_OFF)
  116. if (graph_of(v) != g) error_handler(999,"node_map: illegal node");
  117. #endif
  118.   int i = index(v);
  119.   if (i < table_size) 
  120.      return table[i]; 
  121.   else
  122.     { GenPtr x; 
  123.       init_entry(x); 
  124.       return x;
  125.      }
  126. }
  128. GenPtr map_read(edge e) const
  129. {
  130. #if ! defined(LEDA_CHECKING_OFF)
  131. if (graph_of(e) != g) error_handler(999,"edge_map: illegal edge");
  132. #endif
  133.   int i = index(e);
  134.   if (i < table_size) 
  135.      return table[i]; 
  136.   else
  137.     { GenPtr x; 
  138.       init_entry(x); 
  139.       return x;
  140.      }
  141. }
  144. void init(const graph* G, int sz);
  148. graph_map(const graph* G, int sz);
  149. graph_map(const graph_map&);
  151. graph_map& operator=(const graph_map&);
  153. virtual ~graph_map() { delete[] table; } 
  156. };
  160. #endif