std::vector<ossimString> ossimVpfTable::getColumnValues(const ossimString& columnName)const
{
std::vector<ossimString> result;
if(theTableInformation &&
theTableInformation->status == OPENED)
{
long int columnNumber = table_pos(const_cast<char*>(columnName.c_str()), *theTableInformation);
if(columnNumber >=0 &&
(columnNumber < theTableInformation->nfields))
{
row_type row;
// start at the first row of the table
reset();
for (int rowIndex = 1;
rowIndex <= theTableInformation->nrows;
++rowIndex)
{
row = read_next_row(*theTableInformation);
ossimString value = getColumnValueAsString(row,
columnNumber);
value.trim();
result.push_back(value);
free_row(row, *theTableInformation);
}
}
}
return result;
}
/**************************************************************************
*
*N vpf_dump_doc_table
*
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* Dump the contents of a narrative-style .DOC VPF table into an
* ASCII file as a series of text strings. This function checks
* to make sure that the given table is a real narrative file
* (two fields: ID and TEXT). If not, it displays it as a normal
* VPF table.
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* tablename <input> == (char *) narrative-style .DOC VPF table to dump.
* outname <input> == (char *) name of ASCII dump file.
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels DOS Turbo C
*E
*************************************************************************/
void vpf_dump_doc_table( char *tablename, char *outname )
{
vpf_table_type table;
long int i,n;
char *buf;
row_type row;
FILE *fp;
fp = fopen(outname,"w");
table = vpf_open_table(tablename,disk,"rb",NULL);
/* Check header to make sure the table is a narrative table */
if ((ossim_strcasecmp(table.header[1].name,"TEXT") != 0) ||
(table.nfields != 2)) {
/* Not a real narrative table -> normal VPF table dump */
vpf_close_table(&table);
vpf_dump_table(tablename,outname);
return;
}
fprintf(fp,"%s\n%s\n\n",tablename,table.description);
for (i=1;i<=table.nrows;i++) {
row = read_next_row(table);
buf = (char *)get_table_element(1,row,table,NULL,&n);
fprintf(fp,"%s\n",buf);
free(buf);
free_row(row,table);
}
fclose(fp);
vpf_close_table( &table );
}
/*
* Convert a row from result into db API representation
*/
int convert_row(db_con_t* _h, db_res_t* _res, db_row_t* _r)
{
unsigned long* lengths;
int i;
#ifndef PARANOID
if ((!_h) || (!_r) || (!_n)) {
log(L_ERR, "convert_row(): Invalid parameter value\n");
return -1;
}
#endif
ROW_VALUES(_r) = (db_val_t*)pkg_malloc(sizeof(db_val_t) * RES_COL_N(_res));
ROW_N(_r) = RES_COL_N(_res);
if (!ROW_VALUES(_r)) {
LOG(L_ERR, "convert_row(): No memory left\n");
return -1;
}
lengths = mysql_fetch_lengths(CON_RESULT(_h));
for(i = 0; i < RES_COL_N(_res); i++) {
if (str2val(RES_TYPES(_res)[i], &(ROW_VALUES(_r)[i]),
((MYSQL_ROW)CON_ROW(_h))[i], lengths[i]) < 0) {
LOG(L_ERR, "convert_row(): Error while converting value\n");
free_row(_r);
return -3;
}
}
return 0;
}
void ossimVpfLibrary::setTileNames()const
{
ossimVpfTable table;
theTileNameMap.clear();
row_type row;
if(table.openTable(theLibraryNameFullPath.dirCat("tileref").dirCat("tileref.aft")))
{
table.reset();
const int ROWS = table.getNumberOfRows();
for (int rowIdx = 1; rowIdx <= ROWS; ++rowIdx)
{
// Note: read_row takes a "one based" index.
row = read_row( rowIdx, *(table.getVpfTableData()) );
ossim_int32 namePosition = table.getColumnPosition("TILE_NAME");
ossim_int32 tileIdPosition = table.getColumnPosition("ID");
ossimString tileName = table.getColumnValueAsString(row,
namePosition);;
ossimString tileId = table.getColumnValueAsString(row,
tileIdPosition);
theTileNameMap.insert(make_pair(tileId.toInt32(), tileName.trim()));
free_row( row, *(table.getVpfTableData()) );
}
}
}
/**************************************************************************
*
*N vpf_binary_search
*
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function performs a binary search on a VPF table for the
* specified integer value. Only VPF data type 'I' is supported.
* The table must be sorted on the specified field, or this function
* will give unpredictable results. The table must have been
* successfully opened. If more than one row matches the search
* value, only the first encountered will be returned.
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* srchval <input> == (long int) specified search value.
* field <input> == (int) table sort field.
* table <input> == (vpf_table_type) VPF table.
* vpf_binary_search <output> == (long int) first matching row.
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels DOS Turbo C
*E
*************************************************************************/
long int vpf_binary_search( long int srchval,
int field,
vpf_table_type table )
{
long int left,right, ival, rowid, n;
row_type row;
left = 1;
right = table.nrows;
do {
rowid = (left+right)/2;
row = get_row(rowid,table);
get_table_element(field,row,table,&ival,&n);
free_row(row,table);
if (ival < srchval)
right = rowid-1;
else
left = rowid+1;
} while ((srchval != ival) && (left <= right));
if (srchval != ival) rowid = 0;
return rowid;
}
std::vector<ossimString> ossimVpfTable::getColumnValues(long columnNumber)const
{
std::vector<ossimString> result;
if(theTableInformation &&
theTableInformation->status == OPENED)
{
if(columnNumber >=0 &&
(columnNumber < theTableInformation->nfields))
{
row_type row;
// start at the first row of the table
reset();
for (int rowIndex = 0;
rowIndex < theTableInformation->nrows;
++rowIndex)
{
row = read_next_row(*theTableInformation);
ossimString value = getColumnValueAsString(row,
columnNumber);
// value = value.downcase();
value = value.trim();
result.push_back(value);
free_row(row, *theTableInformation);
}
}
}
return result;
}
void SqliteDataset::next(void) {
#ifdef _XBOX
free_row();
#endif
Dataset::next();
if (!eof())
fill_fields();
}
void table_destroy(TABLE *t) {
struct Node *n = t->rows.l_head;
while (list_isNode(n)) {
TABLE_ROW *r = (TABLE_ROW *) n;
n = n->n_succ;
free_row(r);
}
free(t);
}
/**************************************************************************
*
*N related_row
*
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* Return the related row of table2 based upon the value of table 1's key
* Table 2 must be the '1' side of an n:1 relationship -- If it isn't,
* use 'related_rows()'.
* Supported data types - I and T<n>.
* Binary search supported only for data type I. (column must be sorted)
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels DOS Turbo C
*E
*************************************************************************/
long int related_row( void *keyval1,
vpf_table_type table2, char *key2,
int sort_flag )
{
long int rowid, i, ival, kval, n;
row_type row;
int KEY2_;
char cval, *tval;
if (ossim_strcasecmp(key2,"ID")==0) {
memcpy( &rowid, keyval1, sizeof(rowid) );
return rowid;
}
rowid = 0;
KEY2_ = table_pos(key2,table2);
if ((table2.header[KEY2_].type != 'I')&&
(table2.header[KEY2_].type != 'T')) return rowid;
if ((table2.header[KEY2_].type == 'I')&&
(table2.header[KEY2_].count != 1)) return rowid;
if ((table2.header[KEY2_].type == 'T')&&(sort_flag)) sort_flag = 0;
if (table2.header[KEY2_].type == 'I') memcpy(&kval,keyval1,sizeof(kval));
if (!sort_flag) { /* Sequential search */
for (i=1;i<=table2.nrows;i++) {
row = get_row(i,table2);
if (table2.header[KEY2_].type == 'I') {
get_table_element(KEY2_,row,table2,&ival,&n);
if (ival == kval) rowid = i;
} else {
if (table2.header[KEY2_].count==1) {
get_table_element(KEY2_,row,table2,&cval,&n);
if (memcmp(&cval,keyval1,sizeof(ival))==0) rowid = i;
} else {
tval = (char*)get_table_element(KEY2_,row,table2,NULL,&n);
if (strcmp(tval,(char *)keyval1)==0) rowid = i;
}
}
free_row(row,table2);
if (rowid > 0) break;
}
} else { /* Binary search */
memcpy(&kval,keyval1,sizeof(kval));
rowid = vpf_binary_search( kval, KEY2_, table2 );
}
return rowid;
}
void free_raster_header(NIDS_raster *r) {
int i;
for (i = 0 ; i < r->num_rows ; i++)
free_row(r->rows + i);
free(r->rows);
}
/*************************************************************************
*
*N draw_text
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function draws annotation for a given row number in the text
* pseudo-primitive table.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* rownum <input>==(ossim_int32) row number of the text table.
* table <input>==(vpf_table_type) text primitive table.
* return <output>==(int) 0 if the user escapes, 1 upon successful
* completion.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels August 1991 DOS Turbo C
*E
*************************************************************************/
int draw_text( ossim_int32 rownum, vpf_table_type table )
{
int stat;
row_type row;
row = get_row( rownum, table );
stat = draw_text_row(row,table);
free_row(row,table);
return stat;
}
ossimString ossimVpfTable::getColumnValueAsString(ossim_int32 rowNumber,
long columnNumber)const
{
row_type row = read_row( rowNumber, *theTableInformation);
ossimString result = getColumnValueAsString(row,
columnNumber);
free_row(row, *theTableInformation);
return result;
}
/*************************************************************************
*
*N bounding_select
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function reads the bounding rectangle table to weed out the
* local primitives.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* path <input> == (char *) path to the bounding rectangle table.
* mapextent <input> == (extent_type) map extent to compare.
* dec_degrees <input> == (int) flag to indicate if data is in decimal
* degrees.
* bounding_select <output> == (set_type) set of bounding rectangle ids.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels May 1991 DOS Turbo C
*E
*************************************************************************/
set_type bounding_select( char *path, extent_type mapextent,
int dec_degrees )
{
vpf_table_type table;
set_type set;
rspf_int32 i, count;
extent_type box, pextent;
double x1,y1,x2,y2;
row_type row;
int XMIN_,YMIN_,XMAX_,YMAX_;
/* Project all extents to plate-carree for cartesian comparisons */
/* (decimal degree coordinate systems) */
x1 = mapextent.x1; y1 = mapextent.y1;
x2 = mapextent.x2; y2 = mapextent.y2;
if (dec_degrees) {
set_plate_carree_parameters( central_meridian(x1,x2), 0.0, 1.0 );
pcarree_xy(&x1,&y1);
pcarree_xy(&x2,&y2);
}
pextent.x1 = x1; pextent.y1 = y1;
pextent.x2 = x2; pextent.y2 = y2;
table = vpf_open_table(path,disk,"rb",NULL);
XMIN_ = table_pos("XMIN",table);
YMIN_ = table_pos("YMIN",table);
XMAX_ = table_pos("XMAX",table);
YMAX_ = table_pos("YMAX",table);
set = set_init(table.nrows+1);
for (i=1;i<=table.nrows;i++) {
row = read_next_row(table);
get_table_element(XMIN_,row,table,&box.x1,&count);
get_table_element(YMIN_,row,table,&box.y1,&count);
get_table_element(XMAX_,row,table,&box.x2,&count);
get_table_element(YMAX_,row,table,&box.y2,&count);
free_row(row,table);
x1 = box.x1; y1 = box.y1;
x2 = box.x2; y2 = box.y2;
if (dec_degrees) {
pcarree_xy(&x1,&y1);
pcarree_xy(&x2,&y2);
}
box.x1 = x1; box.y1 = y1;
box.x2 = x2; box.y2 = y2;
if ( contained(box,pextent) || contained(pextent,box) ) {
set_insert(i,set);
}
}
vpf_close_table(&table);
return set;
}
void free_row(struct s_Row *row) {
if (row != 0) {
free_row(row->next_row);
free_cell(row->first_cell);
free(row);
}
}
void rspfVpfFeatureClassSchema::setFeatureClassMapping()
{
if(!isClosed())
{
rspf_int32 featureIdx = getColumnPosition("feature_class");
rspf_int32 table1Idx = getColumnPosition("table1");
rspf_int32 table1KeyIdx = getColumnPosition("table1_key");
rspf_int32 table2Idx = getColumnPosition("table2");
rspf_int32 table2KeyIdx = getColumnPosition("table2_key");
reset();
if(getNumberOfRows() > 0)
{
row_type row;
const int ROWS = getNumberOfRows();
for(int rowIdx = 1; rowIdx <= ROWS; ++rowIdx)
{
if(rowIdx == 1)
{
row = read_row(rowIdx,
*theTableInformation);
}
else
{
row = read_next_row(*theTableInformation);
}
rspfFilename primitiveTable = getColumnValueAsString(row,
table2Idx);
if(rspfVpfFeatureClass::isPrimitive(primitiveTable))
{
rspfString primitiveTableKey = getColumnValueAsString(row,
table2KeyIdx);
rspfFilename table = getColumnValueAsString(row,
table1Idx);
rspfString tableKey = getColumnValueAsString(row,
table1KeyIdx);
rspfString featureClass = getColumnValueAsString(row,
featureIdx);
rspfVpfFeatureClassSchemaNode node(table,
tableKey,
primitiveTable,
primitiveTableKey);
theFeatureClassMap.insert(make_pair(featureClass,
node));
}
free_row(row, *theTableInformation);
}
}
}
}
/*************************************************************************
*
*N table_element
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function returns the element in the specified row in the column
* matching the given field number. If the element is a single element
* (count=1), the value is passed back via the void pointer *value;
* otherwise, an array is allocated and passed back as the return value.
* NOTE: If an array is allocated in this function, it should be freed
* when no longer needed.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* field_number <input> == (ossim_int32) field number (offset from
* first field in table).
* row_number <input> == (ossim_int32) row_number.
* table <input> == (vpf_table_type) VPF table structure.
* value <output> == (void *) pointer to a single element value.
* count <output> == (ossim_int32 *) pointer to the array size for a multiple
* element value.
* return <output> == (void *) returned multiple element value or
* NULL of the field number is invalid
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels May 1991 DOS Turbo C
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* External Variables:
*X
* None
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Functions Called:
*F
* row_type get_row() VPFREAD.C
* void free_row() VPFREAD.C
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Portability:
*O
* This module should be ANSI C compatible.
*E
*************************************************************************/
void *table_element( ossim_int32 field_number,
ossim_int32 row_number,
vpf_table_type table,
void * value,
ossim_int32 * count )
{
row_type row;
void * retvalue;
row = get_row(row_number, table);
retvalue = get_table_element(field_number, row, table, value, count);
free_row(row,table);
return retvalue;
}
ossimString ossimVpfTable::getColumnValueAsString(const ossimString& columnName)
{
if(theTableInformation &&
(theTableInformation->status!=CLOSED))
{
long int columnNumber = table_pos(const_cast<char*>(columnName.c_str()),
*theTableInformation);
row_type row = read_next_row(*theTableInformation);
ossimString result = getColumnValueAsString(row,
columnNumber);
free_row(row, *theTableInformation);
return result;
}
return "";
}
/*************************************************************************
*
*N display_attributes
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function displays all of the attributes of a particular
* feature, including the descriptions of the fields and their
* values.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* fc <input> == (int) feature class number.
* row <input> == (ossim_int32) row of the attribute table.
* library <input> == (library_type *) VPF library structure.
* fp <input> == (FILE *) pointer to the output file.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels May 1991 DOS Turbo C
*E
*************************************************************************/
void display_attributes( int fc,
ossim_int32 row,
library_type *library,
FILE *fp )
{
vpf_table_type feature_table;
row_type vpfrow;
feature_table = vpf_open_table(library->fc[fc].table,disk,"rb",NULL);
vpfrow = read_row( row, feature_table );
vpf_display_record( vpfrow, feature_table, fp );
free_row(vpfrow,feature_table);
vpf_close_table(&feature_table);
}
/*************************************************************************
*
*N draw_face
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function draws the specified face from the given face table.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* row_num <input>==(ossim_int32) row id of the specified face.
* facetable <input>==(vpf_table_type) VPF face primitive table.
* ringtable <input>==(vpf_table_type) VPF ring primitive table.
* edgetable <input>==(vpf_table_type) VPF edge primitive table.
* fbr <input>==(vpf_table_type) VPF face bounding rectangle table.
* outline <input>==(color_type) outline color.
* c1 <input>==(color_type) 1st color in the fill pattern.
* c2 <input>==(color_type) 2nd color in the fill pattern.
* c3 <input>==(color_type) 3rd color in the fill pattern.
* c4 <input>==(color_type) 4th color in the fill pattern.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels May 1991 DOS Turbo C
*E
*************************************************************************/
void draw_face( ossim_int32 rownum,
vpf_table_type facetable,
vpf_table_type ringtable,
vpf_table_type edgetable,
vpf_table_type fbr,
color_type outline,
color_type c1,
color_type c2,
color_type c3,
color_type c4 )
{
row_type row;
row = get_row( rownum, facetable );
draw_face_row(row,facetable, ringtable, edgetable, fbr,
outline,c1,c2,c3,c4);
free_row(row,facetable);
}
/*
* Release memory used by rows
*/
int free_rows(db_res_t* _r)
{
int i;
if (!_r)
{
#ifdef DBT_EXTRA_DEBUG
LOG(L_ERR, "DBT:free_rows: Invalid parameter value\n");
#endif
return -1;
}
if (RES_ROWS(_r))
{
for(i = 0; i < RES_ROW_N(_r); i++)
{
free_row(&(RES_ROWS(_r)[i]));
}
pkg_free(RES_ROWS(_r));
}
return 0;
}
/*************************************************************************
*
*N named_table_element
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function returns the element in the specified row in the column
* matching the given field name. If the element is a single element
* (count=1), the value is passed back via the void pointer *value;
* otherwise, an array is allocated and passed back as the return value.
* NOTE: If an array is allocated in this function, it should be freed
* when no longer needed.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* field_name <input> == (char *) field name.
* row_number <input> == (ossim_int32) row_number.
* table <input> == (vpf_table_type) VPF table structure.
* value <output> == (void *) pointer to a single element value.
* count <output> == (ossim_int32 *) pointer to the array size for a multiple
* element value.
* return <output> == (void *) returned multiple element value.
* or NULL if field_name could not be found
* as a column
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels May 1991 DOS Turbo C
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* External Variables:
*X
* None
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Functions Called:
*F
* void *vpfmalloc() VPFREAD.C
* row_type get_row() VPFREAD.C
* void free_row() VPFREAD.C
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Portability:
*O
* This module should be ANSI C compatible.
*E
*************************************************************************/
void *named_table_element( char * field_name,
ossim_int32 row_number,
vpf_table_type table,
void * value,
ossim_int32 * count )
{
ossim_int32 col;
row_type row;
void * retvalue;
col = table_pos(field_name, table);
if (col < 0) {
fprintf(stderr,"%s: Invalid field name <%s>\n",table.name,field_name);
return NULL;
}
row = get_row(row_number,table);
retvalue = get_table_element( col, row, table, value, count );
free_row(row, table);
return retvalue;
}
/*************************************************************************
*
*N query_table
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function returns the set of selected rows of a VPF table
* based upon the evaluation of the given selection expression string.
*
* The expression is strictly evaluated left to right. No nesting
* is supported, so parentheses are not allowed. The expression
* must match the form:
* <field><log op><value> [ <join> <field><log op><value>]
* where,
* <field> is a valid field name of the table.
* <log op> is one of the following: =, <, >, <=, >=, <> (not equal).
* <value> is a valid value for the field.
* <join> is either " AND " or " OR ".
* Any number of clauses (<field><log op><value>) may be joined
* together with AND or OR to form the expression.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* expression <input>==(char *) selection expression string.
* table <input>==(vpf_table_type) VPF table structure.
* return <output>==(set_type) set of selected rows.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels May 1991 DOS Turbo C
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* External Variables:
*X
* None
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Functions Called:
*F
* set_type set_init( rspf_int32 n ) SET.C
* void set_insert( rspf_int32 element, set_type set ) SET.C
* linked_list_type parse_expression( char *expression,
* vpf_table_type table ) VPFQUERY.C
* row_type read_next_row( vpf_table_type table ) VPFREAD.C
* position_type ll_first( linked_list_type list ) LINKLIST.C
* int ll_end( position_type position ) LINKLIST.C
* void ll_element( position_type position, void *element ) LINKLIST.C
* void *get_table_element( rspf_int32 field_number,
* row_type row,
* vpf_table_type table,
* void *value,
* rspf_int32 *count ) VPFREAD.C
* void display_message( char *info ) USER DEFINED
* static int strcompare( char *val1, char *val2, char op ) VPFQUERY.C
* static int icompare( rspf_int32 val1, rspf_int32 val2, char op ) VPFQUERY.C
* static int fcompare( float val1, float val2, char op ) VPFQUERY.C
* void ll_reset( linked_list_type list ) LINKLIST.C
void free_row( row_type row, vpf_table_type table) VPFREAD.C
*E
*************************************************************************/
set_type query_table( char *expression, vpf_table_type table )
{
row_type row;
position_type pos;
expr_type expr;
register rspf_int32 i;
int boolval=FALSE, booltemp=0, join = OR;
rspf_int32 lval, lval2, count;
float fval, fval2;
char tval, tval2, *tptr;
linked_list_type exprlist;
set_type select_set;
select_set = set_init(table.nrows+1);
if (strcmp(expression,"*")==0) {
set_on(select_set);
return select_set;
}
exprlist = parse_expression( expression, table );
if (!exprlist) return select_set;
if (table.storage == DISK)
fseek( table.fp, index_pos(1,table), SEEK_SET );
for (i=1;i<=table.nrows;i++) {
if (table.storage == DISK)
row = read_next_row(table);
else
row = get_row( i, table );
pos = ll_first(exprlist);
while (!ll_end(pos)) {
ll_element( pos, &expr );
switch (table.header[expr.field].type) {
case 'I':
if (table.header[expr.field].count == 1) {
get_table_element( expr.field, row, table, &lval, &count );
lval2 = atol(expr.value);
booltemp = icompare( lval, lval2, expr.op );
} else {
display_message(
"Selection may not be performed upon arrays");
i=table.nrows+1;
}
break;
case 'T':
if (table.header[expr.field].count == 1) {
get_table_element( expr.field, row, table, &tval, &count );
tval2 = expr.value[0];
booltemp = comp( &tval, &tval2, sizeof(tval), expr.op );
} else {
tptr = (char *)get_table_element( expr.field, row, table,
NULL, &count );
booltemp = strcompare( tptr, expr.value, expr.op );
free(tptr);
}
break;
case 'F':
if (table.header[expr.field].count == 1) {
get_table_element( expr.field, row, table, &fval, &count );
if (!is_vpf_null_float(fval)) {
fval2 = (float)atof(expr.value);
booltemp = fcompare( fval, fval2, expr.op );
} else booltemp = FALSE;
} else {
display_message(
"Selection may not be performed upon arrays");
i=table.nrows+3;
}
break;
default:
display_message("Field type not supported for query");
i=table.nrows+3;
break;
}
if (i>table.nrows) break;
if (join==OR)
boolval = boolval || booltemp;
else
boolval = boolval && booltemp;
join = expr.join;
pos = pos->next;
}
free_row( row, table );
if (boolval) set_insert(i,select_set);
boolval = FALSE;
join = OR;
if (i==table.nrows+3) break;
}
ll_reset(exprlist);
return select_set;
}
bool ossimVpfBoundingRecordTable::openTable(const ossimFilename& tableName)
{
bool result = false;
theExtent = ossimVpfExtent(0,0,0,0);
bool firstOneSetFlag = false;
if(ossimVpfTable::openTable(tableName))
{
ossim_int32 xminIdx = getColumnPosition("XMIN");
ossim_int32 yminIdx = getColumnPosition("YMIN");
ossim_int32 xmaxIdx = getColumnPosition("XMAX");
ossim_int32 ymaxIdx = getColumnPosition("YMAX");
if((xminIdx < 0)||
(yminIdx < 0)||
(xmaxIdx < 0)||
(ymaxIdx < 0))
{
closeTable();
}
else
{
if(getNumberOfRows() > 0)
{
result = true;
reset();
ossim_int32 n = 1;
ossim_float32 xmin;
ossim_float32 ymin;
ossim_float32 xmax;
ossim_float32 ymax;
row_type row;
for(int rowIdx = 1; rowIdx < getNumberOfRows(); ++rowIdx)
{
if(rowIdx == 1)
{
row = read_row(rowIdx,
*theTableInformation);
}
else
{
row = read_next_row(*theTableInformation);
}
get_table_element(xminIdx,
row,
*theTableInformation,
&xmin,
&n);
get_table_element(yminIdx,
row,
*theTableInformation,
&ymin,
&n);
get_table_element(xmaxIdx,
row,
*theTableInformation,
&xmax,
&n);
get_table_element(ymaxIdx,
row,
*theTableInformation,
&ymax,
&n);
if(!is_vpf_null_float(xmin)&&
!is_vpf_null_float(ymin)&&
!is_vpf_null_float(xmax)&&
!is_vpf_null_float(ymax))
{
if(!firstOneSetFlag)
{
theExtent = ossimVpfExtent(xmin,
ymin,
xmax,
ymax);
firstOneSetFlag = true;
}
else
{
theExtent = theExtent + ossimVpfExtent(xmin,
ymin,
xmax,
ymax);
}
}
free_row(row, *theTableInformation);
}
}
}
}
return result;
}
/*************************************************************************
*
*N vpf_open_table
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function opens a vpf table and either loads it into RAM or sets
* up the structure to read off of disk.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* tablename <input> == (const char *) file name of the table.
* storage <input> == (storage_type) table storage mode -
* either ram or disk.
* mode <input> == (const char *) file mode for opening the table -
* same as fopen() mode in C.
* defstr <input> == (char *) table definition string used for
* creating a writable table.
* vpf_open_table <output> == (vpf_table_type) VPF table structure.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels April 1991 DOS Turbo C
* Dave Flinn July 1991 UNIX compatable
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* External Variables:
*X
* None
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Functions Called:
*F
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Portability:
*O
* This module should be ANSI C compatible.
*E
*************************************************************************/
vpf_table_type vpf_open_table( const char * tablename,
storage_type storage ,
const char * mode,
char * defstr )
{
vpf_table_type table;
char tablepath[255],
* idxname;
ossim_int32 i,
j;
ossim_int32 tablesize,
idxsize,
memsize;
ossim_uint32 ulval;
char * diskname = "VPF data disc";
strcpy(tablepath,tablename);
rightjust(tablepath);
/* Parse out name and path */
j = -1;
i=(long)strlen(tablepath);
while (i>0) {
#ifdef __MSDOS__
if (tablepath[i] == '\\') {
#else
if (tablepath[i] == '/') {
#endif
j = i;
break;
}
i--;
}
strncpy(table.name,&(tablepath[j+1]),12);
rightjust(table.name);
strupr(table.name);
table.path = (char *)vpfmalloc(((unsigned long)strlen(tablepath)+5)*(unsigned long)sizeof(char));
strcpy(table.path, tablepath);
table.path[j+1] = '\0';
/* Establish a read or write table operation */
if ( mode[0] == 'r' )
table.mode = Read ;
else
table.mode = Write ;
/*fprintf(stderr, "vpf_open_table opening %s\n", tablepath);*/
table.fp = vpfopencheck(tablepath,mode,diskname);
if (table.fp == NULL) {
perror(tablepath);
/*
#if __MSDOS__
perror(tablepath);
getch();
if (getgraphmode() >= 0) closegraph();
exit(0);
#endif
*/
free(table.path);
if (table.fp) {
fclose(table.fp);
table.fp = NULL;
}
return table;
}
/* If file is to be created, copy the def string ptr into header for now */
if ( table.mode == Write )
table.defstr = defstr ;
#ifdef __MSDOS__
tablesize = (filelength(fileno(table.fp)));
#else
{ /* UNIX doesn't have a filelength function, so this is the best */
struct stat statbuf ;
if ( stat ( tablepath, &statbuf ) < 0 ) {
fprintf (stderr, "vpf_open_table: can't stat file\n" ) ;
free(table.path);
fclose(table.fp);
table.fp = NULL;
return table;
}
tablesize = statbuf.st_size ;
}
#endif
/* Populate table structure with correct data, either for read or write */
table.reclen = parse_data_def(&table);
if ( table.mode == Write ) { /* write out header */
rewind ( table.fp ) ;
Write_Vpf_Int ( &table.ddlen, table.fp, 1 ) ;
Write_Vpf_Char ( table.defstr, table.fp, table.ddlen ) ;
free ( table.defstr ) ;
table.defstr = (char *) NULL ;
table.nrows = 0 ;
}
if (table.reclen > 0) { /* Index file */
table.xstorage = (storage_type)COMPUTE;
if (table.mode != Write)
table.nrows = (tablesize - table.ddlen)/table.reclen;
table.xfp = (FILE *) NULL ;
} else {
idxname = strdup( tablepath );
#ifdef __MSDOS__
idxname[strlen(tablepath)-1] = 'x';
#else
if (idxname[strlen(tablepath)-1] == '.')
idxname[strlen(tablepath)-2] = 'x';
else
idxname[strlen(tablepath)-1] = 'x';
#endif
table.xfp = fopen(idxname, mode);
if ((!table.xfp) && (table.mode == Read)) {
perror(idxname);
fprintf(stderr, "hit RETURN to continue...");
i=getc(stdin);
free(idxname);
for (i = 0; i < table.nfields; i++)
free(table.header[i].name);
free(table.header);
free(table.path);
fclose(table.fp);
table.fp = NULL;
return table;
}
free(idxname);
/*#ifdef __MSDOS__*/
table.xstorage = (storage_type)DISK; /* Worst case default */
/*#endif*/
/* Only read in index if file is read only */
if (table.xfp && ( table.mode == Read ) ) {
Read_Vpf_Int (&(table.nrows), table.xfp, 1 ) ;
Read_Vpf_Int (&ulval, table.xfp, 1 ) ;
idxsize = table.nrows*sizeof(index_cell) + 10L;
#ifdef __MSDOS__
if ( (idxsize < (farcoreleft()/2)) && (idxsize < __64K) )
#else
if (0)
#endif
{
table.xstorage = (storage_type)RAM;
table.index = (index_type)vpfmalloc(idxsize);
for (i=0;i<table.nrows;i++) {
Read_Vpf_Int (&(table.index[i].pos), table.xfp, 1) ;
Read_Vpf_Int (&(table.index[i].length),table.xfp,1 ) ;
}
fclose(table.xfp);
}
} else if (table.mode == Write) {
/* Write out dummy header record for index file. vpf_close_table finishes
the job. */
Write_Vpf_Int ( &(table.ddlen), table.xfp, 1 ) ;
Write_Vpf_Int ( &(table.ddlen), table.xfp, 1 ) ;
table.xstorage = (storage_type)DISK;
table.index = (index_type) NULL ;
}
} /* end of if table .reclen */
table.storage = (storage_type)DISK;
#ifdef __MSDOS__
memsize = (ossim_int32)min(farcoreleft(),__64K);
#else
memsize = MAXINT;
#endif
if ( (storage != disk) && ( table.mode == Read ) ) {
if (tablesize + table.nrows * table.nfields * HEAP_OVERHEAD < memsize) {
fseek(table.fp,index_pos(1,table),SEEK_SET);
table.row = (row_type *)vpfmalloc((table.nrows+1)*sizeof(row_type));
for (i=0;i<table.nrows;i++) {
table.row[i] = read_next_row(table);
}
fclose(table.fp);
table.storage = (storage_type)RAM;
}
}
table.status = OPENED;
return table;
}
/*************************************************************************
*
*N vpf_close_table
*
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* This function frees an entire table from memory.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* table <inout> == (vpf_table_type) VPF table structure.
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels May 1991 DOS Turbo C
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* External Variables:
*X
* None
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Functions Called:
*F
* None
*E
*::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Portability:
*O
* This module should be ANSI C compatible.
*E
*************************************************************************/
void vpf_close_table( vpf_table_type *table )
{
register ossim_int32 i;
if (table->status != OPENED) {
return;
}
/*fprintf(stderr, "vpf_close_table closing %s%s\n", table->path, table->name);*/
/* If the table is writable, write out the final record count */
if ( table->mode == Write && table->xfp ) {
rewind ( table->xfp ) ;
Write_Vpf_Int ( &table->nrows, table->xfp, 1 ) ;
Write_Vpf_Int ( &table->ddlen, table->xfp, 1 ) ;
}
for (i=0;i<table->nfields;i++) {
free(table->header[i].name);
/* free up null text string */
if ( table->header[i].type == 'T')
free(table->header[i].nullval.Char);
/* free up index file string */
if (table->header[i].tdx!=(char *)NULL)
free ( table->header[i].tdx ) ;
/* free up narrative table string */
if (table->header[i].narrative!=(char *)NULL) {
free ( table->header[i].narrative ) ;
}
}
free(table->header);
switch (table->storage) {
case RAM:
for (i=0;i<table->nrows;i++) free_row(table->row[i],*table);
free(table->row);
break;
case DISK:
fclose(table->fp);
break;
default:
printf("%s%s: unknown storage flag: %d\n",table->path,table->name,
table->storage);
break;
}
switch (table->xstorage) {
case RAM:
free(table->index);
break;
case DISK:
fclose(table->xfp);
break;
case COMPUTE:
break;
default:
printf("%s%s: unknown index storage flag: %d\n",
table->path,table->name,table->storage);
break;
}
table->nfields = 0;
free(table->path);
table->status = CLOSED;
}
ossim_int32 is_vpf_table( const char *fname )
{
FILE *fp;
ossim_int32 n, ok;
fp = fopen( fname, "rb" );
if (!fp) {
return FALSE;
}
Read_Vpf_Int ( &n, fp, 1 ) ;
fseek( fp, n-1, SEEK_CUR );
if (fgetc(fp) == ';')
ok = TRUE;
else
ok = FALSE;
fclose(fp);
return ok;
}
/**************************************************************************
*
*N fc_row_numbers
*
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* Given the starting row of a feature class relationship, return the
* list of row numbers of the table at the end of the feature class
* relate chain.
* If your relate goes from the feature to the primitive, this will
* return the primitive ids for the given feature row.
* If your relate goes from the primitive to the feature, this will
* return the feature ids of the given primitive row.
*
* Currently only supports relates on 'I' or 'K' fields.
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels DOS Turbo C
*E
*************************************************************************/
linked_list_type fc_row_numbers( row_type row,
fcrel_type fcrel,
long int tile,
ThematicIndex *idx )
{
row_type relrow;
long int count;
long int n, rownum, keyval;
id_triplet_type triplet_keyval;
int KEY1_, KEY_;
position_type p, prow, pkey;
vpf_relate_struct rcell;
linked_list_type rowlist, keylist, templist;
p = ll_first(fcrel.relate_list);
ll_element(p,&rcell);
KEY1_ = table_pos(rcell.key1,fcrel.table[0]);
get_table_element(0,row,fcrel.table[0],&rownum,&count);
if (KEY1_ == 0) { /* "ID" */
keyval = rownum;
} else {
switch (fcrel.table[0].header[KEY1_].type) {
case 'I':
get_table_element(KEY1_,row,fcrel.table[0],&keyval,&count);
break;
case 'K':
get_table_element(KEY1_,row,fcrel.table[0],&triplet_keyval,
&count);
keyval = triplet_keyval.exid;
if (tile != triplet_keyval.tile) {
keyval = -2;
}
break;
default:
keyval = 0;
break;
}
}
keylist = ll_init();
ll_insert(&keyval,sizeof(keyval),keylist);
n = 0;
p = ll_first(fcrel.relate_list);
for (n=1;n<(fcrel.nchain-1);n++) {
/* Relate through Join table(s) */
rowlist = ll_init();
pkey = ll_first(keylist);
while (!ll_end(pkey)) {
ll_element(pkey,&keyval);
templist = related_rows(&keyval,fcrel.table[n],rcell.key2,0,NULL);
prow = ll_first(templist);
while (!ll_end(prow)) {
ll_element(prow,&rownum);
if (!ll_locate(&rownum,rowlist))
ll_insert(&rownum,sizeof(rownum),ll_last(rowlist));
prow = ll_next(prow);
}
ll_reset(templist);
pkey = ll_next(pkey);
}
ll_reset(keylist);
p = ll_next(p);
ll_element(p,&rcell);
KEY_ = table_pos(rcell.key1,fcrel.table[n]);
keylist = ll_init();
prow = ll_first(rowlist);
while (!ll_end(prow)) {
ll_element(prow,&rownum);
relrow = get_row(rownum,fcrel.table[n]);
if (KEY_ == 0) { /* "ID" */
keyval = rownum;
} else {
switch (fcrel.table[n].header[KEY_].type) {
case 'I':
get_table_element(KEY_,relrow,fcrel.table[n],&keyval,&count);
break;
case 'K':
get_table_element(KEY_,relrow,fcrel.table[n],&triplet_keyval,
&count);
keyval = triplet_keyval.exid;
if (tile != triplet_keyval.tile) {
keyval = -2;
}
break;
default:
keyval = 0;
break;
}
}
if (keyval > 0)
ll_insert(&keyval,sizeof(keyval),ll_last(keylist));
prow = ll_next(prow);
free_row(relrow,fcrel.table[n]);
}
ll_reset(rowlist);
}
rowlist = ll_init();
p = ll_first(keylist);
while (!ll_end(p)) {
ll_element(p,&keyval);
templist = related_rows(&keyval,fcrel.table[n],rcell.key2,0,idx);
prow = ll_first(templist);
while (!ll_end(prow)) {
ll_element(prow,&rownum);
if (!ll_locate(&rownum,rowlist))
ll_insert(&rownum,sizeof(rownum),ll_last(rowlist));
prow = ll_next(prow);
}
ll_reset(templist);
p = ll_next(p);
}
ll_reset(keylist);
return rowlist;
}
/**************************************************************************
*
*N fc_row_number
*
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* Given the starting row of a feature class relationship, return the
* row number of the table at the end of the feature class relate
* chain.
* If your relate goes from the feature to the primitive, this will
* return the primitive id for the given feature row.
* If your relate goes from the primitive to the feature, this will
* return the feature id of the given primitive row.
*
* Currently only supports relates on 'I' or 'K' fields.
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels DOS Turbo C
*E
*************************************************************************/
long int fc_row_number( row_type row, fcrel_type fcrel, long int tile )
{
row_type relrow;
long int count;
long int i, rownum, keyval;
id_triplet_type triplet_keyval;
int KEY1_, KEY_;
position_type p;
vpf_relate_struct rcell;
p = ll_first(fcrel.relate_list);
ll_element(p,&rcell);
KEY1_ = table_pos(rcell.key1,fcrel.table[0]);
get_table_element(0,row,fcrel.table[0],&rownum,&count);
if (KEY1_ == 0) { /* "ID" */
keyval = rownum;
} else {
switch (fcrel.table[0].header[KEY1_].type) {
case 'I':
get_table_element(KEY1_,row,fcrel.table[0],&keyval,&count);
break;
case 'K':
get_table_element(KEY1_,row,fcrel.table[0],&triplet_keyval,
&count);
keyval = triplet_keyval.exid;
if (tile != triplet_keyval.tile) {
return -2;
}
break;
default:
keyval = 0;
break;
}
}
p = ll_first(fcrel.relate_list);
for (i=1;i<(fcrel.nchain-1);i++) {
/* Relate through Join table(s) */
rownum = related_row(&keyval,fcrel.table[i],rcell.key2,0);
relrow = get_row(rownum,fcrel.table[i]);
p = ll_next(p);
ll_element(p,&rcell);
KEY_ = table_pos(rcell.key1,fcrel.table[i]);
if (KEY_ == 0) { /* "ID" */
keyval = rownum;
} else {
switch (fcrel.table[i].header[KEY_].type) {
case 'I':
get_table_element(KEY_,relrow,fcrel.table[i],&keyval,&count);
break;
case 'K':
get_table_element(KEY_,relrow,fcrel.table[i],&triplet_keyval,
&count);
keyval = triplet_keyval.exid;
if (tile != triplet_keyval.tile) {
return -2;
}
break;
default:
keyval = 0;
break;
}
}
free_row(relrow,fcrel.table[i]);
}
if (ossim_strcasecmp(rcell.key2,"ID")==0)
rownum = keyval;
else
rownum = related_row(&keyval,fcrel.table[i],rcell.key2,0);
return rownum;
}
/**************************************************************************
*
*N related_rows
*
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* Return the list of related rows of table2 based upon the value of
* table 1's key.
* Supported data types - I and T<n>.
* Binary search supported only for data type I. (column must be sorted)
* Thematic index used, if present on key column.
* NOTE: A sequential search operation will search the entire
* table ...zzz...
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels DOS Turbo C
*E
*************************************************************************/
linked_list_type related_rows( void *keyval1,
vpf_table_type table2, char *key2,
int sort_flag,
ThematicIndex *idx )
{
linked_list_type rowlist;
set_type rowset;
long int rowid, i, ival, kval, n, start,end;
row_type row = 0;
int KEY2_;
char cval, *tval;
rowlist = ll_init();
if (ossim_strcasecmp(key2,"ID")==0) {
memcpy( &rowid, keyval1, sizeof(rowid) );
ll_insert(&rowid,sizeof(rowid),rowlist);
return rowlist;
}
KEY2_ = table_pos(key2,table2);
if ((table2.header[KEY2_].type != 'I')&&
(table2.header[KEY2_].type != 'T')) return rowlist;
if ((table2.header[KEY2_].type == 'I')&&
(table2.header[KEY2_].count != 1)) return rowlist;
if ((table2.header[KEY2_].type == 'T')&&(sort_flag)) sort_flag = 0;
if (idx) {
if (idx->fp) {
rowset = search_thematic_index(idx,(char *)keyval1);
start = set_min(rowset);
end = set_max(rowset);
for (i=start;i<=end;i++)
if (set_member(i,rowset)) {
ll_insert(&i,sizeof(i),ll_last(rowlist));
}
set_nuke(&rowset);
return rowlist;
}
}
if (!sort_flag) { /* Sequential search */
for (i=1;i<=table2.nrows;i++) {
row = get_row(i,table2);
if (table2.header[KEY2_].type == 'I') {
get_table_element(KEY2_,row,table2,&ival,&n);
if (memcmp(&ival,keyval1,sizeof(ival))==0)
ll_insert(&i,sizeof(i),ll_last(rowlist));
} else {
if (table2.header[KEY2_].count==1) {
get_table_element(KEY2_,row,table2,&cval,&n);
if (memcmp(&cval,keyval1,sizeof(ival))==0)
ll_insert(&i,sizeof(i),ll_last(rowlist));
} else {
tval = (char*)get_table_element(KEY2_,row,table2,NULL,&n);
if (strcmp(tval,(char *)keyval1)==0)
ll_insert(&i,sizeof(i),ll_last(rowlist));
}
}
free_row(row,table2);
}
} else { /* Binary search */
memcpy(&kval,keyval1,sizeof(kval));
rowid = vpf_binary_search( kval, KEY2_, table2 );
if (rowid > 0) {
ll_insert(&rowid,sizeof(rowid),ll_last(rowlist));
i = rowid-1L;
do {
get_row(i,table2);
get_table_element(KEY2_,row,table2,&ival,&n);
if (ival == kval)
ll_insert(&i,sizeof(i),ll_last(rowlist));
i--;
} while ((ival==kval)&&(i>0));
i = rowid+1L;
do {
get_row(i,table2);
get_table_element(KEY2_,row,table2,&ival,&n);
if (ival == kval)
ll_insert(&i,sizeof(i),ll_last(rowlist));
i++;
} while ((ival==kval)&&(i<=table2.nrows));
}
}
return rowlist;
}
/**************************************************************************
*
*N fcs_relate_list
*
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* Read the feature class schema table and create the list of
* tables to chain through.
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* fcname <input> == (char *) feature class name.
* start_table <input> == (char *) table to start from.
* end_table <input> == (char *) table to end with.
* fcs <input> == (vpf_table_type) feature class schema table.
* fcs_relate_list <output> == (linked_list_type) list of tables to
* chain through.
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels DOS Turbo C
*E
*************************************************************************/
linked_list_type fcs_relate_list( char *fcname, char *start_table,
char *end_table, vpf_table_type fcs )
{
linked_list_type rlist;
vpf_relate_struct rstruct;
set_type fcset, set1, set2;
char tablename[255], *buf, expr[255];
row_type row;
long int rownum,n;
int TABLE1_, KEY1_, TABLE2_, KEY2_;
rlist = ll_init();
sprintf(expr,"FEATURE_CLASS = %s",fcname);
fcset = query_table(expr,fcs);
if (set_empty(fcset)) {
set_nuke(&fcset);
return rlist;
}
TABLE1_ = table_pos("TABLE1",fcs);
KEY1_ = table_pos("FOREIGN_KEY",fcs);
if (KEY1_ < 0) KEY1_ = table_pos("TABLE1_KEY",fcs);
TABLE2_ = table_pos("TABLE2",fcs);
KEY2_ = table_pos("PRIMARY_KEY",fcs);
if (KEY2_ < 0) KEY2_ = table_pos("TABLE2_KEY",fcs);
strcpy( tablename, start_table );
while (1) {
sprintf(expr,"TABLE1 = %s",tablename);
set1 = query_table(expr,fcs);
set2 = set_intersection(set1,fcset);
set_nuke(&set1);
if (set_empty(set2)) {
set_nuke(&fcset);
set_nuke(&set2);
return rlist;
}
rownum = set_min(set2);
set_nuke(&set2);
row = get_row(rownum,fcs);
buf = (char *)get_table_element(TABLE1_,row,fcs,NULL,&n);
strcpy(rstruct.table1,buf);
rightjust(rstruct.table1);
free(buf);
buf = (char *)get_table_element(KEY1_,row,fcs,NULL,&n);
strcpy(rstruct.key1,buf);
rightjust(rstruct.key1);
free(buf);
buf = (char *)get_table_element(TABLE2_,row,fcs,NULL,&n);
strcpy(rstruct.table2,buf);
rightjust(rstruct.table2);
free(buf);
buf = (char *)get_table_element(KEY2_,row,fcs,NULL,&n);
strcpy(rstruct.key2,buf);
rightjust(rstruct.key2);
free(buf);
rstruct.degree = R_ONE; /* Default */
free_row( row, fcs );
if (table_in_list(rstruct.table1, rlist)) break;
ll_insert( &rstruct, sizeof(rstruct), ll_last(rlist) );
strcpy( tablename, rstruct.table2 );
if (ossim_strcasecmp(tablename,end_table)==0) break;
}
set_nuke(&fcset);
return rlist;
}
int main(int argc, char **argv)
{
if (argc > 1 && strcmp(argv[1], "--help") == 0) {
printf("Help!\n");
exit(0);
}
if (argc > 1 && strcmp(argv[1], "--version") == 0) {
pq_display_version();
exit(0);
}
int i;
int frm_multi;
const char *cmd_defaults;
struct SWrap Stat;
void (*swrap_init)(struct SWrap *, int);
frm_multi = PQ_PNDS_FRMT;
swrap_init = PQ_PNDS_INIT;
cmd_defaults = PQ_PNDS_DEFS;
char *fname_aa;
char *fname_syn;
char default_fname_aa[] = "codon2aa";
char default_fname_syn[] = "codon2syn";
char default_fullpath_aa[1028];
char default_fullpath_syn[1028];
sprintf(default_fullpath_aa, "%s/%s", DATADIR, default_fname_aa);
sprintf(default_fullpath_syn, "%s/%s", DATADIR, default_fname_syn);
fname_aa = default_fullpath_aa;
fname_syn = default_fullpath_syn;
file2charHash(fname_aa, 128);
file2doubleHash(fname_syn, 128);
FILE *fp;
int nargs;
char **def_array;
char defaults[128];
int ncols;
int nalleles;
char buffer[PQ_LWIDTH];
char delim = '\t';
char chr[PQ_LCOL];
char factor[PQ_LCOL];
unsigned long long int startpos;
unsigned long long int stoppos;
unsigned long long int start_region;
unsigned long long int stop_region;
struct GenericRow row;
int argc_wo_file;
fp = stdin;
argc_wo_file = argc;
if (argc > 1 && access(argv[argc - 1], F_OK) != -1) {
fp = fopen(argv[argc - 1], "r");
argc_wo_file = argc - 1;
}
fgets(buffer, sizeof(buffer), fp);
// add defaults but with dummy -k variable
sprintf(defaults, cmd_defaults, 6);
nargs = pq_countcols(defaults, " ");
def_array = calloc(nargs, sizeof(char *));
pq_str2array(def_array, defaults, nargs, " ");
pq_init_args();
pq_update_args(nargs, def_array);
pq_update_args(argc_wo_file-1, argv+1);
// space delimeters must be escaped on the command line (i.e. -d '\ ')
delim = ((char *)pq_lookup_hash(&ARGHASH, "-d"))[1];
ncols = pq_countcols(buffer, &delim);
sprintf(defaults, cmd_defaults, ncols);
pq_str2array(def_array, defaults, nargs, " ");
pq_update_args(nargs, def_array);
pq_update_args(argc_wo_file-1, argv+1);
free(def_array);
init_row(&row, ncols, CHROM, POS, FCOL);
nalleles = frm_multi * NKARGS;
swrap_init(&Stat, nalleles);
row.update(&row, buffer, &delim);
strcpy(chr, row.chrom(&row));
strcpy(factor, row.factor(&row));
start_region = row.pos(&row) - 1;
goto POST_INIT;
while (fgets(buffer, sizeof(buffer), fp)) {
row.update(&row, buffer, &delim);
POST_INIT:
stoppos = row.pos(&row);
startpos = stoppos - 1;
if (strcmp(row.factor(&row), factor) != 0) {
Stat.write(&Stat);
printf("%s\t%llu\t%llu\t%s", chr, start_region, stop_region, factor);
for (i = 0; i < Stat.nouts; i++) {
printf("\t%s", (char *)Stat.outs[i]);
}
printf("\n");
Stat.clear(&Stat);
strcpy(factor, row.factor(&row));
start_region = startpos;
stop_region = stoppos;
}
Stat.update(&Stat, row.array);
stop_region = stoppos;
strcpy(chr, row.chrom(&row));
}
Stat.write(&Stat);
printf("%s\t%llu\t%llu\t%s", chr, start_region, stop_region, factor);
for (i = 0; i < Stat.nouts; i++) {
printf("\t%s", (char *)Stat.outs[i]);
}
printf("\n");
Stat.clear(&Stat);
pq_free_hash(&CODON_TO_NSYN);
pq_free_hash(&CODON_TO_AMINO);
pq_free_args();
pq_swfree(&Stat);
free_row(&row);
fclose(fp);
return 0;
}
/**************************************************************************
*
*N vpf_dump_table
*
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Purpose:
*P
* Dump the contents of a VPF table into an ASCII file
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* Parameters:
*A
* tablename <input> == (char *) VPF table to dump.
* outname <input> == (char *) name of ASCII dump file.
*E
*:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
*
* History:
*H
* Barry Michaels DOS Turbo C
*E
*************************************************************************/
void vpf_dump_table( char *tablename, char *outname )
{
vpf_table_type table;
long int i,j,k,n;
int ival,*iptr;
long int lval,*lptr;
float fval,*fptr;
date_type dval,*dptr;
id_triplet_type kval, *kptr;
coordinate_type cval, *cptr;
char *buf, ch, date[40];
row_type row;
FILE *fp;
fp = fopen(outname,"w");
table = vpf_open_table(tablename,disk,"rb",NULL);
fprintf(fp,"%s\n%s\n\n",tablename,table.description);
fprintf(fp,"Definition:\n");
for (i=0;i<table.nfields;i++) {
if (table.header[i].count < 0)
fprintf(fp,"%s (%c,*) %s\n",
table.header[i].name,table.header[i].type,
table.header[i].description);
else
fprintf(fp,"%s (%c,%ld) %s\n",
table.header[i].name,table.header[i].type,
table.header[i].count,table.header[i].description);
}
fprintf(fp,"\nContents:\n");
for (i=1;i<=table.nrows;i++) {
row = read_next_row(table);
for (j=0;j<table.nfields;j++) {
fprintf(fp,"%s: ",table.header[j].name);
switch (table.header[j].type) {
case 'T':
if (table.header[j].count==1) {
get_table_element(j,row,table,&ch,&n);
fprintf(fp,"%c\n",ch);
} else {
buf = (char *)get_table_element(j,row,table,NULL,&n);
n = (long)strlen(table.header[j].name) + 2;
for (k=0;(unsigned int)k<strlen(buf);k++) {
fprintf(fp,"%c",buf[k]);
n++;
if (n>80) {
fprintf(fp,"\n");
n = 0;
}
}
fprintf(fp,"\n");
free(buf);
}
break;
case 'I':
if (table.header[j].count==1) {
get_table_element(j,row,table,&lval,&n);
if (lval != MAXFLOAT)
fprintf(fp,"%ld\n",lval);
else
fprintf(fp,"(null)\n");
} else {
lptr = (long int*)get_table_element(j,row,table,NULL,&n);
for (k=0;k<n;k++) {
if (lptr[k] != MAXFLOAT)
fprintf(fp,"%ld ",lptr[k]);
else
fprintf(fp,"(null) ");
}
fprintf(fp,"\n");
free(lptr);
}
break;
case 'S':
if (table.header[j].count==1) {
get_table_element(j,row,table,&ival,&n);
if (ival != MAXINT)
fprintf(fp,"%d\n",ival);
else
fprintf(fp,"(null)\n");
} else {
iptr = (int*)get_table_element(j,row,table,NULL,&n);
for (k=0;k<n;k++) {
if (iptr[k] != MAXINT)
fprintf(fp,"%d ",iptr[k]);
else
fprintf(fp,"(null) ");
}
fprintf(fp,"\n");
free(iptr);
}
break;
case 'F':
if (table.header[j].count==1) {
get_table_element(j,row,table,&fval,&n);
if (fval != MAXFLOAT)
fprintf(fp,"%f\n",fval);
else
fprintf(fp,"(null)\n");
} else {
fptr = (float*)get_table_element(j,row,table,NULL,&n);
for (k=0;k<n;k++) {
if (fptr[k] != MAXFLOAT)
fprintf(fp,"%f ",fptr[k]);
else
fprintf(fp,"(null) ");
}
fprintf(fp,"\n");
free(fptr);
}
break;
case 'C':
if (table.header[j].count==1) {
get_table_element(j,row,table,&cval,&n);
fprintf(fp,"(%f,%f)\n",cval.x,cval.y);
} else {
cptr = (coordinate_type*)get_table_element(j,row,table,NULL,&n);
for (k=0;k<n;k++)
fprintf(fp,"(%f,%f) ",cptr[k].x,cptr[k].y);
fprintf(fp,"\n");
free(cptr);
}
break;
case 'K':
if (table.header[j].count==1) {
get_table_element(j,row,table,&kval,&n);
fprintf(fp,"(%ld,%ld,%ld)\n",
kval.id,kval.tile,kval.exid);
} else {
kptr = (id_triplet_type*)get_table_element(j,row,table,NULL,&n);
for (k=0;k<n;k++)
fprintf(fp,"(%ld,%ld,%ld) ",
kptr[k].id,kptr[k].tile,kptr[k].exid);
fprintf(fp,"\n");
free(kptr);
}
break;
case 'D': /* Date */
if (table.header[j].count==1) {
get_table_element(j,row,table,&dval,&n);
format_date(dval,date);
fprintf(fp,"%s\n",date);
} else {
dptr = (date_type*)get_table_element(j,row,table,NULL,&n);
for (k=0;k<n;k++) {
format_date((char*)(&dptr[k]),date);
fprintf(fp,"%s ",date);
}
fprintf(fp,"\n");
free(dptr);
}
break;
}
}
fprintf(fp,"\n");
free_row( row, table );
}
fclose(fp);
vpf_close_table( &table );
}
