/**
* Utility method for traversing a text node that we know
* a-priori to be on a left or right boundary of the range.
* This method does not properly handle text nodes that contain
* both the start and end points of the range.
*
*/
DOM_Node RangeImpl::traverseTextNode( DOM_Node n, bool isLeft, int how )
{
DOMString txtValue = n.getNodeValue();
DOMString newNodeValue;
DOMString oldNodeValue;
if ( isLeft )
{
int offset = getStartOffset();
newNodeValue = txtValue.substringData( offset , fStartContainer.getNodeValue().length()-offset);
oldNodeValue = txtValue.substringData( 0, offset );
}
else
{
int offset = getEndOffset();
newNodeValue = txtValue.substringData( 0, offset );
oldNodeValue = txtValue.substringData( offset , fEndContainer.getNodeValue().length()-offset );
}
if ( how != CLONE_CONTENTS )
n.setNodeValue( oldNodeValue );
if ( how==DELETE_CONTENTS )
return null;
DOM_Node newNode = n.cloneNode( false );
newNode.setNodeValue( newNodeValue );
return newNode;
}
int DirHashCacheEntry::saveCeHeader()
{
int fd = getFdStore();
if ( fd == -1 )
{
errno = EBADF;
return -1;
}
if ( nio_lseek( fd, getStartOffset(), SEEK_SET ) == -1 )
return -1;
char achBuf[4 + sizeof( CeHeader ) ];
//*( int *)achBuf = CE_ID;
memcpy(achBuf, CE_ID, 4);
memmove( &achBuf[4], &getHeader(), sizeof( CeHeader ) );
if ( (size_t)nio_write( fd, achBuf, 4 + sizeof( CeHeader ) ) <
4 + sizeof( CeHeader ) )
return -1;
if ( getHeader().m_keyLen > 0 )
{
if ( nio_write( fd, getKey().c_str(), getHeader().m_keyLen ) <
getHeader().m_keyLen )
return -1;
}
return 0;
}
void
GfxFeatureMapRequestPacket::printPacket() const
{
cout << "GfxFeatureMapRequestPacket::printPacket() for map "
<< getMapID() << endl;
cout << "Bounding box for the GfxFeatureMapRequestPacket:" << endl;
MC2BoundingBox bbox;
getMC2BoundingBox(&bbox);
bbox.dump();
uint16 x, y;
getScreenSize(x, y);
cout << "Screen size (x = " << x << ", y = "
<< y << ")" << endl;
cout << "max scaleLevel = " << getMaxScaleLevel() << endl;
cout << "min scaleLevel = " << getMinScaleLevel() << endl;
cout << "filt scaleLevel = " << getFiltScaleLevel() << endl;
cout << "language = " << (int)getLanguage() << endl;
cout << "nbrNodeIDs " << getNbrNodeIDs() << endl;
cout << " isStartAndEnd byte 0x" << hex
<< int( readByte(isStartAndEnd_POS)) << dec << endl;
cout << "IgnoreStartOffset " << BP(getIgnoreStartOffset()) << endl;
cout << " isStartAndEnd byte 0x" << hex
<< int(readByte(isStartAndEnd_POS)) << dec << endl;
cout << "IgnoreEndOffset " << BP(getIgnoreEndOffset()) << endl;
cout << "StartOffset " << getStartOffset() << endl;
cout << "EndOffset " << getEndOffset() << endl;
cout << "NbrReqPackets " << int(getNbrReqPackets()) << endl;
cout << "DrawOverviewContents " << BP(getDrawOverviewContents())
<< endl;
}
static void computePartialReadToNodeMapping(IDnum nodeID,
ReadOccurence ** readNodes,
IDnum * readNodeCounts,
boolean * readMarker,
ReadSet * reads)
{
ShortReadMarker *shortMarker;
IDnum index, readIndex;
ReadOccurence *readArray, *readOccurence;
Node *node = getNodeInGraph(graph, nodeID);
ShortReadMarker *nodeArray = getNodeReads(node, graph);
IDnum nodeReadCount = getNodeReadCount(node, graph);
PassageMarkerI marker;
for (index = 0; index < nodeReadCount; index++) {
shortMarker = getShortReadMarkerAtIndex(nodeArray, index);
readIndex = getShortReadMarkerID(shortMarker);
readArray = readNodes[readIndex];
readOccurence = &readArray[readNodeCounts[readIndex]];
readOccurence->nodeID = nodeID;
readOccurence->position =
getShortReadMarkerPosition(shortMarker);
readOccurence->offset =
getShortReadMarkerOffset(shortMarker);
readNodeCounts[readIndex]++;
}
for (marker = getMarker(node); marker != NULL_IDX;
marker = getNextInNode(marker)) {
readIndex = getPassageMarkerSequenceID(marker);
if (readIndex <= 0 || reads->categories[readIndex - 1] == REFERENCE)
continue;
if (!readMarker[readIndex]) {
readArray = readNodes[readIndex];
readOccurence =
&readArray[readNodeCounts[readIndex]];
readOccurence->nodeID = nodeID;
readOccurence->position = getStartOffset(marker);
readOccurence->offset =
getPassageMarkerStart(marker);
readNodeCounts[readIndex]++;
readMarker[readIndex] = true;
} else {
readArray = readNodes[readIndex];
readOccurence =
&readArray[readNodeCounts[readIndex] - 1];
readOccurence->position = -1;
readOccurence->offset = -1;
}
}
for (marker = getMarker(node); marker != NULL_IDX;
marker = getNextInNode(marker)) {
readIndex = getPassageMarkerSequenceID(marker);
if (readIndex > 0)
readMarker[readIndex] = false;
}
}
//<"LSCH"><CeHeader><CacheKey><ResponseHeader><ResponseBody>
int DirHashCacheEntry::loadCeHeader()
{
int fd = getFdStore();
if ( fd == -1 )
{
errno = EBADF;
return -1;
}
if ( nio_lseek( fd, getStartOffset(), SEEK_SET ) == -1 )
return -1;
char achBuf[4 + sizeof( CeHeader ) ];
if ( (size_t)nio_read( fd, achBuf, 4 + sizeof( CeHeader ) )
< 4 + sizeof( CeHeader ) )
return -1;
// if ( *( uint32_t *)achBuf != CE_ID )
// return -1;
if (memcmp(achBuf, CE_ID, 4) != 0)
return -1;
memmove( &getHeader(), &achBuf[4], sizeof( CeHeader ) );
int len = getHeader().m_keyLen;
if ( len > 0 )
{
char * p = getKey().prealloc( len+1 );
if ( !p )
return -1;
if ( nio_read( fd, p, len ) < len )
return -1;
*(p+len) = 0;
}
char tmpBUf[4096];
#ifdef CACHE_RESP_HEADER
if (getHeader().m_valPart1Len < 4096 ) //< 4K
{
if ( nio_read( fd, tmpBUf, getHeader().m_valPart1Len ) < getHeader().m_valPart1Len )
return -1;
m_sRespHeader.append(tmpBUf, getHeader().m_valPart1Len);
}
#endif
//load part3 to buffer
int part3offset = getHeaderSize() + getContentTotalLen();
if ( nio_lseek( fd, part3offset, SEEK_SET ) != -1 )
{
while((len = nio_read( fd, tmpBUf, 4096 )) > 0)
m_sPart3Buf.append(tmpBUf, len);
}
return 0;
}
// DEBUG
void checkNode(Node* node) {
PassageMarkerI marker1 = getMarker(node);
if (marker1 == NULL_IDX)
return;
PassageMarkerI marker2 = getNextInNode(marker1);
if (marker2 == NULL_IDX)
return;
if (getStartOffset(marker1) == getStartOffset(marker2))
abort();
if (getFinishOffset(marker1) == getFinishOffset(marker2))
abort();
printf(">>>> Node %li\n", (long) getNodeID(node));
printf("Marker1: %li - %li > %li (%li) \n", (long) getStartOffset(marker1), (long) getPassageMarkerLength(marker1), (long) (getNodeLength(node) - getFinishOffset(marker1)), (long) getFinishOffset(marker1));
printf("%s\n", readPassageMarker(marker1));
printf("Marker2: %li - %li > %li (%li) \n", (long) getStartOffset(marker2), (long) getPassageMarkerLength(marker2), (long) (getNodeLength(node) - getFinishOffset(marker2)), (long) getFinishOffset(marker2));
printf("%s\n", readPassageMarker(marker2));
if (getStartOffset(marker1) < getNodeLength(node) - getFinishOffset(marker2)
&& getStartOffset(marker2) < getNodeLength(node) - getFinishOffset(marker1)) {
//abort();
;
}
}
static void projectFromLongRead(Node * node, PassageMarkerI marker,
IDnum * readPairs, Category * cats,
ReadOccurence ** readNodes,
IDnum * readNodeCounts,
ShortLength * lengths, boolean weight)
{
IDnum index;
IDnum readIndex = getPassageMarkerSequenceID(marker);
ReadOccurence *readArray;
IDnum readPairIndex;
Category cat;
Coordinate position = getStartOffset(marker);
Coordinate offset = getPassageMarkerStart(marker);
Coordinate length =
lengths[getPassageMarkerSequenceID(marker) - 1];
Coordinate insertLength;
double insertVariance;
// Going through single-read information
if (readNodeCounts[readIndex] > 1 && position >= 0) {
readArray = readNodes[readIndex];
for (index = 0; index < readNodeCounts[readIndex]; index++)
projectFromSingleRead(node, &readArray[index],
position, offset, length,
weight);
}
// Going through paired read information
if (readPairs == NULL)
return;
readPairIndex = readPairs[readIndex - 1] + 1;
if (readPairIndex == 0)
return;
cat = cats[readIndex - 1];
insertLength = getInsertLength(graph, cat);
insertVariance = getInsertLength_var(graph, cat);
readArray = readNodes[readPairIndex];
for (index = 0; index < readNodeCounts[readPairIndex]; index++)
projectFromReadPair(node, &readArray[index], position,
offset, insertLength, insertVariance,
weight);
}
/**
* Traverses the "left boundary" of this range and
* operates on each "boundary node" according to the
* how parameter. It is a-priori assumed
* by this method that the left boundary does
* not contain the range's end container.
*
* A "left boundary" is best visualized by thinking
* of a sample tree:
*
* A
* /|\
* / | \
* / | \
* B C D
* /|\ /|\
* E F G H I J
*
* Imagine first a range that begins between the
* "E" and "F" nodes and ends between the
* "I" and "J" nodes. The start container is
* "B" and the end container is "D". Given this setup,
* the following applies:
*
* Partially Selected Nodes: B, D<br>
* Fully Selected Nodes: F, G, C, H, I
*
* The "left boundary" is the highest subtree node
* that contains the starting container. The root of
* this subtree is always partially selected.
*
* In this example, the nodes that are traversed
* as "left boundary" nodes are: F, G, and B.
*
*/
DOM_Node RangeImpl::traverseLeftBoundary( DOM_Node root, int how )
{
DOM_Node next = getSelectedNode( getStartContainer(), getStartOffset() );
bool isFullySelected = ( next!=getStartContainer() );
if ( next==root )
return traverseNode( next, isFullySelected, true, how );
DOM_Node parent = next.getParentNode();
DOM_Node clonedParent = traverseNode( parent, false, true, how );
while( parent!=null )
{
while( next!=null )
{
DOM_Node nextSibling = next.getNextSibling();
DOM_Node clonedChild =
traverseNode( next, isFullySelected, true, how );
if ( how!=DELETE_CONTENTS )
clonedParent.appendChild(clonedChild);
isFullySelected = true;
next = nextSibling;
}
if ( parent==root )
return clonedParent;
next = parent.getNextSibling();
parent = parent.getParentNode();
DOM_Node clonedGrandParent = traverseNode( parent, false, true, how );
if ( how!=DELETE_CONTENTS )
clonedGrandParent.appendChild( clonedParent );
clonedParent = clonedGrandParent;
}
// should never occur
return null;
}
/**
* @brief Filling m_exif member with exif directory elements
* This is internal function and is not exposed to client
*
* @return The function doesn't return any value. In case of unsiccessful parsing
* the m_exif member is not filled up
*/
void ExifReader::parseExif()
{
m_format = getFormat();
if( !checkTagMark() )
{
return;
}
uint32_t offset = getStartOffset();
size_t numEntry = getNumDirEntry();
offset += 2; //go to start of tag fields
for( size_t entry = 0; entry < numEntry; entry++ )
{
ExifEntry_t exifEntry = parseExifEntry( offset );
m_exif.insert( std::make_pair( exifEntry.tag, exifEntry ) );
offset += tiffFieldSize;
}
}
static boolean uniqueNodesConnect(Node * startingNode)
{
Node *destination = NULL;
PassageMarkerI startMarker, currentMarker;
RBConnection *newList;
RBConnection *list = NULL;
boolean multipleHits = false;
if (arcCount(startingNode) == 0)
return false;
if (getMarker(startingNode) == NULL_IDX)
return false;
dbgCounter++;
// Checking for multiple destinations
for (startMarker = getMarker(startingNode); startMarker != NULL_IDX;
startMarker = getNextInNode(startMarker)) {
if (getFinishOffset(startMarker) >
2 * getWordLength(graph))
continue;
for (currentMarker = getNextInSequence(startMarker);
currentMarker != NULL_IDX;
currentMarker = getNextInSequence(currentMarker)) {
if (!getUniqueness(getNode(currentMarker))) {
continue;
} else if (getNodeStatus(getNode(currentMarker))) {
if (getStartOffset(currentMarker) >
2 * getWordLength(graph))
break;
for (newList = list; newList != NULL;
newList = newList->next) {
if (newList->node ==
getNode(currentMarker)) {
newList->multiplicity++;
break;
}
}
if (newList == NULL)
abort();
break;
} else {
if (getStartOffset(currentMarker) >
2 * getWordLength(graph))
break;
setSingleNodeStatus(getNode(currentMarker),
true);
newList = allocateRBConnection();
newList->node = getNode(currentMarker);
newList->multiplicity = 1;
newList->marker = startMarker;
newList->next = list;
list = newList;
break;
}
}
}
while (list != NULL) {
newList = list;
list = newList->next;
setSingleNodeStatus(newList->node, false);
if (newList->multiplicity >= MULTIPLICITY_CUTOFF) {
if (destination == NULL) {
destination = newList->node;
path = newList->marker;
} else if (destination != newList->node)
multipleHits = true;
}
deallocateRBConnection(newList);
}
if (multipleHits) {
multCounter++;
setUniqueness(startingNode, false);
return false;
}
if (destination == NULL || destination == startingNode
|| destination == getTwinNode(startingNode)) {
nullCounter++;
return false;
}
// Check for reciprocity
for (startMarker = getMarker(getTwinNode(destination));
startMarker != NULL_IDX;
startMarker = getNextInNode(startMarker)) {
if (getFinishOffset(startMarker) >
2 * getWordLength(graph))
continue;
for (currentMarker = getNextInSequence(startMarker);
currentMarker != NULL_IDX;
currentMarker = getNextInSequence(currentMarker)) {
if (!getUniqueness(getNode(currentMarker))) {
continue;
} else if (getNodeStatus(getNode(currentMarker))) {
if (getStartOffset(currentMarker) >
2 * getWordLength(graph))
break;
for (newList = list; newList != NULL;
newList = newList->next) {
if (newList->node ==
getNode(currentMarker)) {
newList->multiplicity++;
break;
}
}
if (newList == NULL)
abort();
break;
} else {
if (getStartOffset(currentMarker) >
2 * getWordLength(graph))
break;
setSingleNodeStatus(getNode(currentMarker),
true);
newList = allocateRBConnection();
newList->node = getNode(currentMarker);
newList->multiplicity = 1;
newList->next = list;
list = newList;
break;
}
}
}
while (list != NULL) {
newList = list;
list = newList->next;
setSingleNodeStatus(newList->node, false);
if (newList->multiplicity >= MULTIPLICITY_CUTOFF
&& newList->node != getTwinNode(startingNode))
multipleHits = true;
deallocateRBConnection(newList);
}
if (multipleHits) {
multCounter++;
setUniqueness(destination, false);
return false;
}
// Aligning long reads to each other:
// TODO
// Merge pairwise alignments and produce consensus
// TODO
return true;
}
