NEOERR *wdb_column_update (WDB *wdb, const char *oldkey, const char *newkey)
{
WDBColumn *ocol, *col;
WDBColumn *vcol;
NEOERR *err = STATUS_OK;
int x, len, r;
ocol = (WDBColumn *) dictSearch (wdb->cols, oldkey, NULL);
if (ocol == NULL)
return nerr_raise (NERR_NOT_FOUND,
"Unable to find column for key %s", oldkey);
col = (WDBColumn *) calloc (1, sizeof (WDBColumn));
if (col == NULL)
{
return nerr_raise (NERR_NOMEM,
"Unable to allocate memory for column update %s", newkey);
}
*col = *ocol;
col->name = strdup(newkey);
if (col->name == NULL)
{
free(col);
return nerr_raise (NERR_NOMEM,
"Unable to allocate memory for column update %s", oldkey);
}
len = uListLength(wdb->cols_l);
for (x = 0; x < len; x++)
{
err = uListGet (wdb->cols_l, x, (void *)&vcol);
if (err) return nerr_pass(err);
if (!strcmp(vcol->name, oldkey))
{
err = uListSet (wdb->cols_l, x, (void *)col);
if (err) return nerr_pass(err);
break;
}
}
if (x>len)
{
return nerr_raise (NERR_ASSERT, "Unable to find cols_l for key %s", oldkey);
}
r = dictRemove (wdb->cols, oldkey); /* Only failure is key not found */
err = dictSetValue(wdb->cols, newkey, col);
if (err)
{
free (col->name);
free (col);
return nerr_pass_ctx (err,
"Unable to insert for update of col %s->%s", oldkey, newkey);
}
wdb->defn_dirty = 1;
wdb->table_version = rand();
return STATUS_OK;
}
NEOERR *wdb_attr_get (WDB *wdb, const char *key, char **value)
{
void *v;
v = dictSearch (wdb->attrs, key, NULL);
if (v == NULL)
return nerr_raise (NERR_NOT_FOUND, "Unable to find attr %s", key);
*value = (char *)v;
return STATUS_OK;
}
NEOERR *wdbr_get (WDB *wdb, WDBRow *row, const char *key, void **value)
{
WDBColumn *col;
void *v;
col = (WDBColumn *) dictSearch (wdb->cols, key, NULL);
if (col == NULL)
return nerr_raise (NERR_NOT_FOUND, "Unable to find key %s", key);
if (col->inmem_index-1 > row->data_count)
return nerr_raise (NERR_ASSERT, "Index for key %s is greater than row data, was table altered?", key);
v = row->data[col->inmem_index-1];
*value = v;
return STATUS_OK;
}
NEOERR *wdbr_set (WDB *wdb, WDBRow *row, const char *key, void *value)
{
WDBColumn *col;
col = (WDBColumn *) dictSearch (wdb->cols, key, NULL);
if (col == NULL)
return nerr_raise (NERR_NOT_FOUND, "Unable to find key %s", key);
if (col->inmem_index-1 > row->data_count)
return nerr_raise (NERR_ASSERT, "Index for key %s is greater than row data, was table altered?", key);
if (col->type == WDB_TYPE_STR && row->data[col->inmem_index-1] != NULL)
{
free (row->data[col->inmem_index-1]);
}
row->data[col->inmem_index-1] = value;
return STATUS_OK;
}
static void ConnectLeftVertex( TESStesselator *tess, TESSvertex *vEvent )
/*
* Purpose: connect a "left" vertex (one where both edges go right)
* to the processed portion of the mesh. Let R be the active region
* containing vEvent, and let U and L be the upper and lower edge
* chains of R. There are two possibilities:
*
* - the normal case: split R into two regions, by connecting vEvent to
* the rightmost vertex of U or L lying to the left of the sweep line
*
* - the degenerate case: if vEvent is close enough to U or L, we
* merge vEvent into that edge chain. The subcases are:
* - merging with the rightmost vertex of U or L
* - merging with the active edge of U or L
* - merging with an already-processed portion of U or L
*/
{
ActiveRegion *regUp, *regLo, *reg;
TESShalfEdge *eUp, *eLo, *eNew;
ActiveRegion tmp;
/* assert( vEvent->anEdge->Onext->Onext == vEvent->anEdge ); */
/* Get a pointer to the active region containing vEvent */
tmp.eUp = vEvent->anEdge->Sym;
/* __GL_DICTLISTKEY */ /* tessDictListSearch */
regUp = (ActiveRegion *)dictKey( dictSearch( tess->dict, &tmp ));
regLo = RegionBelow( regUp );
if( !regLo ) {
// This may happen if the input polygon is coplanar.
return;
}
eUp = regUp->eUp;
eLo = regLo->eUp;
/* Try merging with U or L first */
if( EdgeSign( eUp->Dst, vEvent, eUp->Org ) == 0 ) {
ConnectLeftDegenerate( tess, regUp, vEvent );
return;
}
/* Connect vEvent to rightmost processed vertex of either chain.
* e->Dst is the vertex that we will connect to vEvent.
*/
reg = VertLeq( eLo->Dst, eUp->Dst ) ? regUp : regLo;
if( regUp->inside || reg->fixUpperEdge) {
if( reg == regUp ) {
eNew = tessMeshConnect( tess->mesh, vEvent->anEdge->Sym, eUp->Lnext );
if (eNew == NULL) longjmp(tess->env,1);
} else {
TESShalfEdge *tempHalfEdge= tessMeshConnect( tess->mesh, eLo->Dnext, vEvent->anEdge);
if (tempHalfEdge == NULL) longjmp(tess->env,1);
eNew = tempHalfEdge->Sym;
}
if( reg->fixUpperEdge ) {
if ( !FixUpperEdge( tess, reg, eNew ) ) longjmp(tess->env,1);
} else {
ComputeWinding( tess, AddRegionBelow( tess, regUp, eNew ));
}
SweepEvent( tess, vEvent );
} else {
/* The new vertex is in a region which does not belong to the polygon.
* We don''t need to connect this vertex to the rest of the mesh.
*/
AddRightEdges( tess, regUp, vEvent->anEdge, vEvent->anEdge, NULL, TRUE );
}
}
NEOERR *wdb_column_insert (WDB *wdb, int loc, const char *key, char type)
{
NEOERR *err;
WDBColumn *col, *ocol;
int x, len;
col = (WDBColumn *) dictSearch (wdb->cols, key, NULL);
if (col != NULL)
return nerr_raise (NERR_DUPLICATE,
"Duplicate key %s:%d", key, col->inmem_index);
col = (WDBColumn *) calloc (1, sizeof (WDBColumn));
if (col == NULL)
{
return nerr_raise (NERR_NOMEM,
"Unable to allocate memory for creation of col %s:%d", key, loc);
}
col->name = strdup(key);
if (col->name == NULL)
{
free(col);
return nerr_raise (NERR_NOMEM,
"Unable to allocate memory for creation of col %s:%d", key, loc);
}
col->type = type;
col->ondisk_index = wdb->last_ondisk++;
/* -1 == append */
if (loc == -1)
{
err = dictSetValue(wdb->cols, key, col);
if (err)
{
free (col->name);
free (col);
return nerr_pass_ctx (err,
"Unable to insert for creation of col %s:%d", key, loc);
}
err = uListAppend (wdb->cols_l, (void *)col);
if (err) return nerr_pass(err);
x = uListLength (wdb->cols_l);
col->inmem_index = x;
err = skipInsert (wdb->ondisk, col->ondisk_index,
(void *)(col->inmem_index), 0);
if (err)
return nerr_pass_ctx (err, "Unable to update ondisk mapping for %s", key);
}
else
{
/* We are inserting this in middle, so the skipList ondisk is now
* invalid, as is the inmem_index for all cols */
err = dictSetValue(wdb->cols, key, col);
if (err)
{
free (col->name);
free (col);
return nerr_pass_ctx (err,
"Unable to insert for creation of col %s:%d", key, loc);
}
err = uListInsert (wdb->cols_l, loc, (void *)col);
if (err) return nerr_pass(err);
len = uListLength (wdb->cols_l);
/* Fix up inmem_index and ondisk skipList */
for (x = 0; x < len; x++)
{
err = uListGet (wdb->cols_l, x, (void *)&ocol);
if (err) return nerr_pass(err);
ocol->inmem_index = x + 1;
err = skipInsert (wdb->ondisk, ocol->ondisk_index,
(void *)(ocol->inmem_index), TRUE);
if (err)
return nerr_pass_ctx (err, "Unable to update ondisk mapping for %s", key);
}
}
wdb->defn_dirty = 1;
wdb->table_version = rand();
return STATUS_OK;
}
