already_AddRefed<nsINode>
TreeWalker::NextNode(ErrorResult& aResult)
{
int16_t filtered = nsIDOMNodeFilter::FILTER_ACCEPT; // pre-init for inner loop
nsCOMPtr<nsINode> node = mCurrentNode;
while (1) {
nsINode *firstChild;
while (filtered != nsIDOMNodeFilter::FILTER_REJECT &&
(firstChild = node->GetFirstChild())) {
node = firstChild;
filtered = TestNode(node, aResult);
if (aResult.Failed()) {
return nullptr;
}
if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
// Node found
mCurrentNode = node;
return node.forget();
}
}
nsINode *sibling = nullptr;
nsINode *temp = node;
do {
if (temp == mRoot)
break;
sibling = temp->GetNextSibling();
if (sibling)
break;
temp = temp->GetParentNode();
} while (temp);
if (!sibling)
break;
node = sibling;
// Found a sibling. Either ours or ancestor's
filtered = TestNode(node, aResult);
if (aResult.Failed()) {
return nullptr;
}
if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
// Node found
mCurrentNode = node;
return node.forget();
}
}
return nullptr;
}
/* nsIDOMNode nextNode (); */
NS_IMETHODIMP nsTreeWalker::NextNode(nsIDOMNode **_retval)
{
nsresult rv;
PRInt16 filtered = nsIDOMNodeFilter::FILTER_ACCEPT; // pre-init for inner loop
*_retval = nsnull;
nsCOMPtr<nsINode> node = mCurrentNode;
while (1) {
nsINode *firstChild;
while (filtered != nsIDOMNodeFilter::FILTER_REJECT &&
(firstChild = node->GetFirstChild())) {
node = firstChild;
rv = TestNode(node, &filtered);
NS_ENSURE_SUCCESS(rv, rv);
if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
// Node found
mCurrentNode = node;
return CallQueryInterface(node, _retval);
}
}
nsINode *sibling = nsnull;
nsINode *temp = node;
do {
if (temp == mRoot)
break;
sibling = temp->GetNextSibling();
if (sibling)
break;
temp = temp->GetNodeParent();
} while (temp);
if (!sibling)
break;
node = sibling;
// Found a sibling. Either ours or ancestor's
rv = TestNode(node, &filtered);
NS_ENSURE_SUCCESS(rv, rv);
if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
// Node found
mCurrentNode = node;
return CallQueryInterface(node, _retval);
}
}
return NS_OK;
}
/*
* Implements NextSibling and PreviousSibling which only vary in which
* direction they search.
* @param aReversed Controls whether we search forwards or backwards
* @param aResult Whether we threw or not.
* @returns The desired node. Null if no child is found
*/
already_AddRefed<nsINode>
TreeWalker::NextSiblingInternal(bool aReversed, ErrorResult& aResult)
{
nsCOMPtr<nsINode> node = mCurrentNode;
if (node == mRoot) {
return nullptr;
}
while (1) {
nsINode* sibling = aReversed ? node->GetPreviousSibling()
: node->GetNextSibling();
while (sibling) {
node = sibling;
int16_t filtered = TestNode(node, aResult);
if (aResult.Failed()) {
return nullptr;
}
if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
// Node found
mCurrentNode = node;
return node.forget();
}
// If rejected or no children, try a sibling
if (filtered == nsIDOMNodeFilter::FILTER_REJECT ||
!(sibling = aReversed ? node->GetLastChild()
: node->GetFirstChild())) {
sibling = aReversed ? node->GetPreviousSibling()
: node->GetNextSibling();
}
}
node = node->GetParentNode();
if (!node || node == mRoot) {
return nullptr;
}
// Is parent transparent in filtered view?
int16_t filtered = TestNode(node, aResult);
if (aResult.Failed()) {
return nullptr;
}
if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
return nullptr;
}
}
}
already_AddRefed<nsINode>
TreeWalker::PreviousNode(ErrorResult& aResult)
{
nsCOMPtr<nsINode> node = mCurrentNode;
while (node != mRoot) {
while (nsINode *previousSibling = node->GetPreviousSibling()) {
node = previousSibling;
int16_t filtered = TestNode(node, aResult);
if (aResult.Failed()) {
return nullptr;
}
nsINode *lastChild;
while (filtered != nsIDOMNodeFilter::FILTER_REJECT &&
(lastChild = node->GetLastChild())) {
node = lastChild;
filtered = TestNode(node, aResult);
if (aResult.Failed()) {
return nullptr;
}
}
if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
mCurrentNode = node;
return node.forget();
}
}
if (node == mRoot) {
break;
}
node = node->GetParentNode();
if (!node) {
break;
}
int16_t filtered = TestNode(node, aResult);
if (aResult.Failed()) {
return nullptr;
}
if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
mCurrentNode = node;
return node.forget();
}
}
return nullptr;
}
/*
* Implements NextSibling and PreviousSibling which only vary in which
* direction they search.
* @param aReversed Controls whether we search forwards or backwards
* @param _retval Returned node. Null if no child is found
* @returns Errorcode
*/
nsresult nsTreeWalker::NextSiblingInternal(bool aReversed, nsIDOMNode **_retval)
{
nsresult rv;
PRInt16 filtered;
*_retval = nsnull;
nsCOMPtr<nsINode> node = mCurrentNode;
if (node == mRoot)
return NS_OK;
while (1) {
nsINode* sibling = aReversed ? node->GetPreviousSibling()
: node->GetNextSibling();
while (sibling) {
node = sibling;
rv = TestNode(node, &filtered);
NS_ENSURE_SUCCESS(rv, rv);
if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
// Node found
mCurrentNode.swap(node);
return CallQueryInterface(mCurrentNode, _retval);
}
// If rejected or no children, try a sibling
if (filtered == nsIDOMNodeFilter::FILTER_REJECT ||
!(sibling = aReversed ? node->GetLastChild()
: node->GetFirstChild())) {
sibling = aReversed ? node->GetPreviousSibling()
: node->GetNextSibling();
}
}
node = node->GetNodeParent();
if (!node || node == mRoot)
return NS_OK;
// Is parent transparent in filtered view?
rv = TestNode(node, &filtered);
NS_ENSURE_SUCCESS(rv, rv);
if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT)
return NS_OK;
}
}
/* nsIDOMNode previousNode (); */
NS_IMETHODIMP nsTreeWalker::PreviousNode(nsIDOMNode **_retval)
{
nsresult rv;
PRInt16 filtered;
*_retval = nsnull;
nsCOMPtr<nsINode> node = mCurrentNode;
while (node != mRoot) {
while (nsINode *previousSibling = node->GetPreviousSibling()) {
node = previousSibling;
rv = TestNode(node, &filtered);
NS_ENSURE_SUCCESS(rv, rv);
nsINode *lastChild;
while (filtered != nsIDOMNodeFilter::FILTER_REJECT &&
(lastChild = node->GetLastChild())) {
node = lastChild;
rv = TestNode(node, &filtered);
NS_ENSURE_SUCCESS(rv, rv);
}
if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
mCurrentNode = node;
return CallQueryInterface(node, _retval);
}
}
if (node == mRoot)
break;
node = node->GetNodeParent();
if (!node)
break;
rv = TestNode(node, &filtered);
NS_ENSURE_SUCCESS(rv, rv);
if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
mCurrentNode = node;
return CallQueryInterface(node, _retval);
}
}
return NS_OK;
}
already_AddRefed<nsINode>
NodeIterator::NextOrPrevNode(NodePointer::MoveToMethodType aMove,
ErrorResult& aResult)
{
if (mInAcceptNode) {
aResult.Throw(NS_ERROR_DOM_INVALID_STATE_ERR);
return nullptr;
}
mWorkingPointer = mPointer;
struct AutoClear {
NodePointer* mPtr;
explicit AutoClear(NodePointer* ptr) : mPtr(ptr) {}
~AutoClear() { mPtr->Clear(); }
} ac(&mWorkingPointer);
while ((mWorkingPointer.*aMove)(mRoot)) {
nsCOMPtr<nsINode> testNode = mWorkingPointer.mNode;
int16_t filtered = TestNode(testNode, aResult);
if (aResult.Failed()) {
return nullptr;
}
if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
mPointer = mWorkingPointer;
return testNode.forget();
}
}
return nullptr;
}
extern "C" void *ThreadCrawler(void *data) {
int *nThreads = (int *)data;
do {
std::vector<CServiceResult> ips;
int wait = 5;
db.GetMany(ips, 16, wait);
int64_t now = time(nullptr);
if (ips.empty()) {
wait *= 1000;
wait += rand() % (500 * *nThreads);
Sleep(wait);
continue;
}
std::vector<CAddress> addr;
for (size_t i = 0; i < ips.size(); i++) {
CServiceResult &res = ips[i];
res.nBanTime = 0;
res.nClientV = 0;
res.nHeight = 0;
res.strClientV = "";
bool getaddr = res.ourLastSuccess + 86400 < now;
res.fGood = TestNode(res.service, res.nBanTime, res.nClientV,
res.strClientV, res.nHeight,
getaddr ? &addr : nullptr);
}
db.ResultMany(ips);
db.Add(addr);
} while (1);
return nullptr;
}
/* nsIDOMNode parentNode (); */
NS_IMETHODIMP nsTreeWalker::ParentNode(nsIDOMNode **_retval)
{
*_retval = nsnull;
nsresult rv;
PRInt32 indexPos = mPossibleIndexesPos;
nsCOMPtr<nsINode> node = mCurrentNode;
while (node && node != mRoot) {
node = node->GetNodeParent();
indexPos--;
if (node) {
PRInt16 filtered;
rv = TestNode(node, &filtered);
NS_ENSURE_SUCCESS(rv, rv);
if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
mCurrentNode = node;
mPossibleIndexesPos = indexPos >= 0 ? indexPos : -1;
return CallQueryInterface(node, _retval);
}
}
}
return NS_OK;
}
/*
* Finds the first child of aNode after child N and returns it. If a
* child is found, mCurrentNode is set to that child
* @param aNode Node to search for children
* @param childNum Child number to start search from. The child with
* this number is not searched
* @param aReversed Reverses search to find the last child instead
* of first
* @param aIndexPos Position of aNode in mPossibleIndexes
* @param _retval Returned node. Null if no child is found
* @returns Errorcode
*/
nsresult
nsTreeWalker::ChildOf(nsINode* aNode,
PRInt32 childNum,
PRBool aReversed,
PRInt32 aIndexPos,
nsINode** _retval)
{
PRInt16 filtered;
nsresult rv;
PRInt32 dir = aReversed ? -1 : 1;
// Step through all children
PRInt32 i = childNum;
while (1) {
i += dir;
nsCOMPtr<nsINode> child = aNode->GetChildAt(i);
if (!child) {
break;
}
rv = TestNode(child, &filtered);
NS_ENSURE_SUCCESS(rv, rv);
switch (filtered) {
case nsIDOMNodeFilter::FILTER_ACCEPT:
// Child found
mCurrentNode = child;
mPossibleIndexesPos = aIndexPos;
*_retval = child;
NS_ADDREF(*_retval);
SetChildIndex(aIndexPos, i);
return NS_OK;
case nsIDOMNodeFilter::FILTER_SKIP:
// Search children
rv = FirstChildOf(child, aReversed, aIndexPos+1, _retval);
NS_ENSURE_SUCCESS(rv, rv);
if (*_retval) {
SetChildIndex(aIndexPos, i);
return NS_OK;
}
break;
case nsIDOMNodeFilter::FILTER_REJECT:
// Keep searching
break;
default:
return NS_ERROR_UNEXPECTED;
}
}
*_retval = nsnull;
return NS_OK;
}
/*
* Implements FirstChild and LastChild which only vary in which direction
* they search.
* @param aReversed Controls whether we search forwards or backwards
* @param _retval Returned node. Null if no child is found
* @returns Errorcode
*/
nsresult nsTreeWalker::FirstChildInternal(bool aReversed, nsIDOMNode **_retval)
{
nsresult rv;
PRInt16 filtered;
*_retval = nsnull;
nsCOMPtr<nsINode> node = aReversed ? mCurrentNode->GetLastChild()
: mCurrentNode->GetFirstChild();
while (node) {
rv = TestNode(node, &filtered);
NS_ENSURE_SUCCESS(rv, rv);
switch (filtered) {
case nsIDOMNodeFilter::FILTER_ACCEPT:
// Node found
mCurrentNode = node;
return CallQueryInterface(node, _retval);
case nsIDOMNodeFilter::FILTER_SKIP: {
nsINode *child = aReversed ? node->GetLastChild()
: node->GetFirstChild();
if (child) {
node = child;
continue;
}
break;
}
case nsIDOMNodeFilter::FILTER_REJECT:
// Keep searching
break;
}
do {
nsINode *sibling = aReversed ? node->GetPreviousSibling()
: node->GetNextSibling();
if (sibling) {
node = sibling;
break;
}
nsINode *parent = node->GetNodeParent();
if (!parent || parent == mRoot || parent == mCurrentNode) {
return NS_OK;
}
node = parent;
} while (node);
}
return NS_OK;
}
/*
* Implements FirstChild and LastChild which only vary in which direction
* they search.
* @param aReversed Controls whether we search forwards or backwards
* @param aResult Whether we threw or not.
* @returns The desired node. Null if no child is found
*/
already_AddRefed<nsINode>
TreeWalker::FirstChildInternal(bool aReversed, ErrorResult& aResult)
{
nsCOMPtr<nsINode> node = aReversed ? mCurrentNode->GetLastChild()
: mCurrentNode->GetFirstChild();
while (node) {
int16_t filtered = TestNode(node, aResult);
if (aResult.Failed()) {
return nullptr;
}
switch (filtered) {
case nsIDOMNodeFilter::FILTER_ACCEPT:
// Node found
mCurrentNode = node;
return node.forget();
case nsIDOMNodeFilter::FILTER_SKIP: {
nsINode *child = aReversed ? node->GetLastChild()
: node->GetFirstChild();
if (child) {
node = child;
continue;
}
break;
}
case nsIDOMNodeFilter::FILTER_REJECT:
// Keep searching
break;
}
do {
nsINode *sibling = aReversed ? node->GetPreviousSibling()
: node->GetNextSibling();
if (sibling) {
node = sibling;
break;
}
nsINode *parent = node->GetParentNode();
if (!parent || parent == mRoot || parent == mCurrentNode) {
return nullptr;
}
node = parent;
} while (node);
}
return nullptr;
}
/*
* Finds the following sibling of aNode and returns it. If a sibling
* is found, mCurrentNode is set to that node.
* @param aNode Node to start search at.
* @param aReversed Reverses search to find the previous sibling
* instead of next.
* @param aIndexPos Position of aNode in mPossibleIndexes.
* @param _retval Returned node. Null if no sibling is found
* @returns Errorcode
*/
nsresult
nsTreeWalker::NextSiblingOf(nsINode* aNode,
PRBool aReversed,
PRInt32 aIndexPos,
nsINode** _retval)
{
nsresult rv;
nsCOMPtr<nsINode> node = aNode;
PRInt16 filtered;
PRInt32 childNum;
if (node == mRoot) {
*_retval = nsnull;
return NS_OK;
}
while (1) {
nsCOMPtr<nsINode> parent = node->GetNodeParent();
if (!parent)
break;
childNum = IndexOf(parent, node, aIndexPos);
NS_ENSURE_TRUE(childNum >= 0, NS_ERROR_UNEXPECTED);
// Search siblings
rv = ChildOf(parent, childNum, aReversed, aIndexPos, _retval);
NS_ENSURE_SUCCESS(rv, rv);
if (*_retval)
return NS_OK;
// Is parent the root?
if (parent == mRoot)
break;
// Is parent transparent in filtered view?
rv = TestNode(parent, &filtered);
NS_ENSURE_SUCCESS(rv, rv);
if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT)
break;
node = parent;
aIndexPos = aIndexPos < 0 ? -1 : aIndexPos-1;
}
*_retval = nsnull;
return NS_OK;
}
void TerritoryRegion::CalcTerritoryOfBuilding(const noBaseBuilding* const building)
{
bool check_barriers = true;
unsigned short radius;
if(building->GetBuildingType() == BLD_HARBORBUILDING)
radius = HARBOR_ALONE_RADIUS;
else
radius = static_cast<const nobBaseMilitary*>(building)->GetMilitaryRadius();
if (building->GetGOT() == GOT_NOB_MILITARY)
{
// we don't check barriers for captured buildings
check_barriers = !(static_cast<const nobMilitary*>(building)->WasCapturedOnce());
}
// Punkt, auf dem das Militärgebäude steht
MapCoord x = building->GetX(), y = building->GetY();
TestNode(x, y, building->GetPlayer(), 0, false); // no need to check barriers here. this point is on our territory.
for(unsigned r = 1; r <= radius; ++r)
{
// Eins weiter nach links gehen
gwb->GetPointA(x, y, 0);
for(unsigned dir = 0; dir < 6; ++dir)
{
for(unsigned short i = 0; i < r; ++i)
{
TestNode(x, y, building->GetPlayer(), r, check_barriers);
// Nach rechts oben anfangen
gwb->GetPointA(x, y, (2 + dir) % 6);
}
}
}
}
void nofGeologist::LookForNewNodes()
{
unsigned short max_radius = 15;
bool found = false;
for(unsigned short r = 1; r < max_radius; ++r)
{
MapPoint test(flag->GetPos());
// r Punkte rüber
test.x -= r;
// r schräg runter bzw hoch
for(unsigned short i = 0; i < r; ++i)
{
TestNode(MapPoint(test.x, test.y + i)); // unten
if(i) TestNode(MapPoint(test.x, test.y - i)); // oben
test.x += (test.y & 1);
}
// Die obere bzw untere Reihe
for(unsigned short i = 0; i < r + 1; ++i, ++test.x)
{
TestNode(MapPoint(test.x, test.y + r)); // unten
TestNode(MapPoint(test.x, test.y - r)); // oben
}
test.x = flag->GetX() + r;
// auf der anderen Seite wieder schräg hoch/runter
for(unsigned short i = 0; i < r; ++i)
{
TestNode(MapPoint(test.x, test.y + i)); // unten
if(i) TestNode(MapPoint(test.x, test.y - i)); // oben
test.x -= !(test.y & 1);
}
// Wenn es in diesem Umkreis welche gibt, dann nur noch 2 Kreise zusätzlich weitergehen
if(!found && !available_nodes.empty())
{
max_radius = std::min(10, r + 3);
found = true;
}
}
}
already_AddRefed<nsINode>
TreeWalker::ParentNode(ErrorResult& aResult)
{
nsCOMPtr<nsINode> node = mCurrentNode;
while (node && node != mRoot) {
node = node->GetParentNode();
if (node) {
int16_t filtered = TestNode(node, aResult);
if (aResult.Failed()) {
return nullptr;
}
if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
mCurrentNode = node;
return node.forget();
}
}
}
return nullptr;
}
nsresult
nsNodeIterator::NextOrPrevNode(NodePointer::MoveToMethodType aMove,
nsIDOMNode **_retval)
{
nsresult rv;
int16_t filtered;
*_retval = nullptr;
if (mDetached || mInAcceptNode)
return NS_ERROR_DOM_INVALID_STATE_ERR;
mWorkingPointer = mPointer;
struct AutoClear {
NodePointer* mPtr;
AutoClear(NodePointer* ptr) : mPtr(ptr) {}
~AutoClear() { mPtr->Clear(); }
} ac(&mWorkingPointer);
while ((mWorkingPointer.*aMove)(mRoot)) {
nsCOMPtr<nsINode> testNode = mWorkingPointer.mNode;
rv = TestNode(testNode, &filtered);
NS_ENSURE_SUCCESS(rv, rv);
if (mDetached)
return NS_ERROR_DOM_INVALID_STATE_ERR;
if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
mPointer = mWorkingPointer;
return CallQueryInterface(testNode, _retval);
}
}
return NS_OK;
}
/* nsIDOMNode parentNode (); */
NS_IMETHODIMP nsTreeWalker::ParentNode(nsIDOMNode **_retval)
{
*_retval = nullptr;
nsresult rv;
nsCOMPtr<nsINode> node = mCurrentNode;
while (node && node != mRoot) {
node = node->GetParentNode();
if (node) {
int16_t filtered;
rv = TestNode(node, &filtered);
NS_ENSURE_SUCCESS(rv, rv);
if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
mCurrentNode = node;
return CallQueryInterface(node, _retval);
}
}
}
return NS_OK;
}
/*
* Finds the next node in document order of aNode and returns it.
* If a node is found, mCurrentNode is set to that node.
* @param aNode Node to start search at.
* @param aReversed Reverses search to find the preceding node
* instead of next.
* @param aIndexPos Position of aNode in mPossibleIndexes.
* @param _retval Returned node. Null if no node is found
* @returns Errorcode
*/
nsresult
nsTreeWalker::NextInDocumentOrderOf(nsINode* aNode,
PRBool aReversed,
PRInt32 aIndexPos,
nsINode** _retval)
{
nsresult rv;
if (!aReversed) {
rv = FirstChildOf(aNode, aReversed, aIndexPos+1, _retval);
NS_ENSURE_SUCCESS(rv, rv);
if (*_retval)
return NS_OK;
}
if (aNode == mRoot){
*_retval = nsnull;
return NS_OK;
}
nsCOMPtr<nsINode> node = aNode;
nsCOMPtr<nsINode> currentNodeBackup = mCurrentNode;
PRInt16 filtered;
PRInt32 childNum;
while (1) {
// Get our index in the parent
nsCOMPtr<nsINode> parent = node->GetNodeParent();
if (!parent)
break;
childNum = IndexOf(parent, node, aIndexPos);
NS_ENSURE_TRUE(childNum >= 0, NS_ERROR_UNEXPECTED);
// Search siblings
nsCOMPtr<nsINode> sibling;
rv = ChildOf(parent, childNum, aReversed, aIndexPos,
getter_AddRefs(sibling));
NS_ENSURE_SUCCESS(rv, rv);
if (sibling) {
if (aReversed) {
// in reversed walking we first test if there are
// any children. I don't like this piece of code :(
nsCOMPtr<nsINode> child = sibling;
while (child) {
sibling = child;
rv = FirstChildOf(sibling,
PR_TRUE,
aIndexPos,
getter_AddRefs(child));
if (NS_FAILED(rv)) {
// ChildOf set mCurrentNode and then something
// failed. Restore the old value before returning
mCurrentNode = currentNodeBackup;
mPossibleIndexesPos = -1;
return rv;
}
}
}
*_retval = sibling;
NS_ADDREF(*_retval);
return NS_OK;
}
aIndexPos = aIndexPos < 0 ? -1 : aIndexPos-1;
if (aReversed) {
// Is parent transparent in filtered view?
rv = TestNode(parent, &filtered);
NS_ENSURE_SUCCESS(rv, rv);
if (filtered == nsIDOMNodeFilter::FILTER_ACCEPT) {
mCurrentNode = parent;
mPossibleIndexesPos = aIndexPos;
*_retval = parent;
NS_ADDREF(*_retval);
return NS_OK;
}
}
// Is parent the root?
if (parent == mRoot)
break;
node = parent;
}
*_retval = nsnull;
return NS_OK;
}
