MyXmlTag *MyXmlDoc::getTagByName(QString name)
{
MyXmlTag *tag=NULL;
qint32 level, index;
QString subnode;
if(!m_root) return tag;
level=0;
while(1)
{
subnode=extractNode(name,level,index);
if(subnode=="") break;
if(tag) tag=tag->getChild(); else tag=m_root;
while(1)
{
if(tag->getName()==subnode) index--;
if(index<0) break;
if(tag->getNext())
tag=tag->getNext();
else
return NULL;
}
level++;
}
return tag;
}
TreeNode * extractNode(string & s){
if(s.length()==0) return NULL;
size_t comma_pos = s.find_first_of(",");
if(comma_pos==string::npos) {
// the only node
if(s == "#") return NULL; // mistake: [1] => 1,#,#
return new TreeNode(stoi(s));
}
string cur = s.substr(0, comma_pos);
s = s.substr(comma_pos+1);
if(cur == "#") return NULL;
TreeNode * root = new TreeNode(stoi(cur));
root->left = extractNode(s);
root->right = extractNode(s);
return root;
}
// my_response is used to handle a reply
static enum ccn_upcall_res
my_response(struct ccn_closure *selfp,
enum ccn_upcall_kind kind,
struct ccn_upcall_info *info) {
static char *here = "sync_track.my_response";
enum ccn_upcall_res ret = CCN_UPCALL_RESULT_ERR;
switch (kind) {
case CCN_UPCALL_FINAL:
free(selfp);
ret = CCN_UPCALL_RESULT_OK;
break;
case CCN_UPCALL_CONTENT_UNVERIFIED:
ret = CCN_UPCALL_RESULT_VERIFY;
break;
case CCN_UPCALL_CONTENT_KEYMISSING:
ret = CCN_UPCALL_RESULT_FETCHKEY;
break;
case CCN_UPCALL_INTEREST_TIMED_OUT: {
struct sync_diff_fetch_data *fd = selfp->data;
//enum local_flags flags = selfp->intdata;
if (fd == NULL) break;
struct sync_diff_data *diff_data = fd->diff_data;
if (diff_data == NULL) break;
struct ccns_handle *ch = diff_data->client_data;
free_fetch_data(ch, fd);
start_round(ch, 10);
ret = CCN_UPCALL_RESULT_OK;
break;
}
case CCN_UPCALL_CONTENT_RAW:
case CCN_UPCALL_CONTENT: {
struct sync_diff_fetch_data *fd = selfp->data;
enum local_flags flags = selfp->intdata;
if (fd == NULL) break;
struct sync_diff_data *diff_data = fd->diff_data;
if (diff_data == NULL) break;
struct SyncRootStruct *root = diff_data->root;
if (root == NULL) break;
struct ccns_handle *ch = diff_data->client_data;
struct SyncNodeComposite *nc = extractNode(root, info);
if (ch->debug >= CCNL_FINE) {
char fs[1024];
int pos = 0;
switch (flags) {
case LF_NULL:
pos += snprintf(fs+pos, sizeof(fs)-pos, "null");
break;
case LF_ADVISE:
pos += snprintf(fs+pos, sizeof(fs)-pos, "advise");
break;
case LF_NODE:
pos += snprintf(fs+pos, sizeof(fs)-pos, "node");
break;
default:
pos += snprintf(fs+pos, sizeof(fs)-pos, "??%d", flags);
break;
}
if (nc != NULL)
pos += snprintf(fs+pos, sizeof(fs)-pos, ", nc OK");
struct ccn_charbuf *nm = SyncNameForIndexbuf(info->content_ccnb,
info->content_comps);
struct ccn_charbuf *uri = SyncUriForName(nm);
pos += snprintf(fs+pos, sizeof(fs)-pos, ", %s", ccn_charbuf_as_string(uri));
SyncNoteSimple(diff_data->root, here, fs);
ccn_charbuf_destroy(&nm);
ccn_charbuf_destroy(&uri);
}
if (nc != NULL) {
// the node exists, so store it
// TBD: check the hash?
struct ccns_handle *ch = diff_data->client_data;
struct SyncHashCacheEntry *ce = SyncHashEnter(root->ch,
nc->hash->buf, nc->hash->length,
SyncHashState_remote);
if (flags == LF_ADVISE) {
ch->hashSeen = SyncNoteHash(ch->hashSeen, ce);
if (ch->next_ce == NULL)
// have to have an initial place to start
ch->next_ce = ce;
}
if (ce->ncR == NULL) {
// store the node
ce->ncR = nc;
SyncNodeIncRC(nc);
} else {
// flush the node
SyncNodeDecRC(nc);
nc = NULL;
}
if (flags != LF_NULL) {
// from start_interest
start_round(ch, 10);
} else {
// from sync_diff
sync_diff_note_node(diff_data, ce);
}
ret = CCN_UPCALL_RESULT_OK;
}
free_fetch_data(ch, fd);
break;
default:
// SHOULD NOT HAPPEN
break;
}
}
return ret;
}
// Decodes your encoded data to tree.
TreeNode* deserialize(string data) {
return extractNode(data);
}
void SortedList<T, Pred>::moveNode(typename SortedList<T, Pred>::Node* to_move, typename SortedList<T, Pred>::Node* destination)
{
insertAfterNode(extractNode(to_move), destination);
}
