bool isBalanced(TreeNode *root) {
// Start typing your C/C++ solution below
// DO NOT write int main() function
bool isB = true;
walkTree(root, isB);
return isB;
}
void ofxTimeMeasurements::walkTree(core::tree<string>::iterator Arg, int levelArg, vector<string> &result){
levelArg++;
for(core::tree<string>::iterator x = Arg.begin(); x != Arg.end(); ++x){
result.push_back(x.data());
walkTree(x, levelArg, result);
}
}
int
html2text(char *text, const char *content)
{
int ret;
xmlNodePtr root;
xmlErrorPtr err;
htmlParserCtxtPtr parser;
parser = htmlCreatePushParserCtxt(NULL, NULL, NULL, 0, NULL, 0);
/* htmlCtxtUseOptions(parser, HTML_PARSE_NOBLANKS | HTML_PARSE_NOERROR | HTML_PARSE_NOWARNING | HTML_PARSE_NONET); */
htmlCtxtUseOptions(parser, HTML_PARSE_RECOVER | HTML_PARSE_NOBLANKS | HTML_PARSE_NOERROR | HTML_PARSE_NOWARNING | HTML_PARSE_NONET);
ret = htmlParseChunk(parser, content, xmlStrlen(content), 0);
if (ret != 0) {
err = xmlCtxtGetLastError(parser);
fprintf(stderr, "htmlParseChunk failure: %d: %s\n", \
ret, err->message);
}
ret = htmlParseChunk(parser, NULL, 0, 1);
if (ret != 0) {
err = xmlCtxtGetLastError(parser);
fprintf(stderr, "htmlParseChunk failure 2: %d: %s\n", \
ret, err->message);
}
root = xmlDocGetRootElement(parser->myDoc);
walkTree(parser->myDoc, root, text);
return 0;
}
void calculateForce(cellptr root, double eps, real rootSize)
{
/* List of nodes to be calculate */
nodeptr * activeList;
/* List of interacting nodes */
cellptr interactionList;
/* Maximum number of active nodes */
int activeMaxCount;
/* Center of root */
vector rMid;
/* */
/* Estimate list length */
activeMaxCount = 216 * (treeDepth(root) + 1);
activeList = (nodeptr*) malloc(activeMaxCount * sizeof(nodeptr));
interactionList = (cellptr) malloc(activeMaxCount * sizeof(cell));
/* Initialize active list */
activeList[0] = (nodeptr) root;
/* Initialize center of root */
CLRV(rMid)
/* Start walking the tree */
walkTree(activeList, activeList + 1,
interactionList, interactionList + activeMaxCount,
(nodeptr) root, rootSize, rMid,
eps);
/* Cleaning up */
free(activeList);
free(interactionList);
}
void SVGTextMetricsBuilder::walkTree(RenderObject* start, RenderSVGInlineText* stopAtLeaf, MeasureTextData* data)
{
for (RenderObject* child = start->firstChild(); child; child = child->nextSibling()) {
if (child->isSVGInlineText()) {
RenderSVGInlineText* text = toRenderSVGInlineText(child);
if (stopAtLeaf && stopAtLeaf != text) {
data->processRenderer = false;
measureTextRenderer(text, data);
continue;
}
data->processRenderer = true;
measureTextRenderer(text, data);
if (stopAtLeaf)
return;
continue;
}
if (!child->isSVGInline())
continue;
walkTree(child, stopAtLeaf, data);
}
}
void
walkTree(QAbstractItemModel &model,
QModelIndex const &idx,
std::function<void(QModelIndex const &)> const &worker) {
if (!idx.isValid()) {
for (auto row = 0, numRows = model.rowCount(); row < numRows; ++row)
walkTree(model, model.index(row, 0), worker);
return;
}
worker(idx);
for (auto row = 0, numRows = model.rowCount(idx); row < numRows; ++row)
walkTree(model, model.index(row, 0, idx), worker);
}
void XMLElement::walkTree(Log::ModuleId logModule, Log::Level level,
unsigned int depth, XMLElement node) {
#ifdef PUGIXML
xml_tree_walker walker(logModule, level);
node.nodePtr.traverse(walker);
#else
while (node.isValid()) {
XMLElement::Type nodeType = node.getType();
XMLAttribute attr;
xmlChar *value;
if (XMLElement::ELEMENT_NODE == nodeType) {
if (node.nodePtr->name) {
Log::log(logModule, level, "Element = %s",
node.nodePtr->name);
} else {
Log::log(logModule, level, "Element, unnamed");
}
for (attr = node.getFirstAttribute(); attr.isValid(); attr.next()) {
attr.log(logModule, level, depth);
}
walkTree(logModule, level, depth + 1, node.getFirstSubElement());
} else if (XMLElement::CDATA_NODE == nodeType) {
value = xmlNodeGetContent(node.nodePtr);
if (value) {
Log::log(logModule, level, "CDATA = '%s'",
value);
xmlFree(value);
} else {
Log::log(logModule, level, "CDATA unable to retrieve value");
}
} else if (XMLElement::TEXT_NODE == nodeType) {
value = xmlNodeGetContent(node.nodePtr);
if (value) {
Log::log(logModule, level, "TEXT = '%s'", value);
xmlFree(value);
} else {
Log::log(logModule, level, "TEXT unable to retrieve value");
}
} else {
value = xmlNodeGetContent(node.nodePtr);
if (value) {
Log::log(logModule, level, "Type = %d, value = %s",
nodeType, value);
xmlFree(value);
} else {
Log::log(logModule, level,
"Type = %d, unable to retrieve value",
nodeType);
}
}
node.nextSibling();
}
#endif
}
void HSolvePassive::setup( Id seed, double dt )
{
clear();
dt_ = dt;
walkTree( seed );
initialize();
storeTree();
prepareSparseMatrix();
}
void HSolvePassive::setup( Id seed, double dt )
{
clear();
dt_ = dt;
walkTree( seed );
initialize();
storeTree();
HinesMatrix::setup( tree_, dt_ );
}
void XMLElement::log(Log::ModuleId logModule, Log::Level level) const {
if (Log::isLevelEnabled(logModule, level)) {
if (isValid()) {
Log::log(logModule, Log::LOG_MAX_DEBUG, "XMLElement::log() Calling walkTree().");
walkTree(logModule, level, 0, *this);
} else {
Log::log(logModule, level, "XMLElement::log() invalid element");
}
}
}
void SVGTextMetricsBuilder::measureTextLayoutObject(LayoutSVGInlineText* text)
{
ASSERT(text);
LayoutSVGText* textRoot = LayoutSVGText::locateLayoutSVGTextAncestor(text);
if (!textRoot)
return;
MeasureTextData data(0);
walkTree(textRoot, text, &data);
}
void SVGTextMetricsBuilder::measureTextRenderer(RenderSVGInlineText* text)
{
ASSERT(text);
RenderSVGText* textRoot = RenderSVGText::locateRenderSVGTextAncestor(text);
if (!textRoot)
return;
MeasureTextData data(0);
walkTree(textRoot, text, &data);
}
DependencyTable DependencyAnalysis::Analysis(std::string fileName)
{
auto parserResult = AstAnalyser::analysisFile(fileName);
DependencyTable table;
std::string currentNamespace = "";
std::function<void(ASTNode*)> walkTree;
walkTree = [&](ASTNode* node) {
for (auto detector : detectors) {
auto dep = detector->getDependency(node);
if (dep.type != "null" && dep.definition.filePath != fileName) {
dep.fromFile = fileName;
table.Push(dep);
}
}
for (auto child : node->children) {
walkTree(child);
}
};
walkTree(parserResult);
return table;
}
int walkTree(TreeNode *node, bool &isB)
{
if(!isB || !node) return 0;
if(!node->left && !node->right) return 1;
int dl = 1, dr = 1;
if(isB && node->left)
dl += walkTree(node->left, isB) ;
if(isB && node->right)
dr += walkTree(node->right, isB) ;
if(!isB) return 0;
if(dl > dr)
{
if(dl > dr +1) isB = false;
return dl;
}
else
{
if(dr > dl +1) isB = false;
return dr;
}
}
void Switcher::walkTree(QStandardItem* item_, const QString& text_){
for(int i = 0; i < item_->rowCount(); i++) {
QStandardItem* item = item_->child(i);
if(item->hasChildren())
walkTree(item, text_);
else{
bool hide = !item->text().contains(text_, Qt::CaseInsensitive);
QModelIndex index = _model->indexFromItem(item);
switcherList->setRowHidden(index.row(), index.parent(), hide);
}
}
}
//-----------------------------------------------------------------------
void BspSceneManager::_findVisibleObjects(Camera* cam,
VisibleObjectsBoundsInfo* visibleBounds, bool onlyShadowCasters)
{
// Clear unique list of movables for this frame
mMovablesForRendering.clear();
// Assemble an AAB on the fly which contains the scene elements visible
// by the camera.
CamVisibleObjectsMap::iterator findIt = mCamVisibleObjectsMap.find( cam );
// Walk the tree, tag static geometry, return camera's node (for info only)
// Movables are now added to the render queue in processVisibleLeaf
walkTree(cam, &(findIt->second), onlyShadowCasters);
}
ItemPointerData *
ginGetEntry(BuildAccumulator *accum, Datum *value, uint32 *n)
{
EntryAccumulator *entry;
ItemPointerData *list;
if (accum->stack == NULL)
{
/* first call */
accum->stack = palloc0(sizeof(EntryAccumulator *) * (accum->maxdepth + 1));
entry = accum->entries;
if (entry == NULL)
return NULL;
/* find most-left value */
for (;;)
{
accum->stack[accum->stackpos] = entry;
if (entry->left)
{
accum->stackpos++;
entry = entry->left;
}
else
break;
}
}
else
{
pfree(accum->stack[accum->stackpos]->list);
accum->stack[accum->stackpos]->list = NULL;
entry = walkTree(accum);
}
if (entry == NULL)
return NULL;
*n = entry->number;
*value = entry->value;
list = entry->list;
Assert(list != NULL);
if (entry->shouldSort && entry->number > 1)
qsort(list, *n, sizeof(ItemPointerData), qsortCompareItemPointers);
return list;
}
void ofxTimeMeasurements::collapseExpand(string sel, bool collapse){
unordered_map<ThreadId, ThreadInfo>::iterator ii;
for( ii = threadInfo.begin(); ii != threadInfo.end(); ++ii ){
core::tree<string> &tr = ii->second.tree;
core::tree<string>::iterator loc = tr.tree_find_depth(sel);
if( loc != tr.end()) {
vector<string> subTree;
walkTree(loc, 0, subTree);
for(int p = 0; p < subTree.size(); p++ ){
times[subTree[p]]->settings.visible = !collapse;
}
}
}
}
void XMLElement::walkTree(Log::ModuleId logModule, Log::Level level,
unsigned int depth, XMLElement node) {
while (node.isValid()) {
XMLElement::Type nodeType = node.getType();
XMLAttribute attr;
if (XMLElement::ELEMENT_NODE == nodeType) {
std::string name;
if (node.getName(name)) {
Log::log(logModule, level, "Element = %s",
name.c_str());
} else {
Log::log(logModule, level, "Element, unnamed");
}
for (attr = node.getFirstAttribute(); attr.isValid(); attr.next()) {
attr.log(logModule, level, depth);
}
walkTree(logModule, level, depth + 1, node.getFirstSubElement());
} else if (XMLElement::CDATA_NODE == nodeType) {
std::string value;
if (node.getValue(value)) {
Log::log(logModule, level, "CDATA = '%s'",
value.c_str());
} else {
Log::log(logModule, level, "CDATA unable to retrieve value");
}
} else if (XMLElement::TEXT_NODE == nodeType) {
std::string value;
if (node.getValue(value)) {
Log::log(logModule, level, "TEXT = '%s'",
value.c_str());
} else {
Log::log(logModule, level, "TEXT unable to retrieve value");
}
} else {
Log::log(logModule, level, "Type = %d, unknown node type",
nodeType);
}
node.nextSibling();
}
}
static void
walkTree(xmlDocPtr doc, xmlNodePtr cur, char *text)
{
xmlAttr *cur_attr = NULL;
xmlChar *content;
while (cur != NULL) {
/* text */
if (!xmlStrcmp(cur->name, (const xmlChar *)"text")) {
content = xmlNodeListGetString(doc, cur, 1);
memcpy(text, content, xmlStrlen(content));
xmlFree(content);
return;
}
walkTree(doc, cur->xmlChildrenNode, text);
cur = cur->next;
}
return;
}
/*
* walk on binary tree and returns ordered nodes
*/
static EntryAccumulator *
walkTree(BuildAccumulator *accum)
{
EntryAccumulator *entry = accum->stack[accum->stackpos];
if (entry->list != NULL)
{
/* return entry itself: we already was at left sublink */
return entry;
}
else if (entry->right && entry->right != accum->stack[accum->stackpos + 1])
{
/* go on right sublink */
accum->stackpos++;
entry = entry->right;
/* find most-left value */
for (;;)
{
accum->stack[accum->stackpos] = entry;
if (entry->left)
{
accum->stackpos++;
entry = entry->left;
}
else
break;
}
}
else
{
/* we already return all left subtree, itself and right subtree */
if (accum->stackpos == 0)
return 0;
accum->stackpos--;
return walkTree(accum);
}
return entry;
}
void Switcher::on_switcherLineEdit_textChanged(const QString& text_) {
walkTree(_model->invisibleRootItem(), text_);
}
/**
* Encodes a set of data with DC's version of huffman encoding..
* @todo Use real streams maybe? or something else than string (operator[] contains a compare, slow...)
*/
void CryptoManager::encodeHuffman(const string& is, string& os) {
// We might as well expect this much data as huffman encoding doesn't go very far...
os.reserve(is.size());
if(is.length() == 0) {
os.append("HE3\x0d");
// Nada...
os.append(7, '\0');
return;
}
// First, we count all characters
u_int8_t csum = 0;
int count[256];
memset(count, 0, sizeof(count));
int chars = countChars(is, count, csum);
// Next, we create a set of nodes and add it to a list, removing all characters that never occur.
list<Node*> nodes;
int i;
for(i=0; i<256; i++) {
if(count[i] > 0) {
nodes.push_back(new Node(i, count[i]));
}
}
nodes.sort(greaterNode());
#ifdef _DEBUG
for(list<Node*>::iterator it = nodes.begin(); it != nodes.end(); ++it) dcdebug("%.02x:%d, ", (*it)->chr, (*it)->weight);
dcdebug("\n");
#endif
walkTree(nodes);
dcassert(nodes.size() == 1);
Node* root = nodes.front();
vector<u_int8_t> lookup[256];
// Build a lookup table for fast character lookups
buildLookup(lookup, root);
delete root;
// Reserve some memory to avoid all those copies when appending...
os.reserve(is.size() * 3 / 4);
os.append("HE3\x0d");
// Checksum
os.append(1, csum);
string::size_type sz = is.size();
os.append((char*)&sz, 4);
// Character count
os.append((char*)&chars, 2);
// The characters and their bitlengths
for(i=0; i<256; i++) {
if(count[i] > 0) {
os.append(1, (u_int8_t)i);
os.append(1, (u_int8_t)lookup[i].size());
}
}
BitOutputStream bos(os);
// The tree itself, ie the bits of each character
for(i=0; i<256; i++) {
if(count[i] > 0) {
bos.put(lookup[i]);
}
}
dcdebug("u_int8_ts: %d\n", os.size());
bos.skipToByte();
for(string::size_type j=0; j<is.size(); j++) {
dcassert(lookup[(u_int8_t)is[j]].size() != 0);
bos.put(lookup[(u_int8_t)is[j]]);
}
bos.skipToByte();
}
int main(int argc, char **argv)
{
char *agentDesc = "Bucket agent";
int cmdopt;
int verbose = 0;
int ReadFromStdin = 1;
int head_uploadtree_pk = 0;
PGconn *pgConn;
PGresult *topresult;
PGresult *result;
char sqlbuf[512];
char *Delims = ",= \t\n\r";
char *token, *saveptr;
int agent_pk = 0;
int nomos_agent_pk = 0;
int bucketpool_pk = 0;
int ars_pk = 0;
int readnum = 0;
int rv;
int hasPrules;
int user_pk = 0;
char *bucketpool_name;
char *COMMIT_HASH;
char *VERSION;
char *uploadtree_tablename;
char agent_rev[myBUFSIZ];
int rerun = 0;
// int *bucketList;
pbucketdef_t bucketDefArray = 0;
pbucketdef_t tmpbucketDefArray = 0;
cacheroot_t cacheroot;
uploadtree_t uploadtree;
uploadtree.upload_fk = 0;
/* connect to the scheduler */
fo_scheduler_connect(&argc, argv, &pgConn);
user_pk = fo_scheduler_userID(); /* get user_pk for user who queued the agent */
/* command line options */
while ((cmdopt = getopt(argc, argv, "rin:p:t:u:vc:hV")) != -1)
{
switch (cmdopt)
{
case 'i': /* "Initialize" */
PQfinish(pgConn);
exit(0);
case 'n': /* bucketpool_name */
ReadFromStdin = 0;
bucketpool_name = optarg;
/* find the highest rev active bucketpool_pk */
if (!bucketpool_pk)
{
bucketpool_pk = getBucketpool_pk(pgConn, bucketpool_name);
if (!bucketpool_pk)
printf("%s is not an active bucketpool name.\n", bucketpool_name);
}
break;
case 'p': /* bucketpool_pk */
ReadFromStdin = 0;
bucketpool_pk = atoi(optarg);
/* validate bucketpool_pk */
sprintf(sqlbuf, "select bucketpool_pk from bucketpool where bucketpool_pk=%d and active='Y'", bucketpool_pk);
bucketpool_pk = validate_pk(pgConn, sqlbuf);
if (!bucketpool_pk)
printf("%d is not an active bucketpool_pk.\n", atoi(optarg));
break;
case 't': /* uploadtree_pk */
ReadFromStdin = 0;
if (uploadtree.upload_fk) break;
head_uploadtree_pk = atoi(optarg);
/* validate bucketpool_pk */
sprintf(sqlbuf, "select uploadtree_pk from uploadtree where uploadtree_pk=%d", head_uploadtree_pk);
head_uploadtree_pk = validate_pk(pgConn, sqlbuf);
if (!head_uploadtree_pk)
printf("%d is not an active uploadtree_pk.\n", atoi(optarg));
break;
case 'u': /* upload_pk */
ReadFromStdin = 0;
if (!head_uploadtree_pk)
{
uploadtree.upload_fk = atoi(optarg);
/* validate upload_pk and get uploadtree_pk */
sprintf(sqlbuf, "select upload_pk from upload where upload_pk=%d", uploadtree.upload_fk);
uploadtree.upload_fk = validate_pk(pgConn, sqlbuf);
if (!uploadtree.upload_fk)
printf("%d is not an valid upload_pk.\n", atoi(optarg));
else
{
sprintf(sqlbuf, "select uploadtree_pk from uploadtree where upload_fk=%d and parent is null", uploadtree.upload_fk);
head_uploadtree_pk = validate_pk(pgConn, sqlbuf);
}
}
break;
case 'v': /* verbose output for debugging */
verbose++;
break;
case 'c': break; /* handled by fo_scheduler_connect() */
case 'r':
rerun = 1; /** rerun bucket */
break;
case 'V': /* print version info */
printf("%s", BuildVersion);
PQfinish(pgConn);
exit(0);
default:
Usage(argv[0]);
PQfinish(pgConn);
exit(-1);
}
}
debug = verbose;
/*** validate command line ***/
if (!bucketpool_pk && !ReadFromStdin)
{
printf("FATAL: You must specify an active bucketpool.\n");
Usage(argv[0]);
exit(-1);
}
if (!head_uploadtree_pk && !ReadFromStdin)
{
printf("FATAL: You must specify a valid uploadtree_pk or upload_pk.\n");
Usage(argv[0]);
exit(-1);
}
/* get agent pk
* Note, if GetAgentKey fails, this process will exit.
*/
COMMIT_HASH = fo_sysconfig("buckets", "COMMIT_HASH");
VERSION = fo_sysconfig("buckets", "VERSION");
sprintf(agent_rev, "%s.%s", VERSION, COMMIT_HASH);
agent_pk = fo_GetAgentKey(pgConn, basename(argv[0]), uploadtree.upload_fk, agent_rev, agentDesc);
/*** Initialize the license_ref table cache ***/
/* Build the license ref cache to hold 2**11 (2048) licenses.
This MUST be a power of 2.
*/
cacheroot.maxnodes = 2<<11;
cacheroot.nodes = calloc(cacheroot.maxnodes, sizeof(cachenode_t));
if (!lrcache_init(pgConn, &cacheroot))
{
printf("FATAL: Bucket agent could not allocate license_ref table cache.\n");
exit(1);
}
/* main processing loop */
while(++readnum)
{
uploadtree.upload_fk = 0;
if (ReadFromStdin)
{
bucketpool_pk = 0;
/* Read the bucketpool_pk and upload_pk from stdin.
* Format looks like 'bppk=123, upk=987'
*/
if (!fo_scheduler_next()) break;
token = strtok_r(fo_scheduler_current(), Delims, &saveptr);
while (token && (!uploadtree.upload_fk || !bucketpool_pk))
{
if (strcmp(token, "bppk") == 0)
{
bucketpool_pk = atoi(strtok_r(NULL, Delims, &saveptr));
}
else
if (strcmp(token, "upk") == 0)
{
uploadtree.upload_fk = atoi(strtok_r(NULL, Delims, &saveptr));
}
token = strtok_r(NULL, Delims, &saveptr);
}
/* Check Permissions */
if (GetUploadPerm(pgConn, uploadtree.upload_fk, user_pk) < PERM_WRITE)
{
LOG_ERROR("You have no update permissions on upload %d", uploadtree.upload_fk);
continue;
}
/* From the upload_pk, get the head of the uploadtree, pfile_pk and ufile_name */
sprintf(sqlbuf, "select uploadtree_pk, pfile_fk, ufile_name, ufile_mode,lft,rgt from uploadtree \
where upload_fk='%d' and parent is null limit 1", uploadtree.upload_fk);
topresult = PQexec(pgConn, sqlbuf);
if (fo_checkPQresult(pgConn, topresult, sqlbuf, agentDesc, __LINE__)) return -1;
if (PQntuples(topresult) == 0)
{
printf("ERROR: %s.%s missing upload_pk %d.\nsql: %s",
__FILE__, agentDesc, uploadtree.upload_fk, sqlbuf);
PQclear(topresult);
continue;
}
head_uploadtree_pk = atol(PQgetvalue(topresult, 0, 0));
uploadtree.uploadtree_pk = head_uploadtree_pk;
uploadtree.upload_fk = uploadtree.upload_fk;
uploadtree.pfile_fk = atol(PQgetvalue(topresult, 0, 1));
uploadtree.ufile_name = strdup(PQgetvalue(topresult, 0, 2));
uploadtree.ufile_mode = atoi(PQgetvalue(topresult, 0, 3));
uploadtree.lft = atoi(PQgetvalue(topresult, 0, 4));
uploadtree.rgt = atoi(PQgetvalue(topresult, 0, 5));
PQclear(topresult);
} /* end ReadFromStdin */
else
{
/* Only one input to process if from command line, so terminate if it's been done */
if (readnum > 1) break;
/* not reading from stdin
* Get the pfile, and ufile_name for head_uploadtree_pk
*/
sprintf(sqlbuf, "select pfile_fk, ufile_name, ufile_mode,lft,rgt, upload_fk from uploadtree where uploadtree_pk=%d", head_uploadtree_pk);
topresult = PQexec(pgConn, sqlbuf);
if (fo_checkPQresult(pgConn, topresult, sqlbuf, agentDesc, __LINE__))
{
free(uploadtree.ufile_name);
return -1;
}
if (PQntuples(topresult) == 0)
{
printf("FATAL: %s.%s missing root uploadtree_pk %d\n",
__FILE__, agentDesc, head_uploadtree_pk);
PQclear(topresult);
continue;
}
uploadtree.uploadtree_pk = head_uploadtree_pk;
uploadtree.pfile_fk = atol(PQgetvalue(topresult, 0, 0));
uploadtree.ufile_name = strdup(PQgetvalue(topresult, 0, 1));
uploadtree.ufile_mode = atoi(PQgetvalue(topresult, 0, 2));
uploadtree.lft = atoi(PQgetvalue(topresult, 0, 3));
uploadtree.rgt = atoi(PQgetvalue(topresult, 0, 4));
uploadtree.upload_fk = atoi(PQgetvalue(topresult, 0, 5));
PQclear(topresult);
}
/* Find the most recent nomos data for this upload. That's what we want to use
to process the buckets.
*/
nomos_agent_pk = LatestNomosAgent(pgConn, uploadtree.upload_fk);
if (nomos_agent_pk == 0)
{
printf("WARNING: Bucket agent called on treeitem (%d), but the latest nomos agent hasn't created any license data for this tree.\n",
head_uploadtree_pk);
continue;
}
/* at this point we know:
* bucketpool_pk, bucket agent_pk, nomos agent_pk, upload_pk,
* pfile_pk, and head_uploadtree_pk (the uploadtree_pk of the head tree to scan)
*/
/* Has the upload already been processed? If so, we are done.
Don't even bother to create a bucket_ars entry.
*/
switch (UploadProcessed(pgConn, agent_pk, nomos_agent_pk, uploadtree.pfile_fk, head_uploadtree_pk, uploadtree.upload_fk, bucketpool_pk))
{
case 1: /* upload has already been processed */
if (1 == rerun) break;
printf("LOG: Duplicate request for bucket agent to process upload_pk: %d, uploadtree_pk: %d, bucketpool_pk: %d, bucket agent_pk: %d, nomos agent_pk: %d, pfile_pk: %d ignored.\n",
uploadtree.upload_fk, head_uploadtree_pk, bucketpool_pk, agent_pk, nomos_agent_pk, uploadtree.pfile_fk);
continue;
case -1: /* SQL error, UploadProcessed() wrote error message */
continue;
case 0: /* upload has not been processed */
break;
}
/*** Initialize the Bucket Definition List bucketDefArray ***/
bucketDefArray = initBuckets(pgConn, bucketpool_pk, &cacheroot);
if (bucketDefArray == 0)
{
printf("FATAL: %s.%d Bucket definition for pool %d could not be initialized.\n",
__FILE__, __LINE__, bucketpool_pk);
exit(-2);
}
bucketDefArray->nomos_agent_pk = nomos_agent_pk;
bucketDefArray->bucket_agent_pk = agent_pk;
/* Find the correct uploadtree table name */
uploadtree_tablename = GetUploadtreeTableName(pgConn, uploadtree.upload_fk);
if (!(uploadtree_tablename))
{
LOG_FATAL("buckets passed invalid upload, upload_pk = %d", uploadtree.upload_fk);
return(-110);
}
/* set uploadtree_tablename in all the bucket definition structs */
for (tmpbucketDefArray = bucketDefArray; tmpbucketDefArray->bucket_pk; tmpbucketDefArray++)
{
tmpbucketDefArray->uploadtree_tablename = uploadtree_tablename;
}
/* loop through rules (bucket defs) to see if there are any package only rules */
hasPrules = 0;
for (tmpbucketDefArray = bucketDefArray; tmpbucketDefArray->bucket_pk; tmpbucketDefArray++)
if (tmpbucketDefArray->applies_to == 'p')
{
hasPrules = 1;
break;
}
/*** END initializing bucketDefArray ***/
/*** Initialize DEB_SOURCE and DEB_BINARY ***/
sprintf(sqlbuf, "select mimetype_pk from mimetype where mimetype_name='application/x-debian-package'");
result = PQexec(pgConn, sqlbuf);
if (fo_checkPQresult(pgConn, result, sqlbuf, __FILE__, __LINE__)) return -1;
if (PQntuples(result) == 0)
{
printf("FATAL: (%s.%d) Missing application/x-debian-package mimetype.\n",__FILE__,__LINE__);
return -1;
}
DEB_BINARY = atoi(PQgetvalue(result, 0, 0));
PQclear(result);
sprintf(sqlbuf, "select mimetype_pk from mimetype where mimetype_name='application/x-debian-source'");
result = PQexec(pgConn, sqlbuf);
if (fo_checkPQresult(pgConn, result, sqlbuf, __FILE__, __LINE__)) return -1;
if (PQntuples(result) == 0)
{
printf("FATAL: (%s.%d) Missing application/x-debian-source mimetype.\n",__FILE__,__LINE__);
return -1;
}
DEB_SOURCE = atoi(PQgetvalue(result, 0, 0));
PQclear(result);
/*** END Initialize DEB_SOURCE and DEB_BINARY ***/
/*** Record analysis start in bucket_ars, the bucket audit trail. ***/
if (0 == rerun) { // do not have any bucket scan on this upload
snprintf(sqlbuf, sizeof(sqlbuf),
"insert into bucket_ars (agent_fk, upload_fk, ars_success, nomosagent_fk, bucketpool_fk) values(%d,%d,'%s',%d,%d)",
agent_pk, uploadtree.upload_fk, "false", nomos_agent_pk, bucketpool_pk);
if (debug)
printf("%s(%d): %s\n", __FILE__, __LINE__, sqlbuf);
result = PQexec(pgConn, sqlbuf);
if (fo_checkPQcommand(pgConn, result, sqlbuf, __FILE__ ,__LINE__)) return -1;
PQclear(result);
/* retrieve the ars_pk of the newly inserted record */
sprintf(sqlbuf, "select ars_pk from bucket_ars where agent_fk='%d' and upload_fk='%d' and ars_success='%s' and nomosagent_fk='%d' \
and bucketpool_fk='%d' and ars_endtime is null \
order by ars_starttime desc limit 1",
agent_pk, uploadtree.upload_fk, "false", nomos_agent_pk, bucketpool_pk);
result = PQexec(pgConn, sqlbuf);
if (fo_checkPQresult(pgConn, result, sqlbuf, __FILE__, __LINE__)) return -1;
if (PQntuples(result) == 0)
{
printf("FATAL: (%s.%d) Missing bucket_ars record.\n%s\n",__FILE__,__LINE__,sqlbuf);
return -1;
}
ars_pk = atol(PQgetvalue(result, 0, 0));
PQclear(result);
}
/*** END bucket_ars insert ***/
if (debug) printf("%s sql: %s\n",__FILE__, sqlbuf);
/* process the tree for buckets
Do this as a single transaction, therefore this agent must be
run as a single thread. This will prevent the scheduler from
consuming excess time (this is a fast agent), and allow this
process to update bucket_ars.
*/
rv = walkTree(pgConn, bucketDefArray, agent_pk, head_uploadtree_pk, 0,
hasPrules);
/* if no errors and top level is a container, process the container */
if ((!rv) && (IsContainer(uploadtree.ufile_mode)))
{
rv = processFile(pgConn, bucketDefArray, &uploadtree, agent_pk, hasPrules);
}
/* Record analysis end in bucket_ars, the bucket audit trail. */
if (0 == rerun && ars_pk)
{
if (rv)
snprintf(sqlbuf, sizeof(sqlbuf),
"update bucket_ars set ars_endtime=now(), ars_success=false where ars_pk='%d'",
ars_pk);
else
snprintf(sqlbuf, sizeof(sqlbuf),
"update bucket_ars set ars_endtime=now(), ars_success=true where ars_pk='%d'",
ars_pk);
if (debug)
printf("%s(%d): %s\n", __FILE__, __LINE__, sqlbuf);
result = PQexec(pgConn, sqlbuf);
if (fo_checkPQcommand(pgConn, result, sqlbuf, __FILE__ ,__LINE__)) return -1;
PQclear(result);
}
} /* end of main processing loop */
void SVGTextMetricsBuilder::buildMetricsAndLayoutAttributes(RenderSVGText* textRoot, RenderSVGInlineText* stopAtLeaf, SVGCharacterDataMap& allCharactersMap)
{
ASSERT(textRoot);
MeasureTextData data(&allCharactersMap);
walkTree(textRoot, stopAtLeaf, &data);
}
