X-Git-Url: https://git.rrq.au/?a=blobdiff_plain;f=vector%2Ftupleitem.c;h=2a4a01a7dc6cc96efde2a08a2af3d92bdaf45ee0;hb=9e8fceb62721997ca62abfed6080e917bb429eee;hp=eff77cedb56e0146c80571aeffc504856d197c20;hpb=6f54a8281e4e5d6bc05e6b4eadc3327d5e48614a;p=rrq%2Frrqmisc.git diff --git a/vector/tupleitem.c b/vector/tupleitem.c index eff77ce..2a4a01a 100644 --- a/vector/tupleitem.c +++ b/vector/tupleitem.c @@ -1,20 +1,40 @@ +#include #include +#include #include -typedef void *tuple[]; +#define COLUMN def->columns -#define COLUMN def->schema[i] - -unsigned long tupleitem_hashcode(itemkeyfun *this,void *key) { +/** + * This callback function returns the hashcode of a key. + * + * \param this is a pointer to the itemkeyfun record from where this + * callback got invoked + * + * \param key is the key to produce a hascode for + * + * \returns the hashcode which is a vector_index (i.e. unsigned long) + * + * The hashcode is used for indexing into the backing vector for + * finding the an item via its key. The same key must map consistently + * to the same hashcode while the hashtable contains an item with that + * key. Different keys map map to the same hashcode, in which case the + * vector placement is made at the first empty or hole slot following + * the hashcode index. + */ +static unsigned long tupleitem_hashcode(void *this,void *key) { tupleschema *def = (tupleschema *) this; tuple *kp = (tuple*) key; int i = 0; - unsigned long value = 0; + unsigned long value = 5381; for ( ; i < def->arity; i++ ) { - if ( COLUMN ) { + if ( COLUMN[i] ) { value <<= 3; - value += COLUMN->hashcode( COLUMN, (*kp)[i] ); + if ( (*kp)[i] ) { + value += COLUMN[i]->hashcode( COLUMN[i], (*kp)[i] ); + } } + value += 17; } return value; } @@ -23,18 +43,19 @@ unsigned long tupleitem_hashcode(itemkeyfun *this,void *key) { * This callback function determines whether an item has a * given key or not. */ -int tupleitem_haskey(itemkeyfun *this,void *item,void *key) { +static int tupleitem_haskey(void *this,void *item,void *key) { tupleschema *def = (tupleschema *) this; tuple *kp = (tuple*) key; tuple *tp = (tuple*) item; int i = 0; - int haskey = 1; for ( ; i < def->arity; i++ ) { - if ( COLUMN ) { - haskey &= COLUMN->haskey( COLUMN, (*tp)[i], (*kp)[i] ); + if ( COLUMN[i] && (*kp)[i] ) { + if ( COLUMN[i]->haskey( COLUMN[i], (*tp)[i], (*kp)[i] ) == 0 ) { + return 0; + } } } - return haskey; + return 1; } @@ -42,20 +63,15 @@ int tupleitem_haskey(itemkeyfun *this,void *item,void *key) { * This callback function returns the key of an item by considering * the arity and mask. */ -void *tupleitem_itemkey(itemkeyfun *this,void *item) { +static void *tupleitem_itemkey(void *this,void *item) { tupleschema *def = (tupleschema *) this; tuple *tp = (tuple*) item; - int i, j; - int keylen = 0; - for ( i = 0 ; i < def->arity; i++ ) { - if ( COLUMN ) { - keylen++; - } - } + int i; + int keylen = def->arity; void **parts = calloc( keylen, sizeof( void* ) ); - for ( i = 0, j = 0; i < def->arity; i++ ) { - if ( COLUMN ) { - parts[j++] = COLUMN->itemkey( COLUMN, (*tp)[i] ); + for ( i = 0; i < def->arity; i++ ) { + if ( COLUMN[i] ) { + parts[i] = COLUMN[i]->itemkey( COLUMN[i], (*tp)[i] ); } } return (void*) parts; @@ -65,15 +81,99 @@ void *tupleitem_itemkey(itemkeyfun *this,void *item) { * This callback function handles a key obtained from the itemkey * callback function to reclaim temporary allocation. */ -void tupleitem_releasekey(itemkeyfun *this,void *key) { +static void tupleitem_releasekey(void *this,void *key) { tupleschema *def = (tupleschema *) this; tuple *kp = (tuple*) key; - int i,j; - for ( i = 0, j = 0; i < def->arity; i++ ) { - if ( COLUMN ) { - COLUMN->releasekey( COLUMN, (*kp)[j++] ); + int i; + for ( i = 0; i < def->arity; i++ ) { + if ( COLUMN[i] ) { + COLUMN[i]->releasekey( COLUMN[i], (*kp)[i] ); } } free( key ); } +#define OUT(X) a = X; if ( a > limit ) return 0; buffer += a; limit -= a + +/** + * This callback function writes a representation of an item into + * a character buffer. + */ +static int tupleitem_tostring(void *this,void *item,char *buffer,int limit) { + tupleschema *def = (tupleschema *) this; + tuple *t = (tuple*) item; + char *x = "<"; + int a, i; + for ( i = 0; i < def->arity; i++ ) { + OUT( snprintf( buffer, limit, x ) ); + x = ","; + OUT( def->columns[i]->tostring( + def->columns[i], (*t)[i], buffer, limit ) ); + } + OUT( snprintf( buffer, limit, ">" ) ); + return a; +} + + +// Allocate +tuple *tuple_create(int arity,...) { + va_list ap; + int i; + tuple *t = (tuple *)malloc( arity * sizeof( void* ) ); + va_start( ap, arity ); + for ( i = 0; i < arity; i++ ) { + (*t)[i] = va_arg( ap, void* ); + } + va_end( ap ); + return t; +} + +itemkeyfun tupleschema_callbacks = { + .hashcode = tupleitem_hashcode, + .haskey = tupleitem_haskey, + .itemkey = tupleitem_itemkey, + .releasekey = tupleitem_releasekey, + .tostring = tupleitem_tostring +}; + +tupleschema *tupleschema_create(int arity,tuple *columns) { + tupleschema *ts = (tupleschema*) malloc( sizeof( tupleschema ) ); + (*ts) = (tupleschema) { + .base = tupleschema_callbacks, + .arity = arity, + .columns = (itemkeyfun**) columns + }; + return ts; +} + +#define COPYA(T,P,N) (T*) memcpy( malloc( N * sizeof(T) ), P, N * sizeof( T ) ) +#define COPY(T,P) COPYA(T,P,1) + +// Duplicate a tupleschema with optionally some columns reset. +tupleschema *tupleschema_mask(tupleschema *schema,...) { + tupleschema *masked = COPY(tupleschema,schema); + masked->columns = COPYA( itemkeyfun*, schema->columns, schema->arity ); + va_list ap; + int i; + va_start( ap, schema ); + for ( ;; ) { + i = va_arg( ap, int ); + if ( i < 0 || i >= schema->arity ) { + break; + } + masked->columns[i] = 0; + }; + va_end( ap ); + return masked; +} + +unsigned long tuple_mask(int arity,tuple *t) { + unsigned long mask = 0; + while ( arity-- > 0 ) { + mask <<= 1; + if ( (*t)[ arity ] ) { + mask++; + } + } + return mask; +}