Belle II Software  release-05-02-19
Classes | Functions
DirectedNodeNetworkTests Namespace Reference

These tests cover the functionality of the classes: DirectedNode, DirectedNodeNetwork. More...

Classes

class  DirectedNodeNetworkTest
 Test class demonstrating the behavior of TCNetworkContainer. More...
 

Functions

VXD::SensorInfoBase provideSensorInfo (VxdID aVxdID, double globalX=0., double globalY=0., double globalZ=-0.)
 helper function: create a sensorInfo to be used
 
PXDCluster providePXDCluster (double u, double v, VxdID aVxdID, double uError=0.1, double vError=0.1)
 helper function: returns a pxdCluster with given sensorID and local coordinates
 
 TEST_F (DirectedNodeNetworkTest, MockupSanityCheck)
 basic sanity checks: checks mockup for working properly
 
 TEST_F (DirectedNodeNetworkTest, CreateNetworkIntAndThoroughlyTestIntendedBehavior)
 testing basic functionality of the DirectedNodeNetwork when filled with a basic type - int. More...
 

Detailed Description

These tests cover the functionality of the classes: DirectedNode, DirectedNodeNetwork.

Function Documentation

◆ TEST_F()

DirectedNodeNetworkTests::TEST_F ( DirectedNodeNetworkTest  ,
CreateNetworkIntAndThoroughlyTestIntendedBehavior   
)

testing basic functionality of the DirectedNodeNetwork when filled with a basic type - int.

This test is a bit overcrowded and therefore not an ideal test for learning the intended usage of the network. This test tries to cover all cases relevant. The correct usage of the network is better described in the test 'CreateRealisticNetwork'.

small lambda function for checking existence of a given node in a given vector

small lambda function for printing all the nodes for debugging

Definition at line 163 of file directedNodeNetwork.cc.

164  {
165  // here some tool-definitions first:
166 
168  auto nodeWasFound = [&](std::vector<DirectedNode<int, VoidMetaInfo>*>& nodes, DirectedNode<int, VoidMetaInfo>* node) -> bool {
169  for (DirectedNode<int, VoidMetaInfo>* otherNode : nodes)
170  {
171  if (node->getEntry() == otherNode->getEntry()) { return true; }
172  }
173  return false;
174  };
175 
177  auto printNodeEntries = [&](std::vector<DirectedNode<int, VoidMetaInfo>*>& nodes) -> std::string {
178  std::string output = "Nodes got the following entries: ";
179  for (DirectedNode<int, VoidMetaInfo>* node : nodes)
180  {
181  output += std::to_string(node->getEntry()) + " ";
182  }
183  return output + "\n";
184  };
185 
186  // just some input for testing:
187  std::array<int, 5> intArray = { { 2, 5, 3, 4, 99} };
188  std::array<int, 5> intArray2 = { { 144, 121, 33, 35, 31415} }; // these entries are independent of the first intArray-entries
189  std::array<int, 5> intArray3 = { { 1440, 1210, 3, 33, 3141529} }; // entry 2 crosses intArray, entry 3 crosses intArray2
190  std::deque<int> onTheFlyCreatedInts; // the user has to take care about the lifetime of the objects to be linked in the network!
191  EXPECT_EQ(5, intArray.size());
192 
193  DirectedNodeNetwork<int, VoidMetaInfo> intNetwork;
194  EXPECT_EQ(0, intNetwork.size());
195  B2INFO("tests case when both nodes are new and when inner one is new, but outer one not");
196  for (unsigned int index = 1 ; index < 5; index++) {
197  B2INFO("intArray-index " << index << " of array has entry: " << intArray.at(index));
198 
199  intNetwork.addNode(intArray.at(index - 1), intArray.at(index - 1));
200  intNetwork.addNode(intArray.at(index), intArray.at(index));
201  // correct order: outerEntry, innerEntry:
202  intNetwork.linkNodes(intArray.at(index - 1), intArray.at(index));
203 
204  // innerEnd has been updated:
205  EXPECT_EQ(intArray.at(index), intNetwork.getInnerEnds().at(0)->getEntry());
206 
207  // entries are now in network:
208  EXPECT_EQ(intArray.at(index - 1), *intNetwork.getNode(intArray.at(index - 1)));
209  EXPECT_EQ(intArray.at(index), *intNetwork.getNode(intArray.at(index)));
210 
211  // get all nodes of outer node, expected: 1 inner and no outerNodes:
212  auto& innerNodes = intNetwork.getNode(intArray.at(index - 1))->getInnerNodes();
213  auto& outerNodes = intNetwork.getNode(intArray.at(index))->getOuterNodes();
214  EXPECT_EQ(1, innerNodes.size());
215  EXPECT_EQ(1, outerNodes.size());
216 
217  // array[index] is now linked as inner node of array[index-1]:
218  EXPECT_EQ(*(innerNodes.at(0)), *(intNetwork.getNode(intArray.at(index))));
219  }
220  EXPECT_EQ(0, intNetwork.getNode(intArray.at(0))->getOuterNodes().size()); // the outermost node has no outerNodes
221  EXPECT_EQ(0, intNetwork.getNode(intArray.at(4))->getInnerNodes().size()); // the innermost node has no innerNodes
222 
223  // some extra sanity checks, are inner- and outerEnds as expected?
224  EXPECT_EQ(intArray.size(), intNetwork.size());
225  std::vector<DirectedNode<int, VoidMetaInfo>*> outerEnds_before = intNetwork.getOuterEnds();
226  std::vector<DirectedNode<int, VoidMetaInfo>*> innerEnds_before = intNetwork.getInnerEnds();
227  EXPECT_EQ(1, outerEnds_before.size());
228  EXPECT_EQ(1, innerEnds_before.size());
229 
230  DirectedNode<int, VoidMetaInfo>* outermostNode = outerEnds_before.at(0);
231  EXPECT_EQ(intArray.at(0), outermostNode->getEntry());
232  EXPECT_EQ(outermostNode->getEntry(), *outermostNode);
233  EXPECT_EQ(intArray.at(1), *(outermostNode->getInnerNodes().at(0)));
234 
235  DirectedNode<int, VoidMetaInfo>* innermostNode = innerEnds_before.at(0);
236  EXPECT_EQ(intArray.at(4), innermostNode->getEntry());
237  EXPECT_EQ(innermostNode->getEntry(), *innermostNode);
238  EXPECT_EQ(intArray.at(3), *(innermostNode->getOuterNodes().at(0)));
239 
240 
241  {
242  B2INFO("building another path, which is independent of the first one:");
243  for (unsigned int index = 1 ; index < 5; index++) {
244  B2INFO("intArray2-index " << index << " of array has entry: " << intArray2.at(index));
245 
246  intNetwork.addNode(intArray2.at(index - 1), intArray2.at(index - 1));
247  intNetwork.addNode(intArray2.at(index), intArray2.at(index));
248  // correct order: outerEntry, innerEntry:
249  intNetwork.linkNodes(intArray2.at(index - 1), intArray2.at(index));
250 
251  // entries are now in network:
252  EXPECT_EQ(intArray2.at(index - 1), *intNetwork.getNode(intArray2.at(index - 1)));
253  EXPECT_EQ(intArray2.at(index), *intNetwork.getNode(intArray2.at(index)));
254 
255  // get all nodes of outer node, expected: 1 inner and no outerNodes:
256  auto& innerNodes = intNetwork.getNode(intArray2.at(index - 1))->getInnerNodes();
257  auto& outerNodes = intNetwork.getNode(intArray2.at(index))->getOuterNodes();
258  EXPECT_EQ(1, innerNodes.size());
259  EXPECT_EQ(1, outerNodes.size());
260 
261  // array[index] is now linked as inner node of array[index-1]:
262  EXPECT_TRUE(nodeWasFound(innerNodes, intNetwork.getNode(intArray2.at(index))));
263  EXPECT_EQ(*(innerNodes.at(0)), *(intNetwork.getNode(intArray2.at(index))));
264  }
265  EXPECT_EQ(0, intNetwork.getNode(intArray2.at(0))->getOuterNodes().size()); // the outermost node has no outerNodes
266  EXPECT_EQ(0, intNetwork.getNode(intArray2.at(4))->getInnerNodes().size()); // the innermost node has no innerNodes
267 
268  // some extra sanity checks, are inner- and outerEnds as expected?
269  EXPECT_EQ(10, intNetwork.size());
270  std::vector<DirectedNode<int, VoidMetaInfo>*> outerEnds = intNetwork.getOuterEnds();
271  std::vector<DirectedNode<int, VoidMetaInfo>*> innerEnds = intNetwork.getInnerEnds();
272  EXPECT_EQ(2, outerEnds.size());
273  EXPECT_EQ(2, innerEnds.size());
274  }
275 
276 
277  B2INFO("building another path into the network which crosses the other paths:"); {
278  B2INFO("tests cases: both new, outer new but inner not, inner new but outer not, both already existing:");
279  for (unsigned int index = 1 ; index < 5; index++) {
280  B2INFO("intArray3-indices " << index - 1 << "/" << index <<
281  " of array have entries: " << intArray3.at(index - 1) << "/" << intArray3.at(index) << "\n"
282  );
283 
284  intNetwork.addNode(intArray3.at(index - 1), intArray3.at(index - 1));
285  intNetwork.addNode(intArray3.at(index), intArray3.at(index));
286  // correct order: outerEntry, innerEntry:
287  intNetwork.linkNodes(intArray3.at(index - 1), intArray3.at(index));
288 
289  // entries are now in network:
290  EXPECT_EQ(intArray3.at(index - 1), *intNetwork.getNode(intArray3.at(index - 1)));
291  EXPECT_EQ(intArray3.at(index), *intNetwork.getNode(intArray3.at(index)));
292 
293  // array[index] is now linked as an inner node of array[index-1]:
294  EXPECT_TRUE(nodeWasFound(intNetwork.getNode(intArray3.at(index - 1))->getInnerNodes(),
295  intNetwork.getNode(intArray3.at(index))));
296 
297 
298  if (index > 1) continue; // the following tests do not work for paths crossing each other, therefore tests would fail
299  // innerEnd has been updated:
300  std::vector<DirectedNode<int, VoidMetaInfo>*> innerEnds = intNetwork.getInnerEnds();
301  EXPECT_TRUE(nodeWasFound(innerEnds, intNetwork.getNode(intArray3.at(index))));
302  B2INFO("innerEnds after indices " << index - 1 << "/" << index << " are: " << printNodeEntries(innerEnds));
303 
304  // get all nodes of outer node, expected: 1 inner and no outerNodes:
305  auto& innerNodes = intNetwork.getNode(intArray3.at(index - 1))->getInnerNodes();
306  auto& outerNodes = intNetwork.getNode(intArray3.at(index))->getOuterNodes();
307  EXPECT_EQ(1, innerNodes.size());
308  EXPECT_EQ(1, outerNodes.size());
309  }
310  EXPECT_EQ(0, intNetwork.getNode(intArray3.at(0))->getOuterNodes().size()); // the outermost node has no outerNodes
311  EXPECT_EQ(0, intNetwork.getNode(intArray3.at(4))->getInnerNodes().size()); // the innermost node has no innerNodes
312 
313  // some extra sanity checks, are inner- and outerEnds as expected?
314  EXPECT_EQ(13, intNetwork.size());
315  //B2INFO(" theWholeNetwork: \n" << printNodeEntries(intNetwork.getNodes()));
316  std::vector<DirectedNode<int, VoidMetaInfo>*> outerEnds = intNetwork.getOuterEnds();
317  std::vector<DirectedNode<int, VoidMetaInfo>*> innerEnds = intNetwork.getInnerEnds();
318  EXPECT_EQ(3, outerEnds.size());
319  EXPECT_EQ(3, innerEnds.size());
320  B2INFO("outerEnds are: \n" << printNodeEntries(outerEnds));
321  B2INFO("innerEnds are: \n" << printNodeEntries(innerEnds));
322  }
323 
324  B2INFO("case: when outer node is new, but inner one not: "); {
325  B2INFO(" case: inner one was outer end before: ");
326  auto* oldOuterMostNode = intNetwork.getOuterEnds().at(0);
327  int oldOuterInt = oldOuterMostNode->getEntry();
328  onTheFlyCreatedInts.push_back(42);
329  int& newInnerInt = onTheFlyCreatedInts.back();
330  EXPECT_TRUE(NULL == intNetwork.getNode(newInnerInt));
331  intNetwork.addNode(newInnerInt, newInnerInt);
332  intNetwork.linkNodes(newInnerInt, oldOuterInt);
333  EXPECT_FALSE(NULL == intNetwork.getNode(newInnerInt));
334  EXPECT_EQ(14, intNetwork.size());
335  EXPECT_EQ(3, intNetwork.getInnerEnds().size());
336  std::vector<DirectedNode<int, VoidMetaInfo>*> newOuterEnds = intNetwork.getOuterEnds();
337  EXPECT_EQ(3, newOuterEnds.size()); // did not change, new outermost node replaced old one
338  EXPECT_EQ(1, oldOuterMostNode->getOuterNodes().size());
339  EXPECT_EQ(newInnerInt, *(oldOuterMostNode->getOuterNodes().at(0)));
340  }
341 
342  {
343  B2INFO(" case: inner one was no outer end before: ");
344  onTheFlyCreatedInts.push_back(23);
345  int& newOuterInt = onTheFlyCreatedInts.back();
346  int& existingInt = intArray.at(1); // neither an outer nor an inner end before.
347  std::vector<DirectedNode<int, VoidMetaInfo>*> oldOuterEnds = intNetwork.getOuterEnds();
348  std::vector<DirectedNode<int, VoidMetaInfo>*> oldInnerEnds = intNetwork.getInnerEnds();
349 
350  EXPECT_EQ(3, oldOuterEnds.size());
351  EXPECT_TRUE(NULL == intNetwork.getNode(newOuterInt));
352  unsigned int sizeB4 = intNetwork.size();
353  intNetwork.addNode(newOuterInt, newOuterInt);
354  intNetwork.linkNodes(newOuterInt, existingInt);
355  EXPECT_FALSE(NULL == intNetwork.getNode(newOuterInt));
356  EXPECT_EQ(sizeB4 + 1, intNetwork.size());
357  EXPECT_EQ(3, intNetwork.getInnerEnds().size());
358  DirectedNode<int, VoidMetaInfo>* existingNode = intNetwork.getNode(existingInt);
359  EXPECT_EQ(1, existingNode->getInnerNodes().size());
360  EXPECT_EQ(2, existingNode->getOuterNodes().size());
361  std::vector<DirectedNode<int, VoidMetaInfo>*> newOuterEnds = intNetwork.getOuterEnds();
362  EXPECT_EQ(4, newOuterEnds.size()); // did change, new outermost node co-existing with old outermost one
363  EXPECT_EQ(2, existingNode->getOuterNodes().size());
364 
365  }
366 
367 
368  {
369  B2INFO("case: when both were there, but not linked yet: ");
370  unsigned int sizeB4 = intNetwork.size();
371  intNetwork.linkNodes(intArray.at(0), intArray.at(2));
372  EXPECT_EQ(sizeB4, intNetwork.size()); // size of network does not change
373  EXPECT_EQ(3, intNetwork.getInnerEnds().size()); // this can not change here
374  EXPECT_EQ(4, intNetwork.getOuterEnds().size());
375  std::vector<DirectedNode<int, VoidMetaInfo>*> innerEnds = intNetwork.getNode(intArray.at(0))->getInnerNodes();
376  EXPECT_EQ(2, innerEnds.size());
377  EXPECT_TRUE(nodeWasFound(innerEnds, intNetwork.getNode(intArray.at(1))));
378  EXPECT_TRUE(nodeWasFound(innerEnds, intNetwork.getNode(intArray.at(2))));
379  EXPECT_TRUE(nodeWasFound(innerEnds, innerEnds.at(1)));
380 
381 
382  B2INFO("case: when outer both were there and already linked: ");
383  EXPECT_FALSE(intNetwork.linkNodes(intArray.at(0), intArray.at(2)));
384  // nothing was added, everything the same as last case:
385  EXPECT_EQ(sizeB4, intNetwork.size());
386  EXPECT_EQ(3, intNetwork.getInnerEnds().size());
387  EXPECT_EQ(4, intNetwork.getOuterEnds().size());
388  std::vector<DirectedNode<int, VoidMetaInfo>*> moreInnerEnds = intNetwork.getNode(intArray.at(0))->getInnerNodes();
389  EXPECT_EQ(innerEnds.size(), moreInnerEnds.size());
390  EXPECT_TRUE(nodeWasFound(innerEnds, moreInnerEnds.at(0)));
391  EXPECT_TRUE(nodeWasFound(innerEnds, moreInnerEnds.at(1)));
392  }
393 
394 
395  B2INFO("testing members for filling, when (at least) one entry was already there:"); {
396  B2INFO("case: addInnerToLastOuterNode: both were there, but not linked yet: ");
397  unsigned int networkSizeB4 = intNetwork.size();
398  unsigned int nInnerEndsB4 = intNetwork.getInnerEnds().size();
399  intNetwork.addInnerToLastOuterNode(intArray.at(3));
400  EXPECT_EQ(networkSizeB4, intNetwork.size());
401  EXPECT_EQ(nInnerEndsB4, intNetwork.getInnerEnds().size());
402  std::vector<DirectedNode<int, VoidMetaInfo>*> innerEnds = intNetwork.getNode(intArray.at(0))->getInnerNodes();
403  EXPECT_EQ(3, innerEnds.size());
404 
405  EXPECT_TRUE(nodeWasFound(innerEnds, intNetwork.getNode(intArray.at(1))));
406  EXPECT_TRUE(nodeWasFound(innerEnds, intNetwork.getNode(intArray.at(2))));
407  EXPECT_TRUE(nodeWasFound(innerEnds, intNetwork.getNode(intArray.at(3))));
408  }
409 
410 
411  {
412  B2INFO("case: addInnerToLastOuterNode: both were there, but already linked (same results as before, but with an error for unintended behavior):");
413  unsigned int networkSizeB4 = intNetwork.size();
414  unsigned int nInnerEndsB4 = intNetwork.getInnerEnds().size();
415  intNetwork.addInnerToLastOuterNode(intArray.at(3));
416  EXPECT_EQ(networkSizeB4, intNetwork.size());
417  EXPECT_EQ(nInnerEndsB4, intNetwork.getInnerEnds().size());
418  std::vector<DirectedNode<int, VoidMetaInfo>*> innerEnds = intNetwork.getNode(intArray.at(0))->getInnerNodes();
419  EXPECT_EQ(3, innerEnds.size());
420 
421  EXPECT_TRUE(nodeWasFound(innerEnds, intNetwork.getNode(intArray.at(1))));
422  EXPECT_TRUE(nodeWasFound(innerEnds, intNetwork.getNode(intArray.at(2))));
423  EXPECT_TRUE(nodeWasFound(innerEnds, intNetwork.getNode(intArray.at(3))));
424  }
425  /*
426  {
427  B2INFO("case: addInnerToLastOuterNode: inner was not there yet (innerEndsUpdate):");
428  onTheFlyCreatedInts.push_back(31);
429  int& lastOuterNodeInt = intNetwork.getLastOuterNode()->getEntry();
430  int& newInnerInt = onTheFlyCreatedInts.back();
431  unsigned int networkSizeB4 = intNetwork.size();
432  unsigned int nInnerEndsB4 = intNetwork.getInnerEnds().size();
433  unsigned int nInnerNodesB4 = intNetwork.getNode(lastOuterNodeInt)->getInnerNodes().size();
434  intNetwork.addInnerToLastOuterNode(newInnerInt);
435  EXPECT_EQ(networkSizeB4 + 1, intNetwork.size());
436  EXPECT_EQ(nInnerEndsB4 + 1, intNetwork.getInnerEnds().size());
437  EXPECT_EQ(nInnerNodesB4 + 1, intNetwork.getNode(lastOuterNodeInt)->getInnerNodes().size());
438 
439  EXPECT_TRUE(nodeWasFound(intNetwork.getNode(lastOuterNodeInt)->getInnerNodes(), intNetwork.getNode(newInnerInt)));
440  auto innerEnds = intNetwork.getInnerEnds();
441  EXPECT_TRUE(nodeWasFound(innerEnds, intNetwork.getNode(newInnerInt)));
442  }
443 
444  {
445  B2INFO("case: addOuterToLastInnerNode: both were there, but not linked yet:");
446  int& lastInnerNodeInt = intNetwork.getLastInnerNode()->getEntry();
447  unsigned int networkSizeB4 = intNetwork.size();
448  unsigned int nOuterEndsB4 = intNetwork.getOuterEnds().size();
449  intNetwork.addOuterToLastInnerNode(intArray2.at(1));
450  EXPECT_EQ(networkSizeB4, intNetwork.size());
451  EXPECT_EQ(nOuterEndsB4, intNetwork.getOuterEnds().size());
452  std::vector<DirectedNode<int, VoidMetaInfo>*> outerNodes = intNetwork.getNode(lastInnerNodeInt)->getOuterNodes();
453  EXPECT_EQ(2, outerNodes.size());
454  }
455 
456  {
457  B2INFO("case: addOuterToLastInnerNode: both were there, but already linked (same results as before, but with an error for unintended behavior):");
458  int& lastInnerNodeInt = intNetwork.getLastInnerNode()->getEntry();
459  unsigned int networkSizeB4 = intNetwork.size();
460  unsigned int nOuterEndsB4 = intNetwork.getOuterEnds().size();
461  intNetwork.addOuterToLastInnerNode(intArray2.at(1));
462  EXPECT_EQ(networkSizeB4, intNetwork.size());
463  EXPECT_EQ(nOuterEndsB4, intNetwork.getOuterEnds().size());
464  std::vector<DirectedNode<int, VoidMetaInfo>*> outerNodes = intNetwork.getNode(lastInnerNodeInt)->getOuterNodes();
465  EXPECT_EQ(2, outerNodes.size());
466  }
467 
468  {
469  B2INFO("case: addOuterToLastInnerNode: outer was not there yet (outerEndsUpdate):");
470  onTheFlyCreatedInts.push_back(66);
471  int& lastInnerNodeInt = intNetwork.getLastInnerNode()->getEntry();
472  int& newOuterInt = onTheFlyCreatedInts.back();
473  unsigned int networkSizeB4 = intNetwork.size();
474  unsigned int nOuterEndsB4 = intNetwork.getOuterEnds().size();
475  unsigned int nOuterNodesB4 = intNetwork.getNode(lastInnerNodeInt)->getOuterNodes().size();
476  intNetwork.addOuterToLastInnerNode(newOuterInt);
477  EXPECT_EQ(networkSizeB4 + 1, intNetwork.size());
478  EXPECT_EQ(nOuterEndsB4 + 1, intNetwork.getOuterEnds().size());
479  EXPECT_EQ(nOuterNodesB4 + 1, intNetwork.getNode(lastInnerNodeInt)->getOuterNodes().size());
480 
481  EXPECT_TRUE(nodeWasFound(intNetwork.getNode(lastInnerNodeInt)->getOuterNodes(), intNetwork.getNode(newOuterInt)));
482  auto outerEnds = intNetwork.getOuterEnds();
483  EXPECT_TRUE(nodeWasFound(outerEnds, intNetwork.getNode(newOuterInt)));
484  }
485  */
486  }
Belle2::DirectedNode::getInnerNodes
std::vector< DirectedNode< EntryType, MetaInfoType > * > & getInnerNodes()
************************* PUBLIC MEMBER FUNCTIONS *************************
Definition: DirectedNode.h:96
Belle2::DirectedNodeNetwork::getOuterEnds
std::vector< Node * > getOuterEnds()
getters:
Definition: DirectedNodeNetwork.h:177
Belle2::DirectedNodeNetwork::size
unsigned int size() const
Returns number of nodes to be found in the network.
Definition: DirectedNodeNetwork.h:225
Belle2::DirectedNode::getOuterNodes
std::vector< DirectedNode< EntryType, MetaInfoType > * > & getOuterNodes()
Returns links to all outer nodes attached to this one.
Definition: DirectedNode.h:99
Belle2::DirectedNodeNetwork
Network of directed nodes of the type EntryType.
Definition: DirectedNodeNetwork.h:38
Belle2::DirectedNodeNetwork::linkNodes
bool linkNodes(NodeID outerNodeID, NodeID innerNodeID)
takes two entry IDs and weaves them into the network
Definition: DirectedNodeNetwork.h:132
Belle2::DirectedNodeNetwork::getNode
Node * getNode(NodeID toBeFound)
Returns pointer to the node carrying the entry which is equal to given parameter.
Definition: DirectedNodeNetwork.h:194
Belle2::DirectedNodeNetwork::getInnerEnds
std::vector< Node * > getInnerEnds()
returns all nodes which have no inner nodes (but outer ones) and therefore are inner ends of the netw...
Definition: DirectedNodeNetwork.h:185
Belle2::DirectedNode
The Node-Class.
Definition: DirectedNode.h:41
Belle2::DirectedNodeNetwork::addNode
bool addNode(NodeID nodeID, EntryType &newEntry)
************************* PUBLIC MEMBER FUNCTIONS *************************
Definition: DirectedNodeNetwork.h:72
Belle2::DirectedNode::getEntry
EntryType & getEntry()
Allows access to stored entry.
Definition: DirectedNode.h:102
Belle2::DirectedNodeNetwork::addInnerToLastOuterNode
bool addInnerToLastOuterNode(NodeID innerNodeID)
to the last outerNode added, another innerNode will be attached
Definition: DirectedNodeNetwork.h:85