예제 #1
0
파일: bonsai.c 프로젝트: cfrantz/pongo
static dbtype_t
_bonsai_multi_delete(pgctx_t *ctx, dbtype_t node, dbtype_t key, dbtype_t *value)
{
    dbval_t *np = dbptr(ctx, node);
    dbtype_t min, left, right;
    int cmp;
    int i;

    if (!node.all) {
        value->type = Error;
        return DBNULL;
    }

    left = np->left;
    right = np->right;
    cmp = dbcmp(ctx, key, np->key);
    if (cmp < 0) {
        return balance(ctx, node, _bonsai_delete(ctx, left, key, value), right, subtree_left, 1);
    }
    if (cmp > 0) {
        return balance(ctx, node, left, _bonsai_delete(ctx, right, key, value), subtree_right, 1);
    }

    if (np->nvalue == 1) {
        if (dbcmp(ctx, *value, np->values[0])!=0) {
            value->type = Error;
            return node;
        }
        if (!left.all) return right;
        if (!right.all) return left;
        right = delete_min(ctx, right, &min);
        rcuwinner(node, 0xe9);
        return balance(ctx, min, left, right, subtree_right, 0);
    }

    node = bonsai_copy(ctx, left, right, node);
    np = dbptr(ctx, node);
    for(i=0; i<np->nvalue; i++) {
        if (dbcmp(ctx, *value, np->values[i])==0) {
            memcpy(np->values+i, np->values+i+1, (np->nvalue-i-1)*sizeof(dbtype_t));
            break;
        }
    }
    if (i == np->nvalue) {
        value->type = Error;
    } else {
        np->nvalue--;
    }
    return node;
}
예제 #2
0
파일: bonsai.c 프로젝트: cfrantz/pongo
static dbtype_t
_bonsai_delete(pgctx_t *ctx, dbtype_t node, dbtype_t key, dbtype_t *valout)
{
    dbval_t *np = dbptr(ctx, node);
    dbtype_t min, left, right;
    int cmp;

    if (!node.all) {
        if (valout) valout->type = Error;
        return DBNULL;
    }

    left = np->left;
    right = np->right;
    cmp = dbcmp(ctx, key, np->key);
    if (cmp < 0) {
        return balance(ctx, node, _bonsai_delete(ctx, left, key, valout), right, subtree_left, 1);
    }
    if (cmp > 0) {
        return balance(ctx, node, left, _bonsai_delete(ctx, right, key, valout), subtree_right, 1);
    }

    if (valout) *valout = np->value;
    rcuwinner(node, 0xe9);

    if (!left.all) return right;
    if (!right.all) return left;
    right = delete_min(ctx, right, &min);
    return balance(ctx, min, left, right, subtree_right, 0);
}
예제 #3
0
파일: bonsai.c 프로젝트: cfrantz/pongo
dbtype_t
bonsai_insert(pgctx_t *ctx, dbtype_t node, dbtype_t key, dbtype_t value, int insert_or_fail)
{
    int cmp;
    dbval_t *np;
    if (!node.all) {
        return bonsai_new(ctx, DBNULL, DBNULL, key, value);
    }

    np = dbptr(ctx, node);
    cmp = dbcmp(ctx, key, np->key);
    if (insert_or_fail && cmp==0) {
        node.type = Error;
        return node;
    }
    if (cmp < 0) {
        return balance(ctx, node,
                bonsai_insert(ctx, np->left, key, value, insert_or_fail),
                np->right,
                subtree_left, 1);
    }
    if (cmp > 0) {
        return balance(ctx, node,
                np->left,
                bonsai_insert(ctx, np->right, key, value, insert_or_fail),
                subtree_right, 1);
    }
    np->value = value;
    return node;
}
예제 #4
0
파일: bonsai.c 프로젝트: cfrantz/pongo
dbtype_t
bonsai_multi_insert(pgctx_t *ctx, dbtype_t node, dbtype_t key, dbtype_t value)
{
    int cmp;
    int i, j, done;
    dbval_t *np, *orig;
    if (!node.all) {
        return bonsai_multi_new(ctx, DBNULL, DBNULL, key, value);
    }

    np = dbptr(ctx, node);
    cmp = dbcmp(ctx, key, np->key);
    if (cmp < 0) {
        return balance(ctx, node,
                bonsai_multi_insert(ctx, np->left, key, value),
                np->right,
                subtree_left, 1);
    }
    if (cmp > 0) {
        return balance(ctx, node,
                np->left,
                bonsai_multi_insert(ctx, np->right, key, value),
                subtree_right, 1);
    }
    orig = np;
    node = bonsai_ncopy(ctx, np->left, np->right, node, 1);
    np = dbptr(ctx, node);
    for(done=i=j=0; i<orig->nvalue; i++, j++) {
        if (!done) {
            cmp = dbcmp(ctx, value, orig->values[i]);
            if (cmp < 0) {
                np->values[j++] = value;
                np->nvalue++;
                done = 1;
            } else if (cmp == 0) {
                done = 1;
            }
        }
        np->values[j] = orig->values[i];
    }
    if (!done) {
        np->values[j++] = value;
        np->nvalue++;
    }

    return node;
}
예제 #5
0
int dblist_contains(pgctx_t *ctx, dbtype_t list, dbtype_t item)
{
	_list_t *_list;
	int i;

    list.ptr = dbptr(ctx, list);
	assert(list.ptr->type == List);
    _list = dbptr(ctx, list.ptr->list);
    if (_list) {
        for(i=0; i<_list->len; i++) {
            if (dbcmp(ctx, _list->item[i], item) == 0)
                return 1;
        }
    }
    return 0;
}
예제 #6
0
파일: bonsai.c 프로젝트: cfrantz/pongo
int
bonsai_find(pgctx_t *ctx, dbtype_t node, dbtype_t key, dbtype_t *value)
{
    int cmp;
    while(node.all) {
        node.ptr = dbptr(ctx, node);
        cmp = dbcmp(ctx, key, node.ptr->key);
        if (cmp < 0) {
            node = node.ptr->left;
        } else if (cmp > 0) {
            node = node.ptr->right;
        } else {
            if (value) *value = node.ptr->value;
            return 0;
        }
    }
    return -1;
}
예제 #7
0
파일: bonsai.c 프로젝트: cfrantz/pongo
dbtype_t
bonsai_find_node(pgctx_t *ctx, dbtype_t node, dbtype_t key)
{
    int cmp;
    dbtype_t ret;
    while(node.all) {
        ret = node;
        node.ptr = dbptr(ctx, node);
        cmp = dbcmp(ctx, key, node.ptr->key);
        if (cmp < 0) {
            node = node.ptr->left;
        } else if (cmp > 0) {
            node = node.ptr->right;
        } else {
            return ret;
        }
    }
    return DBNULL;
}
예제 #8
0
int dblist_remove(pgctx_t *ctx, dbtype_t list, dbtype_t item, int sync)
{
	_list_t *_list, *_newlist = NULL;
	int sz, i, j, remove;

    list.ptr = dbptr(ctx, list);
	assert(list.ptr->type == List);
    // Read-Copy-Update loop for modify operations
    do {
	    _list = dbptr(ctx, list.ptr->list);
        if (!_list)
            return -1;
        sz = dblist_size(_list, 0);
        dbfree(_newlist, 0xf9);
        _newlist = dballoc(ctx, sz);
        _newlist->type = _InternalList;
        _newlist->len = _list->len - 1;
        remove = 0;
        for(i=j=0; i<_list->len; i++) {
            // Copy all items that don't match.  Only remove
            // one matching item
            if (!remove && dbcmp(ctx, _list->item[i], item) == 0) {
                remove = 1;
            } else {
                _newlist->item[j++] = _list->item[i];
            }
        }
        if (!remove) {
            dbfree(_newlist, 0xfa);
            // No item was removed, so discard the copy (no one will
            // ever see it) and return an error
            return -1;
        }
    } while(!synchronizep(ctx, sync, &list.ptr->list, _list, _newlist));
    dbfree(_list, 0xfb);
    return 0;
}
예제 #9
0
파일: pongo_iter.c 프로젝트: cfrantz/pongo
static PyObject *
PongoIter_next_expr(PyObject *ob)
{
    PongoIter *self = (PongoIter*)ob;
    dbval_t *internal, *pn;
    dbtype_t node, key, val;
    PyObject *ret=NULL, *k, *v;
    int ls, rs;
    _list_t *list;
    _obj_t *obj;

    dblock(self->ctx);
    internal = dbptr(self->ctx, self->dbptr);
    if (!internal) {
        PyErr_SetNone(PyExc_StopIteration);
    } else if (self->tag == List) {
        list = (_list_t*)internal;
        for(;;) {
            if (self->pos == self->len) {
                PyErr_SetNone(PyExc_StopIteration);
                break;
            }
            node = list->item[self->pos++];
            if ((!self->lhdata.all || dbcmp(self->ctx, node, self->lhdata) >= self->lhex) &&
                (!self->rhdata.all || dbcmp(self->ctx, node, self->rhdata) <= self->rhex)) {
                    ret = to_python(self->ctx, node, TP_PROXY);
                    break;
            }
        }
    } else if (self->tag == Object) {
        obj = (_obj_t*)internal;
        for(;;) {
            // If we've reached the end, quit with StopIteration
            if (self->pos == self->len) {
                PyErr_SetNone(PyExc_StopIteration);
                break;
            }
            key = obj->item[self->pos].key;
            val = obj->item[self->pos].value;
            self->pos++;
            // If the key doesn't satisfy the RHS, and since Objects are
            // sorted, we can quit with StopIteration
            if (!(!self->rhdata.all || dbcmp(self->ctx, key, self->rhdata) <= self->rhex)) {
                PyErr_SetNone(PyExc_StopIteration);
                break;
            }
            // If the key does satisfy the LHS, return it
            if (!self->lhdata.all || dbcmp(self->ctx, key, self->lhdata) >= self->lhex) {
                k = to_python(self->ctx, key, TP_PROXY);
                v = to_python(self->ctx, val, TP_PROXY);
                ret = PyTuple_Pack(2, k, v);
                break;
            }
        }
    } else if (self->tag == Collection || self->tag == MultiCollection) {
        if (self->pos && self->depth == -1) {
            PyErr_SetNone(PyExc_StopIteration);
        } else {
            // NOTE: I'm overloading the lowest bit to mean "already traversed the left
            // side".  Normally, this bit is part of the 'type' field and would encode
            // this value as "Int".  However, the BonsaiNode left/right can only point
            // to other BonsaiNodes and the stack (where the bit overloading is happening)
            // lives only in main memory, so we'll never write this bit modification
            // to disk.

            // If were at position 0, put the internal node onto the stack
            // I'm reusing pos as a flag since pos is otherwise unused by the tree iterator
            if (self->pos == 0) {
                node = self->dbptr;
                for(;;) {
                    pn = _ptr(self->ctx, node.all);
                    ls = (!self->lhdata.all || dbcmp(self->ctx, pn->key, self->lhdata) >= self->lhex);
                    rs = (!self->rhdata.all || dbcmp(self->ctx, pn->key, self->rhdata) <= self->rhex);
                    if (ls && rs) {
                        self->stack[++self->depth] = node;
                        self->pos = 1;
                        break;
                    } else if (ls && pn->left.all) {
                        node = pn->left;
                    } else if (rs && pn->right.all) {
                        node = pn->right;
                    } else {
                        PyErr_SetNone(PyExc_StopIteration);
                        goto exitproc;
                    }
                }
            }

            // Get current top of stack.  If we've already traversed the left side
            // of this node, go directly to the emit stage and traverse the right side.
            node = self->stack[self->depth];
            pn = _ptr(self->ctx, node.all & ~1);
            if (node.all & 1) {
                node.all &= ~1;
            } else {
                // Walk as far left as possible, pushing onto stack as we
                // follow each link
                if (pn->left.all) {
                    node = pn->left;
                    for(;;) {
                        pn = _ptr(self->ctx, node.all);
                        ls = (!self->lhdata.all || dbcmp(self->ctx, pn->key, self->lhdata) >= self->lhex);
                        rs = (!self->rhdata.all || dbcmp(self->ctx, pn->key, self->rhdata) <= self->rhex);
                        if (ls && rs) {
                            self->stack[++self->depth] = node;
                        }
                        if (ls && pn->left.all) {
                            node = pn->left;
                        } else if (rs && pn->right.all) {
                            node = pn->right;
                        } else {
                            break;
                        }
                    }
                    // Reset node and pn to whatever is on the top of stack now
                    node = self->stack[self->depth];
                    pn = _ptr(self->ctx, node.all);
                }
            }
            // Now node, pn and top of stack all reference the same object,
            // so convert the object to python, pop the top of stack and
            // mark the new top as "left side traversed"
            ret = to_python(self->ctx, node, TP_NODEKEY|TP_NODEVAL|TP_PROXY);
            if (--self->depth >= 0) {
                self->stack[self->depth].all |= 1;
            }

            // Now check if there is a right branch in the tree and push
            // it for the next call to the iterator
            if (pn->right.all) {
                node = pn->right;
                for(;;) {
                    pn = _ptr(self->ctx, node.all);
                    ls = (!self->lhdata.all || dbcmp(self->ctx, pn->key, self->lhdata) >= self->lhex);
                    rs = (!self->rhdata.all || dbcmp(self->ctx, pn->key, self->rhdata) <= self->rhex);
                    if (ls && rs) {
                        self->stack[++self->depth] = node;
                    }
                    if (ls && pn->left.all) {
                        node = pn->left;
                    } else if (rs && pn->right.all) {
                        node = pn->right;
                    } else {
                        break;
                    }
                }
            }
        }
    }
exitproc:
    dbunlock(self->ctx);
    return ret;
}
예제 #10
0
BOOL CLDlg::OnInitDialog()
{
	CDialog::OnInitDialog();
	 m_hYellowBrush=(HBRUSH)GetStockObject(BLACK_BRUSH);

	 m_hRedBrush=(HBRUSH)GetStockObject(BLACK_BRUSH);


	// Add "About..." menu item to system menu.

	// IDM_ABOUTBOX must be in the system command range.
	ASSERT((IDM_ABOUTBOX & 0xFFF0) == IDM_ABOUTBOX);
	ASSERT(IDM_ABOUTBOX < 0xF000);

	CMenu* pSysMenu = GetSystemMenu(FALSE);
	if (pSysMenu != NULL)
	{
		CString strAboutMenu;
		strAboutMenu.LoadString(IDS_ABOUTBOX);
		if (!strAboutMenu.IsEmpty())
		{
			pSysMenu->AppendMenu(MF_SEPARATOR);
			pSysMenu->AppendMenu(MF_STRING, IDM_ABOUTBOX, strAboutMenu);
		}
	}

	// Set the icon for this dialog.  The framework does this automatically
	//  when the application's main window is not a dialog
	SetIcon(m_hIcon, TRUE);			// Set big icon
	SetIcon(m_hIcon, FALSE);		// Set small icon
	
	// TODO: Add extra initialization here
	
	
///////////////////////// initializations ///////////////////////////////////

pt1[0].x=0;
pt1[0].y=0;
pt2[0].x=1;
pt2[0].y=1; 
pt1[1].x=0;
pt1[1].y=3;
pt2[1].x=0;
pt2[1].y=3; 
pt1[2].x=8;
pt1[2].y=7;
pt2[2].x=9;
pt2[2].y=9; 
pt1[3].x=8;
pt1[3].y=5;
pt2[3].x=9;
pt2[3].y=6; 
pt1[4].x=4;
pt1[4].y=4;
pt2[4].x=5;
pt2[4].y=5; 

cmpt[0].x=0;
cmpt[0].y=0;
cmpt[1].x=0;
cmpt[1].y=4;
cmpt[2].x=5;
cmpt[2].y=5;
cmpt[3].x=5;
cmpt[3].y=7;
cmpt[4].x=8;
cmpt[4].y=8;

///////////////////////// initializations ///////////////////////////////////



///////////////////////////////database read from floortab/////////////////////////////////////////////
    CDatabase xx;

	xx.Open("ODBC;DSN=geoinfo");
	CRecordset dbSQL(&xx);
	dbSQL.Open(CRecordset::forwardOnly,"select * from floortab");
	cnt=0;
	while(!dbSQL.IsEOF()) 
	{
	CString xy;
	dbSQL.GetFieldValue("fid",xy);
	flid[cnt]=atoi(xy);
	dbSQL.GetFieldValue("frows",xy);
	flrows[cnt]=atoi(xy);
	dbSQL.GetFieldValue("fclmns",xy);
	flclmns[cnt++]=atoi(xy);
	dbSQL.MoveNext();	
	}

///////////////////////////////database read from floortab//////////////////////////////////////////////

///////////////////////////////database read from labtab//////////////////////////////////////////////
	CRecordset dblab(&xx);
	dblab.Open(CRecordset::forwardOnly,"select * from labtab");
	labcount=0;
	while(!dblab.IsEOF()) 
	{
	CString xy;
	dblab.GetFieldValue("labid",xy);
	labid[labcount]=atoi(xy);

	dblab.GetFieldValue("fid",xy);
	labfl[labcount]=atoi(xy);
	
	dblab.GetFieldValue("labname",xy);
	strcpy(labname[labcount],xy);
	
	dblab.GetFieldValue("labrow1",xy);
	pt1[labcount].x=atoi(xy);
	
	dblab.GetFieldValue("labclmn1",xy);
	pt1[labcount].y=atoi(xy);
	
	dblab.GetFieldValue("labrow2",xy);
	pt2[labcount].x=atoi(xy);
	
	dblab.GetFieldValue("labclmn2",xy);
	pt2[labcount].y=atoi(xy);

	dblab.GetFieldValue("labrows",xy);
	labrows[labcount]=atoi(xy);

	dblab.GetFieldValue("labclmns",xy);
	labclmns[labcount++]=atoi(xy);

	
	dblab.MoveNext();	
	}
	
///////////////////////////////database read from labtab//////////////////////////////////////////////
	
///////////////////////////////database read from labtab//////////////////////////////////////////////
	CRecordset dbcmp(&xx);
	dbcmp.Open(CRecordset::forwardOnly,"select * from comptab");
	cmcount=0;
	while(!dbcmp.IsEOF()) 
	{
	CString xy;
	dbcmp.GetFieldValue("cmid",xy);
	cmid[cmcount]=atoi(xy);
	dbcmp.GetFieldValue("labid",xy);
	cmlabid[cmcount]=atoi(xy);
	dbcmp.GetFieldValue("ptx",xy);
	cmpt[cmcount].x =atoi(xy);
	dbcmp.GetFieldValue("pty",xy);
	cmpt[cmcount].y =atoi(xy);

	dbcmp.GetFieldValue("cmip1",xy);
	cmip[cmcount][0] =atoi(xy);

	dbcmp.GetFieldValue("cmip2",xy);
	cmip[cmcount][1] =atoi(xy);

	dbcmp.GetFieldValue("cmip3",xy);
	cmip[cmcount][2] =atoi(xy);

	dbcmp.GetFieldValue("cmip4",xy);
	cmip[cmcount][3] =atoi(xy);

	cmcount++;
	dbcmp.MoveNext();	
	}
	
	
///////////////////////////////database read from labtab//////////////////////////////////////////////
return TRUE;  // return TRUE  unless you set the focus to a control
}