MathTree* clone_tree(MathTree* orig)
{
MathTree* clone = new_tree(orig->num_levels, orig->num_constants);
// Clone the constants into the new tree.
for (int c=0; c < orig->num_constants; ++c) {
clone->constants[c] = clone_node(orig->constants[c]);
}
// Then clone all of the nodes into the new tree:
// Iterate over levels
for (int level=0; level < orig->num_levels; ++level) {
int active = orig->active[level];
clone->active[level] = active;
if (active) {
clone->nodes[level] = malloc(sizeof(Node*)*active);
} else {
clone->nodes[level] = NULL;
}
// Clone each node in this level and opcode.
for (int n=0; n < active; ++n) {
Node* clone_ = clone_node(orig->nodes[level][n]);
clone->nodes[level][n] = clone_;
}
}
clone->head = orig->head->clone_address;
return clone;
}
static off_t n_set_right(brtr_t *b, off_t r, off_t ptr)
/* sets right branch and balances node, creating new ones */
{
off_t nr;
struct brtr_node *n, *m;
n = brtr_node(b, r);
m = brtr_node(b, ptr);
if (m && m->c > (n->c / 2) + 1) {
off_t nrr;
/* do the rotation */
nrr = clone_node(b, n, n->left, m->left);
nr = clone_node(b, m, nrr, m->right);
brtr_free(b, ptr);
}
else {
nr = clone_node(b, n, n->left, ptr);
}
brtr_free(b, r);
return nr;
}
static tst_node*
clone_node(tst_node* p, Alloc* alloc)
{
if (p)
{
tst_node* clone = alloc->new_node(p->id);
if (p->data)
clone->data = alloc->new_data(*p->data);
clone->lt = clone_node(p->lt, alloc);
clone->eq = clone_node(p->eq, alloc);
clone->gt = clone_node(p->gt, alloc);
return clone;
}
return 0;
}
UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) {
if (node == NULL) return NULL;
UndirectedGraphNode *cn = NULL;
unordered_map<int, UndirectedGraphNode*> um;
clone_node(node, cn, um);
return cn;
}
void clone_node(UndirectedGraphNode *&p, UndirectedGraphNode *&q, unordered_map<int, UndirectedGraphNode*> &um) {
q = new UndirectedGraphNode(p->label);
um[p->label] = q;
for (int i = 0; i < p->neighbors.size(); i++) {
int label = p->neighbors[i]->label;
if (um.find(label) != um.end()) {
q->neighbors.push_back(um[label]);
} else {
UndirectedGraphNode *cn;
clone_node(p->neighbors[i], cn, um);
q->neighbors.push_back(cn);
}
}
}
hubbub_error clone_node(void *ctx, void *node, bool deep, void **result)
{
node_t *old_node = node;
node_t *new_node = calloc(1, sizeof *new_node);
node_t *last;
node_t *child;
size_t i;
new_node->type = old_node->type;
switch (old_node->type) {
case DOCTYPE:
new_node->data.doctype.name =
strdup(old_node->data.doctype.name);
if (old_node->data.doctype.public_id)
new_node->data.doctype.public_id =
strdup(old_node->data.doctype.public_id);
if (old_node->data.doctype.system_id)
new_node->data.doctype.system_id =
strdup(old_node->data.doctype.system_id);
break;
case COMMENT:
case CHARACTER:
new_node->data.content = strdup(old_node->data.content);
break;
case ELEMENT:
new_node->data.element.ns = old_node->data.element.ns;
new_node->data.element.name =
strdup(old_node->data.element.name);
new_node->data.element.attrs =
calloc(old_node->data.element.n_attrs,
sizeof *new_node->data.element.attrs);
for (i = 0; i < old_node->data.element.n_attrs; i++) {
attr_t *attr = &new_node->data.element.attrs[i];
attr->ns = old_node->data.element.attrs[i].ns;
attr->name =
strdup(old_node->data.element.attrs[i].name);
attr->value =
strdup(old_node->data.element.attrs[i].value);
}
new_node->data.element.n_attrs = old_node->data.element.n_attrs;
break;
}
*result = new_node;
new_node->child = new_node->parent =
new_node->next = new_node->prev =
NULL;
new_node->refcnt = 1;
if (deep == false)
return 0;
last = NULL;
for (child = old_node->child; child != NULL;
child = child->next) {
node_t *n;
clone_node(ctx, child, true, (void **) (void *) &n);
n->refcnt = 0;
if (last == NULL) {
new_node->child = n;
} else {
last->next = n;
n->prev = last;
}
n->parent = new_node;
last = n;
}
return HUBBUB_OK;
}
