TreeNode * bt_create(int * nodes, int count, int start = 0, int sep = '#') {
// Handle the special cases.
if ((0 == count) || (start >= count)) {
return NULL;
}
// If the current node indicates an empty tree, then just return NULL.
if (nodes[start] == sep) {
return NULL;
}
// Otherwise, there is at least one node in nodes.
// Create the root node.
TreeNode * root = new TreeNode(nodes[start]);
// Create the left subtree, if existing.
TreeNode * left_subtree = bt_create(nodes, count, 2*start+1);
// Create the right subtree, if existing.
TreeNode * right_subtree = bt_create(nodes, count, 2*start+2);
// Link the nodes.
root->left = left_subtree;
root->right = right_subtree;
if (left_subtree != NULL) left_subtree->parent = root;
if (right_subtree != NULL) right_subtree->parent = root;
return root;
}
void initialize_masterblock()
{
elog(EL_LOG, ("Initializing catalog masterdata block"));
for (int i = 0; i < catobj_count; i++) {
local_catalog->masterdata.trees[i] = bt_create(xs_string);
}
local_catalog->masterdata.htable = XNULL;
vmm_alloc_data_block(&(catalog_masterblock));
WRITEP(catalog_masterblock);
memcpy(
&(((catalog_master_record *) XADDR(catalog_masterblock))->masterdata),
&(local_catalog->masterdata),
sizeof(catalog_name_trees));
memset(
((catalog_master_record *) XADDR(catalog_masterblock))->last_nid,
0, MAX_ROOT_NID_SIZE);
memset(
&(((catalog_master_record *) XADDR(catalog_masterblock))->last_nid_size),
0, sizeof(int));
cs_initp();
}
BinTree bt_dup(BinTree bt, DupFuncPtr dupfunc)
{
BinTree result;
bt_node *oldnode;
ErrPushFunc("bt_dup");
result = bt_create(bt->compare);
/* Save previoulsy current */
oldnode = bt->current_node;
/* Duplicate nodes */
bt_GoFirst(bt);
while(!bt_EOT(bt))
{
bt_add(result, (dupfunc==NULL) ? bt_GetCur(bt) : dupfunc(bt_GetCur(bt)));
bt_GoNext(bt);
}
/* restore previously current */
bt->current_node = oldnode;
result->count = bt->count;
ErrPopFunc();
return(result);
}
// -----------------------------------------------------------------------------
//virtual
bool Solution::Test()
{
bool pass = true;
{
int nodes[] = { };
BTNode<int> * root = bt_create(nodes, sizeof(nodes) / sizeof(int));
root = invertTree(root);
std::vector<int> v;
bt_traverse(root, BT_TRAV_IN, v);
pass = pass && v.empty();
bt_delete(root);
}
{
int nodes[] = { '1' };
BTNode<int> * root = bt_create(nodes, sizeof(nodes) / sizeof(int));
root = invertTree(root);
std::vector<int> v;
bt_traverse(root, BT_TRAV_IN, v);
pass = pass && (v.size() == 1) && (v[0] == '1');
bt_delete(root);
}
{
int nodes[] = { '1', '2' };
BTNode<int> * root = bt_create(nodes, sizeof(nodes) / sizeof(int));
root = invertTree(root);
std::vector<int> v;
bt_traverse(root, BT_TRAV_IN, v);
pass = pass && (v.size() == 2) && (v[0] == '1') && (v[1] == '2');
bt_delete(root);
}
{
int nodes[] = { '1', '2', '3' };
BTNode<int> * root = bt_create(nodes, sizeof(nodes) / sizeof(int));
root = invertTree(root);
std::vector<int> v;
bt_traverse(root, BT_TRAV_IN, v);
pass = pass && (v.size() == 3) && (v[0] == '3') && (v[1] == '1') && (v[2] == '2');
bt_delete(root);
}
return pass;
}
/*************************************************************************
* FUNCTION
* custom_bt_create
*
* DESCRIPTION
* Customize BT task create function.
* Return KAL_FALSE directly if BT task should not be created.
*
* PARAMETERS
*
* RETURNS
*
* GLOBALS AFFECTED
*
*************************************************************************/
kal_bool custom_bt_create(comptask_handler_struct **handle)
{
#if defined(__BTMTK__)
return bt_create(handle);
#else /* __BTMTK__ */
return KAL_FALSE;
#endif /* __BTMTK__ */
}
BTree* bt_insert (BTree* a, int x) {
insert(a,x);
if(overflow(a)) {
int m;
BTree* b = split(a,&m);
BTree* r = bt_create(a->ordem); r->k[0] = m;
r->p[0] = a;
r->p[1] = b;
r->n = 1;
return r;
}
return a;
}
// -----------------------------------------------------------------------------
//virtual
bool Solution::Test()
{
bool pass = true;
{
int nodes[] = { };
BTNode<int> * root = bt_create(nodes, sizeof(nodes) / sizeof(int));
std::vector< std::vector<int> > result = levelOrderBottom(root);
pass = pass && result.empty();
bt_delete(root);
}
{
int nodes[] = { 1 };
BTNode<int> * root = bt_create(nodes, sizeof(nodes) / sizeof(int));
std::vector< std::vector<int> > result = levelOrderBottom(root);
pass = pass && (result.size() == 1) &&
(result[0].size() == 1) && (result[0][0] == 1)
;
bt_delete(root);
}
{
int nodes[] = { 3, 9, 20, '#', '#', 15, 7 };
BTNode<int> * root = bt_create(nodes, sizeof(nodes) / sizeof(int));
std::vector< std::vector<int> > v = levelOrderBottom(root);
pass = pass && (v.size() == 3) &&
(v[0].size() == 2) && (v[0][0] == 15) && (v[0][1] == 7) &&
(v[1].size() == 2) && (v[1][0] == 9) && (v[1][1] == 20) &&
(v[2].size() == 1) && (v[2][0] == 3)
;
bt_delete(root);
}
return pass;
}
int main(int argc, char * argv[]) {
bool pass = true;
{
const int N = 15;
int nodes[] = { 15, 6, 18, 3, 7, 17, 20, 2, 4, '#', 13, '#', '#', '#', '#' };
TreeNode * root = bt_create(nodes, N, 0, '#');
TreeNode * node15 = root;
pass = pass && (bst_find_successor(node15)->value == 17);
TreeNode * node13 = root->left->right->right;
pass = pass && (bst_find_successor(node13)->value == 15);
TreeNode * node20 = root->right->right;
pass = pass && (bst_find_successor(node20) == NULL);
bt_delete(root);
}
return (pass ? 0 : -1);
}
static BTree* split (BTree* a, int* m) {
int i;
BTree* b = bt_create(a->ordem);
int q;
if(a->ordem%2 == 0)
q = (a->n/2)-1;
else
q = a->n/2;
b->n = a->n - q - 1;
a->n = q;
*m = a->k[q];
b->p[0] = a->p[q+1];
for (i=0; i < b->n; ++i) {
b -> k[i] = a->k[q + 1 + i] ;
b->p[i+1] = a->p[q+1+i+1];
}
return b;
}
// -----------------------------------------------------------------------------
//virtual
bool Solution::Test()
{
bool pass = true;
{
int nodes[] = {};
BTNode<int> * p = bt_create(nodes, sizeof(nodes) / sizeof(int));
BTNode<int> * q = bt_create(nodes, sizeof(nodes) / sizeof(int));
pass = pass && isSameTree(p, q);
bt_delete(p);
bt_delete(q);
}
{
int nodes[] = {1};
BTNode<int> * p = bt_create(nodes, sizeof(nodes) / sizeof(int));
BTNode<int> * q = bt_create(nodes, sizeof(nodes) / sizeof(int));
pass = pass && isSameTree(p, q);
bt_delete(p);
bt_delete(q);
}
{
int nodes[] = {1, 2, 3};
BTNode<int> * p = bt_create(nodes, sizeof(nodes) / sizeof(int));
BTNode<int> * q = bt_create(nodes, sizeof(nodes) / sizeof(int));
pass = pass && isSameTree(p, q);
bt_delete(p);
bt_delete(q);
}
{
int nodes[] = { '1', '2', '3', '#', '#', '4', '#', '#', '#', '#', '#', '#', '5' };
BTNode<int> * p = bt_create(nodes, sizeof(nodes) / sizeof(int));
BTNode<int> * q = bt_create(nodes, sizeof(nodes) / sizeof(int));
pass = pass && isSameTree(p, q);
bt_delete(p);
bt_delete(q);
}
{
int nodes[] = { '1', '2', '3', '#', '#', '4', '#', '#', '#', '#', '#', '#', '5' };
BTNode<int> * p = bt_create(nodes, sizeof(nodes) / sizeof(int));
BTNode<int> * q = p;
pass = pass && isSameTree(p, q);
bt_delete(p);
}
{
int nodes1[] = { '1', '2', '3', '#', '#', '4', '#', '#', '#', '#', '#', '#', '5' };
int nodes2[] = { '1', '2', '3', '#', '#', '4', '#', '#', '#', '#', '#', '5', '#' };
BTNode<int> * p = bt_create(nodes1, sizeof(nodes1) / sizeof(int));
BTNode<int> * q = bt_create(nodes2, sizeof(nodes2) / sizeof(int));
pass = pass && !isSameTree(p, q);
bt_delete(p);
bt_delete(q);
}
{
int nodes1[] = { '1', '2', '3', '#', '#', '4', '#', '#', '#', '#', '#', '#', '5' };
int nodes2[] = { '1', '2', '3', '#', '#', '4', '#', '#', '#', '#', '#', '#', '6' };
BTNode<int> * p = bt_create(nodes1, sizeof(nodes1) / sizeof(int));
BTNode<int> * q = bt_create(nodes2, sizeof(nodes2) / sizeof(int));
pass = pass && !isSameTree(p, q);
bt_delete(p);
bt_delete(q);
}
return pass;
}
int
cdx_calcfiltlist(ClipMachine * ClipMachineMemory, RDD_DATA * rd, RDD_ORDER * ro, RDD_FILTER * fp, const char *__PROC__)
{
int i, er;
BTREE *bt;
void *key = malloc(sizeof(unsigned int) + ro->bufsize);
ClipVar vv, *vp;
if (fp->list)
{
bt = bt_create(0, fp->listlen, sizeof(unsigned int) + ro->bufsize, _cdx_compare);
for (i = 0; i < fp->listlen; i++)
{
if ((er = rd->vtbl->rawgo(ClipMachineMemory, rd, fp->list[i], 0, __PROC__)))
return er;
if (ro->simpexpr)
{
if ((er = rd->vtbl->getvalue(ClipMachineMemory, rd, ro->simpfno, &vv, __PROC__)))
return er;
vp = &vv;
}
else
{
if ((er = rdd_calc(ClipMachineMemory, rd->area, &ro->block, &vv, 0)))
return er;
vp = _clip_vptr(&vv);
}
memcpy(key, &rd->recno, sizeof(unsigned int));
if ((er = cdx_formatkey(ClipMachineMemory, ro, vp, key + sizeof(unsigned int), __PROC__)))
return er;
_clip_destroy(ClipMachineMemory, &vv);
bt_add(bt, ro, key);
}
free(fp->list);
}
else
{
#if 1
unsigned int bytes = ((fp->size + 1) >> 5) + 1;
int i, b, bb, t, tt;
fp->listlen = 0;
for (i = 0; i < bytes; i++)
{
if (fp->rmap[i])
{
for (b = (i << 2), bb = 0; bb < 4; b++, bb++)
{
if (((char *) fp->rmap)[b])
{
for (t = (b << 3) + 1, tt = 0; tt < 8; t++, tt++)
{
if (_rm_getbit(fp->rmap, fp->size, t))
fp->listlen++;
}
}
}
}
}
if (fp->listlen > 100)
{
free(key);
return 0;
}
#else
fp->listlen = 0;
for (i = 1; i <= fp->size; i++)
if (_rm_getbit(fp->rmap, fp->size, i))
fp->listlen++;
#endif
bt = bt_create(0, fp->listlen, sizeof(unsigned int) + ro->bufsize, _cdx_compare);
#if 1
for (i = 0; i < bytes; i++)
{
if (fp->rmap[i])
{
for (b = (i << 2), bb = 0; bb < 4; b++, bb++)
{
if (((char *) fp->rmap)[b])
{
for (t = (b << 3) + 1, tt = 0; tt < 8; t++, tt++)
{
if (_rm_getbit(fp->rmap, fp->size, t))
{
if ((er = rd->vtbl->rawgo(ClipMachineMemory, rd, t, 0, __PROC__)))
return er;
if (ro->simpexpr)
{
if ((er = rd->vtbl->getvalue(ClipMachineMemory, rd, ro->simpfno, &vv, __PROC__)))
return er;
vp = &vv;
}
else
{
if ((er = rdd_calc(ClipMachineMemory, rd->area, &ro->block, &vv, 0)))
return er;
vp = _clip_vptr(&vv);
}
memcpy(key, &rd->recno, sizeof(unsigned int));
if ((er = cdx_formatkey(ClipMachineMemory, ro, vp, key + sizeof(unsigned int), __PROC__)))
return er;
_clip_destroy(ClipMachineMemory, &vv);
bt_add(bt, ro, key);
}
}
}
}
}
}
#else
for (i = 1; i <= fp->size; i++)
{
if (_rm_getbit(fp->rmap, fp->size, i))
{
if ((er = rd->vtbl->rawgo(ClipMachineMemory, rd, i, 0, __PROC__)))
return er;
if (ro->simpexpr)
{
if ((er = rd->vtbl->getvalue(ClipMachineMemory, rd, ro->simpfno, &vv, __PROC__)))
return er;
vp = &vv;
}
else
{
if ((er = rdd_calc(ClipMachineMemory, rd->area, &ro->block, &vv, 0)))
return er;
vp = _clip_vptr(&vv);
}
memcpy(key, &rd->recno, sizeof(unsigned int));
if ((er = cdx_formatkey(ClipMachineMemory, ro, vp, key + sizeof(unsigned int), __PROC__)))
return er;
_clip_destroy(ClipMachineMemory, &vv);
bt_add(bt, ro, key);
}
}
#endif
}
fp->list = malloc(sizeof(unsigned int) * (fp->listlen + 1));
if (!ro->descend)
{
bt_first(bt);
if (bt_key(bt))
{
i = 0;
fp->list[i] = *(unsigned int *) bt_key(bt);
while (!bt_next(bt))
{
i++;
fp->list[i] = *(unsigned int *) bt_key(bt);
}
}
}
else
{
bt_last(bt);
if (bt_key(bt))
{
i = 0;
fp->list[i] = *(unsigned int *) bt_key(bt);
while (!bt_prev(bt))
{
i++;
fp->list[i] = *(unsigned int *) bt_key(bt);
}
}
}
bt_destroy(bt);
free(key);
return 0;
}
void catalog_before_commit(bool is_commit)
{
/*
* Final journal commit. Done by single transaction at a time
*/
if (!is_commit) { return; }
try {
catalog_journal_record *r;
xptr *tree;
bt_key name;
char * htname;
catalog_validate_objects();
catalog_lock_metadata();
cs_initp();
r = local_catalog->catalog_journal;
while (r != NULL) {
switch (r->type) {
case catalog_journal_record::add_name:
tree = &(CATALOG_NAME_TREE(r->nor.object_type));
name.setnew(r->nor.name_to_save->name);
if (*tree == XNULL) { *tree = bt_create(xs_string); }
bt_insert(*tree, name, r->nor.name_to_save->obj->p);
break;
case catalog_journal_record::del_name:
tree = &(CATALOG_NAME_TREE(r->nor.object_type));
name.setnew(r->nor.name_to_save->name);
bt_delete(*tree, name, r->nor.name_to_save->obj->p);
htname = catalog_ht_fullname_string(r->nor.object_type, r->nor.name_to_save->name, NULL);
local_catalog->masterdata.htable = sbtrie_delete_str(local_catalog->masterdata.htable, htname);
free(htname);
break;
case catalog_journal_record::add_htable_record:
local_catalog->masterdata.htable = sbtrie_insert_str(local_catalog->masterdata.htable, r->htr.name, r->htr.data, strlen(r->htr.data) + 2, true);
break;
}
r = r->next;
local_catalog->masterdata_updated = true;
}
local_catalog->catalog_journal = NULL;
if (local_catalog->masterdata_updated) {
WRITEP(catalog_masterblock);
memcpy(
&(((catalog_master_record *) XADDR(catalog_masterblock))->masterdata),
&(local_catalog->masterdata),
sizeof(catalog_name_trees));
local_catalog->masterdata_updated = false;
}
if (!tr_globals::is_ro_mode) {
WRITEP(catalog_masterblock);
memcpy(
&(((catalog_master_record *) XADDR(catalog_masterblock))->last_nid_size),
&last_nid_size,
sizeof(int));
memcpy(
((catalog_master_record *) XADDR(catalog_masterblock))->last_nid,
last_nid,
last_nid_size);
}
} catch (ANY_SE_EXCEPTION) {
catalog_unlock_metadata();
throw;
}
}
