Data Access

typedefs assumed below (you can use them in your code): typedef FATableItr<L> ILeft; typedef FATableItr<R> IRight; typedef Lattice<L,R,LD> Lattice; typedef Lattice::LinkData LinkData; // _linkdata_type_ typedef Lattice::LeftID LeftID; typedef Lattice::RightID RightID; typedef Lattice::VectorLeftID VectorLeftID; // vector<LeftID> typedef Lattice::VectorRightID VectorRightID; // vector<RightID> typedef Lattice::LeftItr LeftItr; // VectorLeftID ::const_iterator typedef Lattice::RightItr RightItr; // VectorRightID::const_iterator typedef Lattice::Links Links; // vector<Link*> typedef Lattice::LinkItr LinkItr; // Links::const_iterator

General information:

• Retrieve a vector of all identifiers on one side of the Lattice:

const VectorLeftID&  ld = pLattice->vLeftID ();
const VectorRightID& rd = pLattice->vRightID();

• Retrieve a vector of pointers to all links in this Lattice:

const Links& links = pLattice->links();

• Query the usage of this Lattice:
  true indicates that the Lattice is empty.

DABoolean empty = pLattice->isEmpty();

• Query the topology of this Lattice:
  true indicates that the corresponding topology is enabled.

DABoolean b = pLattice->isLNodeMulti(); // Left  objects may have many links.
DABoolean b = pLattice->isRNodeMulti(); // Right objects may have many links.
DABoolean b = pLattice->isLLinkMulti(); // Many left  objects may share a link.
DABoolean b = pLattice->isRLinkMulti(); // Many right objects may share a link.

• Retrieve the topology of this Lattice:
  Reports the topology as a string.

string s = topologyText();
cout << topologyText();

Navigation:

• Retrieve an object's friends (a vector of identifiers):
  For the ID argument, return 0 if the ID is not in the Lattice.

const VectorLeftID*  vLL = pLattice->vLeftGivenLeft  (LeftID);
const VectorLeftID*  vLL = pLattice->vLeftGivenLeft  (LeftItr);
const VectorLeftID*  vLL = pLattice->vLeftGivenLeft  (FATableItr<L>);

const VectorRightID* vRR = pLattice->vRightGivenRight(RightID);
const VectorRightID* vRR = pLattice->vRightGivenRight(RightItr);
const VectorRightID* vRR = pLattice->vRightGivenRight(FATableItr<R>);

const VectorRightID* vRL = pLattice->vRightGivenLeft (LeftID);
const VectorRightID* vRL = pLattice->vRightGivenLeft (LeftItr);
const VectorRightID* vRL = pLattice->vRightGivenLeft (FATableItr<L>);

const VectorLeftID*  vLR = pLattice->vLeftGivenRight (RightID);
const VectorLeftID*  vLR = pLattice->vLeftGivenRight (RightItr);
const VectorLeftID*  vLR = pLattice->vLeftGivenRight (FATableItr<R>);

• Retrieve an object's single friend (a pointer to a const identifier):
  Return 0 if there is not a single ID (ie, none or more than one).

const LeftID*  LL = pLattice->leftIDGivenLeft  (LeftID);
const LeftID*  LL = pLattice->leftIDGivenLeft  (LeftItr);
const LeftID*  LL = pLattice->leftIDGivenLeft  (FATableItr<L>);

const RightID* RR = pLattice->rightIDGivenRight(RightID);
const RightID* RR = pLattice->rightIDGivenRight(RightItr);
const RightID* RR = pLattice->rightIDGivenRight(FATableItr<R>);

const RightID* RL = pLattice->rightIDGivenLeft (LeftID);
const RightID* RL = pLattice->rightIDGivenLeft (LeftItr);
const RightID* RL = pLattice->rightIDGivenLeft (FATableItr<L>);

const LeftID*  LR = pLattice->leftIDGivenRight (RightID);
const LeftID*  LR = pLattice->leftIDGivenRight (RightItr);
const LeftID*  LR = pLattice->leftIDGivenRight (FATableItr<R>);

• Retrieve data across the Lattice:
  Here's a complete example showing how to loop over the Lattice's left data and, for each left datum, loop over its far friends to accesses their data. RightTable is the FATable on the right side of the Lattice. *li and *ri are FATable Identifiers.

const VectorLeftID& vlid = pLattice->vLeftID();
for (LeftItr li = vlid.begin();  li != vlid.end();  ++li)
{ const VectorRightID& vrid =  (*li)->vRightGivenLeft();
  for (RightItr ri = vrid.begin();  ri != vrid.end();  ++ri)
  { value = RightTable.find(*ri)->value();
  }
}

The above code works both for FATables and FAPtrTables. If you have an FATable, then this works also:
value = RightTable[*ri].value();
FAPtrTables don't support operator[].

• Retrieve a vector of pointers to an object's links:
  You can pass in the object's identifier, its LeftData iterator, or its FATable iterator.

const Links* pLinks = linksGivenLeft(LeftID);
const Links* pLinks = linksGivenLeft(LeftItr);
const Links* pLinks = linksGivenLeft(FATableItr<L>);

const Links* pLinks = linksGivenRight(RightID);
const Links* pLinks = linksGivenRight(RightItr);
const Links* pLinks = linksGivenRight(FATableItr<R>);

Loop over a node's links like this::

Links::const_iterator i    = links.begin();
Links::const_iterator iEnd = links.end();
for (; i != iEnd; ++i)
{ Link* pLink = *i;
  ...
}

• Retrieve an object's only link:
  Return 0 if there is not a single link (ie, none or more than one).

Link* pLink = linkGivenLeft(LeftID);
Link* pLink = linkGivenLeft(LeftItr);
Link* pLink = linkGivenLeft(FATableItr<L>);

Link* pLink = linkGivenRight(RightID);
Link* pLink = linkGivenRight(RightItr);
Link* pLink = linkGivenRight(FATableItr<R>);

• Fill a vector of pointers to the links that connect two objects, or that they share:
  This vector (the third argument in the calls below) is filled on the fly, so the user must create it and delete it when he's done. Lattice uses push_back(), so it will add to an existing vector, if the user wants that behavior.

void connectLinks   (LeftID,        RightID,       Links&);
void connectLinks   (LeftItr,       RightItr,      Links&);
void connectLinks   (FATableItr<L>, FATableItr<R>, Links&);

void shareLinksLeft (LeftID,        LeftID,        Links&);
void shareLinksLeft (LeftItr,       LeftItr,       Links&);
void shareLinksLeft (FATableItr<L>, FATableItr<L>, Links&);

void shareLinksRight(RightID,       RightID,       Links&);
void shareLinksRight(RightItr,      RightItr,      Links&);
void shareLinksRight(FATableItr<R>, FATableItr<R>, Links&);

• Return a pointer to the one link that connects two objects, or that they share:
  Return 0 if there is not a single link (ie, none or more than one).

Link* connectLink   (LeftID,        RightID);
Link* connectLink   (LeftItr,       RightItr);
Link* connectLink   (FATableItr<L>, FATableItr<R>);

link* shareLinkLeft (LeftID,        LeftID);
Link* shareLinkLeft (LeftItr,       LeftItr);
Link* shareLinkLeft (FATableItr<L>, FATableItr<L>);

Link* shareLinkRight(RightID,       RightID);
Link* shareLinkRight(RightItr,      RightItr);
Link* shareLinkRight(FATableItr<R>, FATableItr<R>);

• Retrieve the data associated with a link:
  The link data is a user defined class that the user is free to define and modify (see TestLattice.cc).

LinkData& ld = pLink->linkData();

ld is a reference to your link data class for this link. Do whatever you want with it. You have write access.

• Retrieve a vector of the identifiers at either end of the link:

const VectorLeftID&  vlid = pLink->vLeftID ();
const VectorRightID& vrid = pLink->vRightID();

• Retrieve the single identifier at one end of the link:
  Return 0 if there is not a single ID (ie, none or more than one).

const LeftID*  lid = pLink->leftID ();
const RightID* rid = pLink->rightID();