Open
Graph Drawing
Framework

 v. 2023.09 (Elderberry)
 

Hypergraph.h
Go to the documentation of this file.
1 
34 #pragma once
35 
36 #include <ogdf/basic/GraphList.h>
37 #include <ogdf/basic/Observer.h>
39 #include <ogdf/basic/basic.h>
40 #include <ogdf/basic/memory.h>
41 
42 #include <iosfwd>
43 #include <string>
44 
45 namespace ogdf {
46 template<class E>
47 class List;
48 } // namespace ogdf
49 
51 #define forall_adj_elements(adj, ge) for ((adj) = (v)->firstAdj(); (adj); (adj) = (adj)->succ())
52 
54 #define forall_hypernodes(v, H) for ((v) = (H).firstHypernode(); (v); (v) = (v)->succ())
55 
57 #define forall_rev_hypernodes(v, H) for ((v) = (H).lastHypernode(); (v); (v) = (v)->pred())
58 
60 #define forall_hyperedges(e, H) for ((e) = (H).firstHyperedge(); (e); (e) = (e)->succ())
61 
63 #define forall_rev_hyperedges(e, H) for ((e) = (H).lastHyperedge(); (e); (e) = (e)->pred())
64 
65 namespace ogdf {
66 
67 class AdjHypergraphElement; // IWYU pragma: keep
68 class HyperedgeElement; // IWYU pragma: keep
69 class Hypergraph; // IWYU pragma: keep
70 class HypernodeElement; // IWYU pragma: keep
71 
74 
77 
80 
82 
87  friend class Hypergraph;
88  friend class GraphListBase;
90 
91 private:
93  GraphElement* m_element;
94 
96 
103 
105  int m_index;
106 
108  explicit AdjHypergraphElement(GraphElement* pElement)
109  : m_element(pElement), m_twin(nullptr), m_index(0) { }
110 
112  AdjHypergraphElement(GraphElement* pElement, int pIndex)
113  : m_element(pElement), m_twin(nullptr), m_index(pIndex) { }
114 
115 public:
117  int index() const { return m_index; }
118 
120 
125  GraphElement* element() const { return m_element; }
126 
128  adjHypergraphEntry twin() const { return m_twin; }
129 
131  adjHypergraphEntry succ() const { return static_cast<adjHypergraphEntry>(m_next); }
132 
134  adjHypergraphEntry pred() const { return static_cast<adjHypergraphEntry>(m_prev); }
135 
137  adjHypergraphEntry cyclicSucc() const;
138 
140  adjHypergraphEntry cyclicPred() const;
141 
143 
144  friend OGDF_EXPORT std::ostream& operator<<(std::ostream& os, ogdf::adjHypergraphEntry v);
145 };
146 
149  friend class Hypergraph;
150  friend class GraphListBase;
152 
153 private:
156 
158  int m_index;
159 
162 
165 
167 
170  explicit HyperedgeElement(int pIndex)
171  : m_index(pIndex), m_cardinality(0), m_hypergraph(nullptr) { }
172 
173 public:
175  int index() const { return m_index; }
176 
178  int cardinality() const { return m_cardinality; }
179 
181  Hypergraph* hypergraph() const { return m_hypergraph; }
182 
184  adjHypergraphEntry firstAdj() const { return m_adjHypernodes.head(); }
185 
187  adjHypergraphEntry lastAdj() const { return m_adjHypernodes.tail(); }
188 
191 
193  template<class NODELIST>
194  void allHypernodes(NODELIST& hypernodes) const {
195  hypernodes.clear();
196  for (adjHypergraphEntry adj = firstAdj(); adj; adj = adj->succ()) {
197  hypernodes.pushBack(reinterpret_cast<hypernode>(adj->element()));
198  }
199  }
200 
202  bool incident(hypernode v) const {
203  for (adjHypergraphEntry adj = firstAdj(); adj; adj = adj->succ()) {
204  if (reinterpret_cast<hypernode>(adj->element()) == v) {
205  return true;
206  }
207  }
208  return false;
209  }
210 
212  hyperedge succ() const { return static_cast<hyperedge>(m_next); }
213 
215  hyperedge pred() const { return static_cast<hyperedge>(m_prev); }
216 
218  bool operator==(const hyperedge e) const {
219  return e->index() == m_index && e->hypergraph() == m_hypergraph;
220  }
221 
222  friend OGDF_EXPORT std::ostream& operator<<(std::ostream& os, ogdf::hyperedge e);
223 
225 };
226 
229  friend class Hypergraph;
230  friend class GraphListBase;
232 
233 public:
235  enum class Type {
236  normal = 0x0000001,
237  dummy = 0x0000002,
238  OR = 0x0000003,
239  BUF = 0x0000004,
240  AND = 0x0000005,
241  NOR = 0x0000006,
242  NOT = 0x0000007,
243  XOR = 0x0000008,
244  DFF = 0x0000009,
245  NAND = 0x0000010,
246  INPUT = 0x0000011,
247  OUTPUT = 0x0000012
248  };
249 
250 private:
253 
255  int m_index;
256 
258  int m_degree;
259 
262 
265 
267  explicit HypernodeElement(int pIndex)
268  : m_index(pIndex), m_degree(0), m_type(Type::normal), m_hypergraph(nullptr) { }
269 
271  HypernodeElement(int pIndex, Type pType)
272  : m_index(pIndex), m_degree(0), m_type(pType), m_hypergraph(nullptr) { }
273 
274 public:
276  int index() const { return m_index; }
277 
279  int degree() const { return m_degree; }
280 
282  Hypergraph* hypergraph() const { return m_hypergraph; }
283 
285  Type type() const { return m_type; }
286 
288  void type(Type pType) { m_type = pType; }
289 
291  adjHypergraphEntry firstAdj() const { return m_adjHyperedges.head(); }
292 
294  adjHypergraphEntry lastAdj() const { return m_adjHyperedges.tail(); }
295 
297  template<class NODELIST>
298  void allHyperedges(NODELIST& hyperedges) const {
299  hyperedges.clear();
300  for (adjHypergraphEntry adj = firstAdj(); adj; adj = adj->succ()) {
301  hyperedges.pushBack(reinterpret_cast<hyperedge>(adj->element()));
302  }
303  }
304 
306  bool adjacent(hypernode v) const {
307  for (adjHypergraphEntry adj = firstAdj(); adj; adj = adj->succ()) {
308  if (reinterpret_cast<hyperedge>(adj->element())->incident(v)) {
309  return true;
310  }
311  }
312  return false;
313  }
314 
316  hypernode succ() const { return static_cast<hypernode>(m_next); }
317 
319  hypernode pred() const { return static_cast<hypernode>(m_prev); }
320 
322  bool operator==(const hypernode v) const {
323  return v->index() == m_index && v->hypergraph() == m_hypergraph;
324  }
325 
327 
328  friend OGDF_EXPORT std::ostream& operator<<(std::ostream& os, ogdf::hypernode v);
329 };
330 
332 template<typename Key>
334  : public RegistryBase<Key*, HypergraphRegistry<Key>, internal::GraphIterator<Key*>> {
337 
338 public:
340 
342  HypergraphRegistry(Hypergraph* graph, int* nextKeyIndex)
343  : m_pGraph(graph), m_nextKeyIndex(nextKeyIndex) { }
344 
345  static inline int keyToIndex(Key* key) { return key->index(); }
346 
347  bool isKeyAssociated(Key* key) const {
348  if (key == nullptr) {
349  return false;
350  }
351 #ifdef OGDF_DEBUG
352  if (key->hypergraph() == m_pGraph) {
353  OGDF_ASSERT(keyToIndex(key) < this->getArraySize());
354  return true;
355  } else {
356  return false;
357  }
358 #else
359  return true;
360 #endif
361  }
362 
363  int calculateArraySize(int add) const { return calculateTableSize(*m_nextKeyIndex + add); }
364 
365  int maxKeyIndex() const { return (*m_nextKeyIndex) - 1; }
366 
368  Hypergraph* graphOf() const { return m_pGraph; }
369 };
370 
372  const HypergraphRegistry<HypernodeElement>& self);
373 
375  const HypergraphRegistry<HypernodeElement>& self);
376 
378  const HypergraphRegistry<HyperedgeElement>& self);
379 
381  const HypergraphRegistry<HyperedgeElement>& self);
382 
384 template<typename Key, typename Value, bool WithDefault, typename Registry = HypergraphRegistry<Key>>
385 class HypergraphRegisteredArray : public RegisteredArray<Registry, Value, WithDefault, Hypergraph> {
387 
388 public:
389  using RA::RA;
390 
393  if (RA::registeredAt() == nullptr) {
394  return nullptr;
395  } else {
396  return RA::registeredAt()->graphOf();
397  }
398  }
399 };
400 
401 #define OGDF_DECL_REG_ARRAY_TYPE(v, c) HypergraphRegisteredArray<HypernodeElement, v, c>
404 #undef OGDF_DECL_REG_ARRAY_TYPE
405 
406 #define OGDF_DECL_REG_ARRAY_TYPE(v, c) HypergraphRegisteredArray<HyperedgeElement, v, c>
409 #undef OGDF_DECL_REG_ARRAY_TYPE
410 
411 class HypergraphObserver;
412 
413 class OGDF_EXPORT Hypergraph : public Observable<HypergraphObserver, Hypergraph> {
416 
419 
422 
425 
428 
431 
434 
437 
438 public:
440  Hypergraph();
441 
443  Hypergraph(const Hypergraph& H);
444 
446  ~Hypergraph();
447 
449  bool empty() const { return m_nHypernodes == 0; }
450 
452  const internal::GraphList<HypernodeElement>& hypernodes() const { return m_hypernodes; }
453 
455  const internal::GraphList<HyperedgeElement>& hyperedges() const { return m_hyperedges; }
456 
458  int numberOfHypernodes() const { return m_nHypernodes; }
459 
461  int numberOfHyperedges() const { return m_nHyperedges; }
462 
464  int maxHypernodeIndex() const { return m_hypernodeIdCount - 1; }
465 
467  int maxHyperedgeIndex() const { return m_hyperedgeIdCount - 1; }
468 
470  hypernode firstHypernode() const { return m_hypernodes.head(); }
471 
473  hypernode lastHypernode() const { return m_hypernodes.tail(); }
474 
476  hyperedge firstHyperedge() const { return m_hyperedges.head(); }
477 
479  hyperedge lastHyperEdge() const { return m_hyperedges.tail(); }
480 
482  hypernode newHypernode();
483 
485  hypernode newHypernode(int pIndex);
486 
488  hypernode newHypernode(HypernodeElement::Type pType);
489 
491  hypernode newHypernode(int pIndex, HypernodeElement::Type pType);
492 
494 
498  hyperedge newHyperedge(List<hypernode>& hypernodes);
499 
501 
506  hyperedge newHyperedge(int pIndex, List<hypernode>& hypernodes);
507 
509 
512  void delHypernode(hypernode v);
513 
515 
518  void delHyperedge(hyperedge e);
519 
521  void clear();
522 
524  hypernode randomHypernode() const;
525 
527  hyperedge randomHyperedge() const;
528 
530  template<class LIST>
531  void allHypernodes(LIST& hypernodeList) const {
532  hypernodeList.clear();
533  for (hypernode v = m_hypernodes.head(); v; v = v->succ()) {
534  hypernodeList.pushBack(v);
535  }
536  }
537 
539  template<class LIST>
540  void allHyperedges(LIST& hyperedgeList) const {
541  hyperedgeList.clear();
542  for (hyperedge e = m_hyperedges.head(); e; e = e->succ()) {
543  hyperedgeList.pushBack(e);
544  }
545  }
546 
548  void readBenchHypergraph(std::istream& is);
549 
551  void readBenchHypergraph(const char* filename);
552 
554  void readPlaHypergraph(std::istream& is);
555 
557  void loadPlaHypergraph(const char* fileName);
558 
560  bool consistency() const;
561 
563  HypergraphRegistry<HypernodeElement>& hypernodeRegistry() { return m_regHypernodeArrays; }
564 
567  return m_regHypernodeArrays;
568  }
569 
570  operator const HypergraphRegistry<HypernodeElement>&() const { return m_regHypernodeArrays; }
571 
573  HypergraphRegistry<HyperedgeElement>& hyperedgeRegistry() { return m_regHyperedgeArrays; }
574 
577  return m_regHyperedgeArrays;
578  }
579 
580  operator const HypergraphRegistry<HyperedgeElement>&() const { return m_regHyperedgeArrays; }
581 
582  Hypergraph& operator=(const Hypergraph& H);
583 
584  friend OGDF_EXPORT std::ostream& operator<<(std::ostream& os, ogdf::Hypergraph& H);
585 
586  friend OGDF_EXPORT std::istream& operator>>(std::istream& is, ogdf::Hypergraph& H);
587 
589 
590 private:
591  void initArrays();
592 
593  int nextEntry(char* buffer, int from, string stop);
594 
595  HypernodeElement::Type gateType(string gate);
596 };
597 
598 }
ogdf::Hypergraph::numberOfHyperedges
int numberOfHyperedges() const
Returns the number of hyperedges in the hypergraph.
Definition: Hypergraph.h:461
ogdf::Hypergraph::maxHyperedgeIndex
int maxHyperedgeIndex() const
Returns the largest used hyperedge index.
Definition: Hypergraph.h:467
ogdf::RegistryBase
Abstract base class for registries.
Definition: RegisteredArray.h:61
ogdf
The namespace for all OGDF objects.
Definition: multilevelmixer.cpp:39
ogdf::RegisteredArray
Dynamic arrays indexed with arbitrary keys.
Definition: RegisteredArray.h:869
OGDF_DECL_REG_ARRAY
#define OGDF_DECL_REG_ARRAY(NAME)
Definition: RegisteredArray.h:1021
ogdf::HypergraphRegistry::isKeyAssociated
bool isKeyAssociated(Key *key) const
Definition: Hypergraph.h:347
ogdf::AdjHypergraphElement::element
GraphElement * element() const
Returns the element associated with this adjacency entry.
Definition: Hypergraph.h:125
ogdf::internal::GraphList::tail
T * tail() const
Returns the last element in the list.
Definition: GraphList.h:327
ogdf::HypergraphRegistry::HypergraphRegistry
HypergraphRegistry(Hypergraph *graph, int *nextKeyIndex)
Constructor.
Definition: Hypergraph.h:342
ogdf::Hypergraph::allHyperedges
void allHyperedges(LIST &hyperedgeList) const
Returns a list with all hyperedges of the hypergraph.
Definition: Hypergraph.h:540
OGDF_ASSERT
#define OGDF_ASSERT(expr)
Assert condition expr. See doc/build.md for more information.
Definition: basic.h:66
ogdf::internal::GraphIteratorBase
Definition: graph_iterators.h:45
ogdf::Hypergraph::OGDF_MALLOC_NEW_DELETE
OGDF_MALLOC_NEW_DELETE
Definition: Hypergraph.h:588
ogdf::Hypergraph::allHypernodes
void allHypernodes(LIST &hypernodeList) const
Returns a list with all hypernodes of the hypergraph.
Definition: Hypergraph.h:531
ogdf::HyperedgeElement::cardinality
int cardinality() const
Returns the number of incident hypernodes.
Definition: Hypergraph.h:178
ogdf::AdjHypergraphElement::pred
adjHypergraphEntry pred() const
Returns the predecessor in the adjacency list.
Definition: Hypergraph.h:134
ogdf::RegisteredArray< HypergraphRegistry< ogdf::List< ogdf::EdgeElement > >, Value, WithDefault, Hypergraph >::RA
typename std::conditional< WithDefault, internal::RegisteredArrayWithDefault< HypergraphRegistry< ogdf::List< ogdf::EdgeElement > >, Value >, internal::RegisteredArrayWithoutDefault< HypergraphRegistry< ogdf::List< ogdf::EdgeElement > >, Value > >::type RA
Definition: RegisteredArray.h:874
ogdf::begin
HypergraphRegistry< HypernodeElement >::iterator begin(const HypergraphRegistry< HypernodeElement > &self)
ogdf::internal::GraphElement
The base class for objects used by (hyper)graphs.
Definition: GraphList.h:60
ogdf::Hypergraph::m_nHyperedges
int m_nHyperedges
The number of hyperedges in the hypergraph.
Definition: Hypergraph.h:430
ogdf::HypernodeElement::HypernodeElement
HypernodeElement(int pIndex, Type pType)
Constructor.
Definition: Hypergraph.h:271
Observer.h
Simple, safe base classes for C++ observables and observers.
ogdf::HypergraphRegistry::keyToIndex
static int keyToIndex(Key *key)
Definition: Hypergraph.h:345
ogdf::HypergraphRegisteredArray
RegisteredArray for nodes and edges of a hypergraph.
Definition: Hypergraph.h:385
ogdf::HyperedgeElement::OGDF_NEW_DELETE
OGDF_NEW_DELETE
Definition: Hypergraph.h:224
ogdf::HyperedgeElement::incident
bool incident(hypernode v) const
Returns true iff v is incident to the hyperedge.
Definition: Hypergraph.h:202
ogdf::Hypergraph::m_hyperedges
internal::GraphList< HyperedgeElement > m_hyperedges
The list of all hyperedges.
Definition: Hypergraph.h:424
ogdf::AdjHypergraphElement::m_index
int m_index
The (unique) index of the adjacency entry.
Definition: Hypergraph.h:105
ogdf::HyperedgeElement::HyperedgeElement
HyperedgeElement(int pIndex)
Constructs an hyperedge element between hypernodes.
Definition: Hypergraph.h:170
ogdf::Hypergraph::hypernodeRegistry
const HypergraphRegistry< HypernodeElement > & hypernodeRegistry() const
Returns a const reference to the registry of hypernode arrays associated with this hypergraph.
Definition: Hypergraph.h:566
ogdf::AdjHypergraphElement::m_element
GraphElement * m_element
The associated hyperedge or hypernode.
Definition: Hypergraph.h:93
ogdf::HyperedgeElement
Class for the representation of hyperedges.
Definition: Hypergraph.h:148
ogdf::Hypergraph::hyperedges
const internal::GraphList< HyperedgeElement > & hyperedges() const
Returns the list of all hyperedges.
Definition: Hypergraph.h:455
ogdf::HypernodeElement::firstAdj
adjHypergraphEntry firstAdj() const
Returns the first entry in the adjaceny list.
Definition: Hypergraph.h:291
ogdf::HypernodeElement::m_degree
int m_degree
The number of incident hyperedges.
Definition: Hypergraph.h:258
ogdf::AdjHypergraphElement::succ
adjHypergraphEntry succ() const
Returns the successor in the adjacency list.
Definition: Hypergraph.h:131
ogdf::Hypergraph::hyperedgeRegistry
const HypergraphRegistry< HyperedgeElement > & hyperedgeRegistry() const
Returns a const reference to the registry of hyperedge arrays associated with this hypergraph.
Definition: Hypergraph.h:576
ogdf::HypergraphRegistry::iterator
internal::GraphIterator< Key * > iterator
Definition: Hypergraph.h:339
ogdf::HypernodeElement::pred
hypernode pred() const
Returns the predecessor in the list of all hypernodes.
Definition: Hypergraph.h:319
ogdf::HypergraphRegistry::maxKeyIndex
int maxKeyIndex() const
Definition: Hypergraph.h:365
ogdf::HyperedgeElement::incidentHypernodes
internal::GraphList< AdjHypergraphElement > incidentHypernodes() const
Returns the incident hypernodes of the hyperedge.
Definition: Hypergraph.h:190
ogdf::HypergraphRegistry
Registry for nodes and edges of a hypergraph.
Definition: Hypergraph.h:333
ogdf::Observable
Base class for an observable object that can be tracked by multiple Observer objects.
Definition: Observer.h:127
ogdf::Hypergraph::lastHyperEdge
hyperedge lastHyperEdge() const
Returns the last hyperedge in the list of all hyperedges.
Definition: Hypergraph.h:479
ogdf::HypernodeElement::type
void type(Type pType)
Sets the type of hypernode.
Definition: Hypergraph.h:288
ogdf::HyperedgeElement::index
int index() const
Returns the index of a hyperedge.
Definition: Hypergraph.h:175
ogdf::Hypergraph::maxHypernodeIndex
int maxHypernodeIndex() const
Returns the largest used hypernode index.
Definition: Hypergraph.h:464
ogdf::Hypergraph::m_nHypernodes
int m_nHypernodes
The number of hypernodes in the hypergraph.
Definition: Hypergraph.h:427
ogdf::HypernodeElement::OGDF_NEW_DELETE
OGDF_NEW_DELETE
Definition: Hypergraph.h:326
ogdf::AdjHypergraphElement
Class for adjacency list elements.
Definition: Hypergraph.h:86
ogdf::HypernodeElement::Type
Type
The type of hypernodes.
Definition: Hypergraph.h:235
ogdf::HyperedgeElement::m_cardinality
int m_cardinality
The number of incidend hypernodes.
Definition: Hypergraph.h:161
ogdf::Hypergraph::m_regHypernodeArrays
HypergraphRegistry< HypernodeElement > m_regHypernodeArrays
The registered hypernode arrays.
Definition: Hypergraph.h:415
ogdf::Hypergraph::hypernodes
const internal::GraphList< HypernodeElement > & hypernodes() const
Returns the list of all hypernodes.
Definition: Hypergraph.h:452
ogdf::HypernodeElement::m_hypergraph
Hypergraph * m_hypergraph
The hypergraph containing the hypernode (if any).
Definition: Hypergraph.h:264
GraphList.h
Decralation of GraphElement and GraphList classes.
ogdf::Hypergraph::firstHyperedge
hyperedge firstHyperedge() const
Returns the first hyperedge in the list of all hyperedges.
Definition: Hypergraph.h:476
ogdf::HyperedgeArray
HypergraphRegisteredArray< HyperedgeElement, Value, WithDefault > HyperedgeArray
Array for labeling the hyperedges in a Hypergraph with an arbitrary Value.
Definition: Hypergraph.h:408
ogdf::Hypergraph::m_hyperedgeIdCount
int m_hyperedgeIdCount
The Index that will be assigned to the next created hyperedge.
Definition: Hypergraph.h:436
ogdf::calculateTableSize
int calculateTableSize(int actualCount)
The default growth function for registered arrays.
Definition: RegisteredArray.h:70
RegisteredArray.h
Declaration and implementation of RegisteredArray class.
ogdf::HypernodeElement::hypergraph
Hypergraph * hypergraph() const
Returns the hypergraph containing the hypernode.
Definition: Hypergraph.h:282
ogdf::AdjHypergraphElement::twin
adjHypergraphEntry twin() const
Returns the pointer to a twin adjacency list.
Definition: Hypergraph.h:128
ogdf::AdjHypergraphElement::AdjHypergraphElement
AdjHypergraphElement(GraphElement *pElement, int pIndex)
Constructs an adjacency entry for a given hyper{node,edge} and index.
Definition: Hypergraph.h:112
ogdf::HypernodeElement::m_adjHyperedges
internal::GraphList< AdjHypergraphElement > m_adjHyperedges
The adjacency list of the hypernode.
Definition: Hypergraph.h:252
ogdf::Hypergraph::m_hypernodes
internal::GraphList< HypernodeElement > m_hypernodes
The list of all hypernodes.
Definition: Hypergraph.h:421
ogdf::HyperedgeElement::hypergraph
Hypergraph * hypergraph() const
Returns the hypergraph containing the hyperedge.
Definition: Hypergraph.h:181
ogdf::HyperedgeElement::pred
hyperedge pred() const
Returns the predecessor in the list of all hyperedges.
Definition: Hypergraph.h:215
ogdf::operator<<
std::ostream & operator<<(std::ostream &os, const ogdf::Array< E, INDEX > &a)
Prints array a to output stream os.
Definition: Array.h:983
ogdf::Hypergraph::empty
bool empty() const
Returns true iff the hypergraph is empty (ie. contains no hypernodes).
Definition: Hypergraph.h:449
ogdf::Hypergraph::numberOfHypernodes
int numberOfHypernodes() const
Returns the number of hypernodes in the hypergraph.
Definition: Hypergraph.h:458
ogdf::HypernodeElement::m_index
int m_index
The (unique) index of the hypernode.
Definition: Hypergraph.h:255
ogdf::HypergraphRegistry::m_pGraph
Hypergraph * m_pGraph
Definition: Hypergraph.h:335
ogdf::HypernodeElement::index
int index() const
Returns the (unique) hypernode index.
Definition: Hypergraph.h:276
ogdf::List
Doubly linked lists (maintaining the length of the list).
Definition: DfsMakeBiconnected.h:40
ogdf::internal::GraphList
Lists of graph objects (like nodes, edges, etc.).
Definition: GraphList.h:301
ogdf::HyperedgeElement::m_hypergraph
Hypergraph * m_hypergraph
The hypergraph containing the hyperedge (if any).
Definition: Hypergraph.h:164
ogdf::HyperedgeElement::firstAdj
adjHypergraphEntry firstAdj() const
Returns the first entry in the adjaceny list.
Definition: Hypergraph.h:184
ogdf::AdjHypergraphElement::m_twin
adjHypergraphEntry m_twin
The corresponding adjacency entry.
Definition: Hypergraph.h:102
ogdf::HypernodeElement::adjacent
bool adjacent(hypernode v) const
Returns true iff v is adjacent to the hypernode.
Definition: Hypergraph.h:306
ogdf::HyperedgeElement::succ
hyperedge succ() const
Returns the successor in the list of all hyperedges.
Definition: Hypergraph.h:212
ogdf::HypergraphRegistry::calculateArraySize
int calculateArraySize(int add) const
Definition: Hypergraph.h:363
ogdf::HypergraphRegistry::graphOf
Hypergraph * graphOf() const
Returns a pointer to the associated hypergraph.
Definition: Hypergraph.h:368
ogdf::HypernodeElement::allHyperedges
void allHyperedges(NODELIST &hyperedges) const
Returns a list with all incident hyperedges of the hypernode.
Definition: Hypergraph.h:298
ogdf::AdjHypergraphElement::index
int index() const
Returns the index of this adjacency element.
Definition: Hypergraph.h:117
ogdf::HyperedgeElement::operator==
bool operator==(const hyperedge e) const
Equality operator.
Definition: Hypergraph.h:218
ogdf::Hypergraph::firstHypernode
hypernode firstHypernode() const
Returns the first hypernode in the list of all hypernodes.
Definition: Hypergraph.h:470
ogdf::AdjHypergraphElement::OGDF_NEW_DELETE
OGDF_NEW_DELETE
Definition: Hypergraph.h:142
ogdf::Hypergraph::lastHypernode
hypernode lastHypernode() const
Returns the last hypernode in the list of all hypernodes.
Definition: Hypergraph.h:473
ogdf::HyperedgeElement::m_adjHypernodes
internal::GraphList< AdjHypergraphElement > m_adjHypernodes
The adjacency list of the hyperedge.
Definition: Hypergraph.h:155
ogdf::internal::GraphList::head
T * head() const
Returns the first element in the list.
Definition: GraphList.h:324
ogdf::Hypergraph::hyperedgeRegistry
HypergraphRegistry< HyperedgeElement > & hyperedgeRegistry()
Returns a reference to the registry of hyperedge arrays associated with this hypergraph.
Definition: Hypergraph.h:573
ogdf::HypergraphRegistry::m_nextKeyIndex
int * m_nextKeyIndex
Definition: Hypergraph.h:336
ogdf::HypernodeElement::operator==
bool operator==(const hypernode v) const
Equality operator.
Definition: Hypergraph.h:322
basic.h
Basic declarations, included by all source files.
ogdf::HypernodeElement::degree
int degree() const
Returns the hypernode degree.
Definition: Hypergraph.h:279
ogdf::end
HypergraphRegistry< HypernodeElement >::iterator end(const HypergraphRegistry< HypernodeElement > &self)
OGDF_EXPORT
#define OGDF_EXPORT
Specifies that a function or class is exported by the OGDF dynamic library (shared object / DLL),...
Definition: config.h:117
ogdf::HypergraphRegisteredArray::hypergraphOf
Hypergraph * hypergraphOf() const
Returns a pointer to the associated hypergraph.
Definition: Hypergraph.h:392
ogdf::HypernodeElement::succ
hypernode succ() const
Returns the successor in the list of all hypernodes.
Definition: Hypergraph.h:316
ogdf::HyperedgeElement::allHypernodes
void allHypernodes(NODELIST &hypernodes) const
Returns a list with all incident hypernodes of the hyperedge.
Definition: Hypergraph.h:194
ogdf::HypernodeElement::lastAdj
adjHypergraphEntry lastAdj() const
Returns the last entry in the adjacency list.
Definition: Hypergraph.h:294
ogdf::HypernodeElement::HypernodeElement
HypernodeElement(int pIndex)
Constructor.
Definition: Hypergraph.h:267
ogdf::Hypergraph::hypernodeRegistry
HypergraphRegistry< HypernodeElement > & hypernodeRegistry()
Returns a reference to the registry of hypernode arrays associated with this hypergraph.
Definition: Hypergraph.h:563
ogdf::operator>>
std::istream & operator>>(std::istream &is, TokenIgnorer token)
ogdf::HypernodeElement::type
Type type() const
Returns the type of hypernode.
Definition: Hypergraph.h:285
ogdf::HyperedgeElement::lastAdj
adjHypergraphEntry lastAdj() const
Returns the last entry in the adjacency list.
Definition: Hypergraph.h:187
ogdf::RegistryBase< Key *, HypergraphRegistry< Key >, internal::GraphIterator< Key * > >::getArraySize
int getArraySize() const
Returns the current size of all registered arrays.
Definition: RegisteredArray.h:294
ogdf::HypernodeElement::m_type
Type m_type
The type of the hypernode.
Definition: Hypergraph.h:261
ogdf::Hypergraph
Definition: Hypergraph.h:413
memory.h
Declaration of memory manager for allocating small pieces of memory.
ogdf::AdjHypergraphElement::AdjHypergraphElement
AdjHypergraphElement(GraphElement *pElement)
Constructs an adjacency element for a given hyper{node,edge}.
Definition: Hypergraph.h:108
ogdf::HyperedgeElement::m_index
int m_index
The (unique) index of the hyperedge.
Definition: Hypergraph.h:158
ogdf::HypernodeElement
Class for the representation of hypernodes.
Definition: Hypergraph.h:228
ogdf::Hypergraph::m_regHyperedgeArrays
HypergraphRegistry< HyperedgeElement > m_regHyperedgeArrays
The registered hyperedge arrays.
Definition: Hypergraph.h:418
ogdf::HypernodeArray
HypergraphRegisteredArray< HypernodeElement, Value, WithDefault > HypernodeArray
Array for labeling the hypernodes in a Hypergraph with an arbitrary Value.
Definition: Hypergraph.h:403
ogdf::Hypergraph::m_hypernodeIdCount
int m_hypernodeIdCount
The Index that will be assigned to the next created hypernode.
Definition: Hypergraph.h:433