inline Tags parseTags(DBFHandle dbfFile, int k) const { char title[12]; int fieldCount = DBFGetFieldCount(dbfFile); Tags tags; tags.reserve(fieldCount); for (int i = 0; i < fieldCount; i++) { if (DBFIsAttributeNULL(dbfFile, k, i)) continue; utymap::formats::Tag tag; int width, decimals; DBFFieldType eType = DBFGetFieldInfo(dbfFile, i, title, &width, &decimals); tag.key = std::string(title); { switch (eType) { case FTString: tag.value = DBFReadStringAttribute(dbfFile, k, i); break; case FTInteger: tag.value = to_string(DBFReadIntegerAttribute(dbfFile, k, i)); break; case FTDouble: tag.value = to_string(DBFReadDoubleAttribute(dbfFile, k, i)); break; default: break; } } tags.push_back(tag); } return std::move(tags); }
bool compareDBF(DBFHandle iDBF, int iRecord, DBFHandle jDBF, int jRecord, bool print) { int i,j; int temp; bool result; DBFFieldType eType; char szTitle[12]; // Column heading int nWidth, nDecimals; result = false; for( i = 0; i < DBFGetFieldCount(iDBF); i++ ) { j = columnMatchArray[i]; if( j < 0 ) continue; eType = DBFGetFieldInfo( iDBF, i, szTitle, &nWidth, &nDecimals ); assert( nWidth < BUFFER_MAX ); memcpy( &iBuffer, DBFReadStringAttribute( iDBF, iRecord, i ), nWidth ); memcpy( &jBuffer, DBFReadStringAttribute( jDBF, jRecord, j ), nWidth ); /* Convert numbers, compare everything else as a string */ if( eType == FTDouble ) temp = (atof( iBuffer ) != atof( jBuffer ) ); else if( eType == FTInteger ) temp = (atoi( iBuffer ) != atoi( jBuffer ) ); else temp = memcmp ( &iBuffer, &jBuffer, nWidth ); /* Unless they are both NULL, flag record as different */ if( temp ) { result = true; if( DBFIsAttributeNULL( iDBF, iRecord, i ) && DBFIsAttributeNULL( jDBF, jRecord, j ) ) result = false; } if( temp && print ) { //printf("%d wide record %d and %d differ (etype=%d)\n", nWidth, iRecord, jRecord, eType ); iBuffer[ nWidth ] = 0; jBuffer[ nWidth ] = 0; printf("%s: %s >>> %s\n", szTitle, &iBuffer, &jBuffer); } } return( result ); }
static Tcl_Obj * NewAttributeObj (DBFHandle const dbfHandle, int const record, int const field) { if (DBFIsAttributeNULL (dbfHandle, record, field)) { return Tcl_NewObj (); } switch (DBFGetFieldInfo (dbfHandle, field, NULL, NULL, NULL)) { case FTInteger: return Tcl_NewIntObj (DBFReadIntegerAttribute (dbfHandle, record, field)); case FTDouble: return Tcl_NewDoubleObj (DBFReadDoubleAttribute (dbfHandle, record, field)); default: return Tcl_NewStringObj (DBFReadStringAttribute (dbfHandle, record, field), -1); } }
static void SetAttributeObj (Tcl_Obj * const objPtr, DBFHandle const dbfHandle, int const record, int const field) { if (DBFIsAttributeNULL (dbfHandle, record, field)) { return; } switch (DBFGetFieldInfo (dbfHandle, field, NULL, NULL, NULL)) { case FTInteger: Tcl_SetIntObj (objPtr, DBFReadIntegerAttribute (dbfHandle, record, field)); break; case FTDouble: Tcl_SetDoubleObj (objPtr, DBFReadDoubleAttribute (dbfHandle, record, field)); break; default: Tcl_SetStringObj (objPtr, DBFReadStringAttribute (dbfHandle, record, field), -1); } }
int main( int argc, char ** argv ) { DBFHandle hDBF; int *panWidth, i, iRecord; char szFormat[32], *pszFilename = NULL; int nWidth, nDecimals; int bHeader = 0; int bRaw = 0; int bMultiLine = 0; char szTitle[12]; /* -------------------------------------------------------------------- */ /* Handle arguments. */ /* -------------------------------------------------------------------- */ for( i = 1; i < argc; i++ ) { if( strcmp(argv[i],"-h") == 0 ) bHeader = 1; else if( strcmp(argv[i],"-r") == 0 ) bRaw = 1; else if( strcmp(argv[i],"-m") == 0 ) bMultiLine = 1; else pszFilename = argv[i]; } /* -------------------------------------------------------------------- */ /* Display a usage message. */ /* -------------------------------------------------------------------- */ if( pszFilename == NULL ) { printf( "dbfdump [-h] [-r] [-m] xbase_file\n" ); printf( " -h: Write header info (field descriptions)\n" ); printf( " -r: Write raw field info, numeric values not reformatted\n" ); printf( " -m: Multiline, one line per field.\n" ); exit( 1 ); } /* -------------------------------------------------------------------- */ /* Open the file. */ /* -------------------------------------------------------------------- */ hDBF = DBFOpen( pszFilename, "rb" ); if( hDBF == NULL ) { printf( "DBFOpen(%s,\"r\") failed.\n", argv[1] ); exit( 2 ); } /* -------------------------------------------------------------------- */ /* If there is no data in this file let the user know. */ /* -------------------------------------------------------------------- */ if( DBFGetFieldCount(hDBF) == 0 ) { printf( "There are no fields in this table!\n" ); exit( 3 ); } /* -------------------------------------------------------------------- */ /* Dump header definitions. */ /* -------------------------------------------------------------------- */ if( bHeader ) { for( i = 0; i < DBFGetFieldCount(hDBF); i++ ) { DBFFieldType eType; const char *pszTypeName; eType = DBFGetFieldInfo( hDBF, i, szTitle, &nWidth, &nDecimals ); if( eType == FTString ) pszTypeName = "String"; else if( eType == FTInteger ) pszTypeName = "Integer"; else if( eType == FTDouble ) pszTypeName = "Double"; else if( eType == FTInvalid ) pszTypeName = "Invalid"; printf( "Field %d: Type=%s, Title=`%s', Width=%d, Decimals=%d\n", i, pszTypeName, szTitle, nWidth, nDecimals ); } } /* -------------------------------------------------------------------- */ /* Compute offsets to use when printing each of the field */ /* values. We make each field as wide as the field title+1, or */ /* the field value + 1. */ /* -------------------------------------------------------------------- */ panWidth = (int *) malloc( DBFGetFieldCount( hDBF ) * sizeof(int) ); for( i = 0; i < DBFGetFieldCount(hDBF) && !bMultiLine; i++ ) { DBFFieldType eType; eType = DBFGetFieldInfo( hDBF, i, szTitle, &nWidth, &nDecimals ); if( strlen(szTitle) > nWidth ) panWidth[i] = strlen(szTitle); else panWidth[i] = nWidth; if( eType == FTString ) sprintf( szFormat, "%%-%ds ", panWidth[i] ); else sprintf( szFormat, "%%%ds ", panWidth[i] ); printf( szFormat, szTitle ); } printf( "\n" ); /* -------------------------------------------------------------------- */ /* Read all the records */ /* -------------------------------------------------------------------- */ for( iRecord = 0; iRecord < DBFGetRecordCount(hDBF); iRecord++ ) { if( bMultiLine ) printf( "Record: %d\n", iRecord ); for( i = 0; i < DBFGetFieldCount(hDBF); i++ ) { DBFFieldType eType; eType = DBFGetFieldInfo( hDBF, i, szTitle, &nWidth, &nDecimals ); if( bMultiLine ) { printf( "%s: ", szTitle ); } /* -------------------------------------------------------------------- */ /* Print the record according to the type and formatting */ /* information implicit in the DBF field description. */ /* -------------------------------------------------------------------- */ if( !bRaw ) { if( DBFIsAttributeNULL( hDBF, iRecord, i ) ) { if( eType == FTString ) sprintf( szFormat, "%%-%ds", nWidth ); else sprintf( szFormat, "%%%ds", nWidth ); printf( szFormat, "(NULL)" ); } else { switch( eType ) { case FTString: sprintf( szFormat, "%%-%ds", nWidth ); printf( szFormat, DBFReadStringAttribute( hDBF, iRecord, i ) ); break; case FTInteger: sprintf( szFormat, "%%%dd", nWidth ); printf( szFormat, DBFReadIntegerAttribute( hDBF, iRecord, i ) ); break; case FTDouble: sprintf( szFormat, "%%%d.%dlf", nWidth, nDecimals ); printf( szFormat, DBFReadDoubleAttribute( hDBF, iRecord, i ) ); break; default: break; } } } /* -------------------------------------------------------------------- */ /* Just dump in raw form (as formatted in the file). */ /* -------------------------------------------------------------------- */ else { sprintf( szFormat, "%%-%ds", nWidth ); printf( szFormat, DBFReadStringAttribute( hDBF, iRecord, i ) ); } /* -------------------------------------------------------------------- */ /* Write out any extra spaces required to pad out the field */ /* width. */ /* -------------------------------------------------------------------- */ if( !bMultiLine ) { sprintf( szFormat, "%%%ds", panWidth[i] - nWidth + 1 ); printf( szFormat, "" ); } if( bMultiLine ) printf( "\n" ); fflush( stdout ); } printf( "\n" ); } DBFClose( hDBF ); return( 0 ); }
//---------------------------------------------------------------------------- int ShapefileReader::RequestData( vtkInformation* vtkNotUsed( request ), vtkInformationVector** vtkNotUsed(inputVector), vtkInformationVector* outputVector) { vtkInformation* outInfo = outputVector->GetInformationObject(0); vtkPolyData* polydata = vtkPolyData::SafeDownCast(outInfo->Get(vtkDataObject::DATA_OBJECT())); if (illegalFileName()){ return 0; } if (incompleteSrcFiles()){ return 0; } SHPHandle shpHandle = SHPOpen(this->FileName, "rb"); int fileType = 0; if (shpHandle == NULL){ vtkErrorMacro("shp file read failed."); return 0; } vtkDebugMacro("file type: " << shpHandle->nShapeType); switch (shpHandle->nShapeType) { case SHPT_NULL: vtkErrorMacro("NULL Object type." << this->FileName); SHPClose(shpHandle); return 0; break; case SHPT_POINT: case SHPT_POINTZ: case SHPT_POINTM: case SHPT_MULTIPOINT: case SHPT_MULTIPOINTZ: case SHPT_MULTIPOINTM: fileType = POINTOBJ; break; case SHPT_ARC: case SHPT_ARCZ: case SHPT_ARCM: fileType = LINEOBJ; break; case SHPT_POLYGON: case SHPT_POLYGONZ: case SHPT_POLYGONM: fileType = FACEOBJ; break; case SHPT_MULTIPATCH: fileType = MESHOBJ; break; default: vtkErrorMacro("Unknown Object type." << this->FileName); SHPClose(shpHandle); return 0; } int pCount=0, pStart=0, pEnd=0; int vTracker = 0, pid=0; SHPObject* shpObj; vtkSmartPointer<vtkPoints> pts = vtkSmartPointer<vtkPoints>::New(); vtkSmartPointer<vtkCellArray> polys = vtkSmartPointer<vtkCellArray>::New(); vtkSmartPointer<vtkCellArray> strips = vtkSmartPointer<vtkCellArray>::New(); vtkSmartPointer<vtkCellArray> pLines = vtkSmartPointer<vtkCellArray>::New(); vtkSmartPointer<vtkCellArray> verts = vtkSmartPointer<vtkCellArray>::New(); vtkSmartPointer<vtkTriangleFilter> tFilter = vtkSmartPointer<vtkTriangleFilter>::New(); vtkSmartPointer<vtkStripper> stripper = vtkSmartPointer<vtkStripper>::New(); vtkSmartPointer<vtkPolyData> pdRaw = vtkSmartPointer<vtkPolyData>::New(); vtkSmartPointer<vtkPolyData> pdRefined = vtkSmartPointer<vtkPolyData>::New(); //looping through all records in file for (int rIndex = 0; rIndex < shpHandle->nRecords; rIndex++){ shpObj = SHPReadObject(shpHandle, rIndex); //making sure shp object type is consistent with file type if (shpObj->nSHPType != shpHandle->nShapeType){ vtkErrorMacro("Inconsistent shape type of record: " << rIndex << " in file " << this->FileName); continue; } pCount = shpObj->nParts; switch (fileType){ case POINTOBJ:{ vtkIdType *ids = new vtkIdType[shpObj->nVertices]; for (int vIndex = 0; vIndex < shpObj->nVertices; vIndex++){ pts->InsertPoint(pid,shpObj->padfX[vIndex], shpObj->padfY[vIndex], shpObj->padfZ[vIndex]); ids[vIndex] = pid++; } verts->InsertNextCell(shpObj->nVertices, ids); delete ids; ids = NULL; break; } case LINEOBJ:{ for (int pIndex = 0; pIndex < pCount; pIndex++){ pStart = shpObj->panPartStart[pIndex]; if (pIndex == (pCount-1)){ pEnd = shpObj->nVertices; }else{ pEnd = shpObj->panPartStart[pIndex+1]; } vtkSmartPointer<vtkPolyLine> pLine = vtkSmartPointer<vtkPolyLine>::New(); pLine->GetPointIds()->SetNumberOfIds(pEnd-pStart); for (int vIndex = pStart; vIndex < pEnd; vIndex++){ pts->InsertNextPoint(shpObj->padfX[vIndex], shpObj->padfY[vIndex], shpObj->padfZ[vIndex]); pLine->GetPointIds()->SetId(vIndex-pStart, vTracker+vIndex-pStart); } pLines->InsertNextCell(pLine); vTracker += pEnd-pStart; } break; } case FACEOBJ:{ for (int pIndex = 0; pIndex < pCount; pIndex++){ pStart = shpObj->panPartStart[pIndex]; if (pIndex == (pCount-1)){ pEnd = shpObj->nVertices; }else{ pEnd = shpObj->panPartStart[pIndex+1]; } vtkSmartPointer<vtkPolygon> poly = vtkSmartPointer<vtkPolygon>::New(); vtkSmartPointer<vtkPolyLine> pLine = vtkSmartPointer<vtkPolyLine>::New(); poly->GetPointIds()->SetNumberOfIds(pEnd-pStart); pLine->GetPointIds()->SetNumberOfIds(pEnd-pStart); for (int vIndex = pStart; vIndex < pEnd; vIndex++){ pts->InsertNextPoint(shpObj->padfX[vIndex], shpObj->padfY[vIndex], shpObj->padfZ[vIndex]); poly->GetPointIds()->SetId(vIndex-pStart, vTracker+vIndex-pStart); pLine->GetPointIds()->SetId(vIndex-pStart, vTracker+vIndex-pStart); } polys->InsertNextCell(poly); pLines->InsertNextCell(pLine); vTracker += pEnd-pStart; } break; } case MESHOBJ:{ switch (*(shpObj->panPartType)){ case SHPP_TRISTRIP:{ for (int pIndex = 0; pIndex < pCount; pIndex++){ pStart = shpObj->panPartStart[pIndex]; if (pIndex == (pCount-1)){ pEnd = shpObj->nVertices; }else{ pEnd = shpObj->panPartStart[pIndex+1]; } vtkSmartPointer<vtkTriangleStrip> strip = vtkSmartPointer<vtkTriangleStrip>::New(); strip->GetPointIds()->SetNumberOfIds(pEnd-pStart); for (int vIndex = pStart; vIndex < pEnd; vIndex++){ pts->InsertNextPoint(shpObj->padfX[vIndex], shpObj->padfY[vIndex], shpObj->padfZ[vIndex]); strip->GetPointIds()->SetId(vIndex-pStart, vTracker+vIndex-pStart); } strips->InsertNextCell(strip); vTracker += pEnd-pStart; } break; }//SHPP_TRISTRIP case SHPP_TRIFAN:{ for (int pIndex = 0; pIndex < pCount; pIndex++){ pStart = shpObj->panPartStart[pIndex]; if (pIndex == (pCount-1)){ pEnd = shpObj->nVertices; }else{ pEnd = shpObj->panPartStart[pIndex+1]; } vtkSmartPointer<vtkTriangleStrip> strip = vtkSmartPointer<vtkTriangleStrip>::New(); strip->GetPointIds()->SetNumberOfIds(pEnd-pStart); for (int vIndex = pStart; vIndex < pEnd; vIndex++){ pts->InsertNextPoint(shpObj->padfX[vIndex], shpObj->padfY[vIndex], shpObj->padfZ[vIndex]); strip->GetPointIds()->SetId(vIndex-pStart, vTracker+vIndex-pStart); } strips->InsertNextCell(strip); vTracker += pEnd-pStart; } break; }//SHPP_TRIFAN case SHPP_OUTERRING: case SHPP_INNERRING: case SHPP_FIRSTRING: case SHPP_RING:{ for (int pIndex = 0; pIndex < pCount; pIndex++){ pStart = shpObj->panPartStart[pIndex]; if (pIndex == (pCount-1)){ pEnd = shpObj->nVertices; }else{ pEnd = shpObj->panPartStart[pIndex+1]; } vtkSmartPointer<vtkPolygon> poly = vtkSmartPointer<vtkPolygon>::New(); vtkSmartPointer<vtkPolyLine> pLine = vtkSmartPointer<vtkPolyLine>::New(); poly->GetPointIds()->SetNumberOfIds(pEnd-pStart); pLine->GetPointIds()->SetNumberOfIds(pEnd-pStart); for (int vIndex = pStart; vIndex < pEnd; vIndex++){ pts->InsertNextPoint(shpObj->padfX[vIndex], shpObj->padfY[vIndex], shpObj->padfZ[vIndex]); poly->GetPointIds()->SetId(vIndex-pStart, vTracker+vIndex-pStart); pLine->GetPointIds()->SetId(vIndex-pStart, vTracker+vIndex-pStart); } polys->InsertNextCell(poly); pLines->InsertNextCell(pLine); vTracker += pEnd-pStart; } break; }//rings }//panPartType break; }//MESHOBJ }//fileType SHPDestroyObject(shpObj); }// rIndex SHPClose(shpHandle); DBFHandle dbfHandle = DBFOpen(this->FileName, "rb"); int fieldCount = DBFGetFieldCount(dbfHandle); for (int fieldIndex = 0; fieldIndex < fieldCount; fieldIndex++){ DBFFieldType fieldType; const char *typeName; char nativeFieldType; char pszFieldName[12]; int pnWidth=0, pnDecimals=0, recordCount=0; nativeFieldType = DBFGetNativeFieldType(dbfHandle, fieldIndex); fieldType = DBFGetFieldInfo(dbfHandle, fieldIndex, pszFieldName, &pnWidth, &pnDecimals); recordCount = DBFGetRecordCount(dbfHandle); vtkDebugMacro("record count: " << recordCount); switch (fieldType){ case FTString:{ vtkSmartPointer<vtkStringArray> cellData = vtkSmartPointer<vtkStringArray>::New(); cellData->SetName(pszFieldName); for (int recordIndex = 0; recordIndex < recordCount; recordIndex++){ if (DBFIsAttributeNULL(dbfHandle, recordIndex, fieldIndex)){ cellData->InsertNextValue("NULL"); }else{ cellData->InsertNextValue(DBFReadStringAttribute(dbfHandle, recordIndex, fieldIndex)); } } polydata->GetCellData()->AddArray(cellData); break; } case FTInteger:{ vtkSmartPointer<vtkIntArray> cellData = vtkSmartPointer<vtkIntArray>::New(); cellData->SetName(pszFieldName); for (int recordIndex = 0; recordIndex < recordCount; recordIndex++){ if (DBFIsAttributeNULL(dbfHandle, recordIndex, fieldIndex)){ cellData->InsertNextValue(0); }else{ cellData->InsertNextValue(DBFReadIntegerAttribute(dbfHandle, recordIndex, fieldIndex)); } } polydata->GetCellData()->AddArray(cellData); break; } case FTDouble:{ vtkSmartPointer<vtkDoubleArray> cellData = vtkSmartPointer<vtkDoubleArray>::New(); cellData->SetName(pszFieldName); for (int recordIndex = 0; recordIndex < recordCount; recordIndex++){ if (DBFIsAttributeNULL(dbfHandle, recordIndex, fieldIndex)){ cellData->InsertNextValue(0.0); }else{ cellData->InsertNextValue(DBFReadDoubleAttribute(dbfHandle, recordIndex, fieldIndex)); } } polydata->GetCellData()->AddArray(cellData); break; } case FTLogical:{ //what is this? lack of sample data! break; } case FTInvalid:{ vtkErrorMacro("Invalid DBF field type"); break; } } } DBFClose(dbfHandle); //pdRaw->SetPoints(pts); //pdRaw->SetPolys(polys); //pdRaw->SetLines(pLines); //pdRaw->SetVerts(verts); //tFilter->SetInput(pdRaw); //tFilter->Update(); //pdRefined = tFilter->GetOutput(); //polydata->SetPoints(pdRefined->GetPoints()); //polydata->SetPolys(pdRefined->GetPolys()); //polydata->SetLines(pdRefined->GetLines()); //polydata->SetVerts(pdRefined->GetVerts()); polydata->SetPoints(pts); polydata->SetLines(pLines); polydata->SetVerts(verts); polydata->SetStrips(strips); return 1; }
int load_table(int t) { int i, j, ncols, nrows, dbfcol; DBFHandle dbf; char *buf; ROW *rows; VALUE *val; G_debug(2, "load_table(): tab = %d", t); if (db.tables[t].loaded == TRUE) /*already loaded */ return DB_OK; dbf = DBFOpen(db.tables[t].file, "r"); if (dbf == NULL) { append_error("Cannot open dbf file.\n"); return DB_FAILED; } ncols = db.tables[t].ncols; nrows = DBFGetRecordCount(dbf); rows = db.tables[t].rows; rows = (ROW *) G_malloc(nrows * sizeof(ROW)); db.tables[t].arows = nrows; G_debug(2, " ncols = %d nrows = %d", ncols, nrows); for (i = 0; i < nrows; i++) { rows[i].alive = TRUE; rows[i].values = (VALUE *) G_calloc(ncols, sizeof(VALUE)); for (j = 0; j < ncols; j++) { val = &(rows[i].values[j]); dbfcol = j; val->is_null = DBFIsAttributeNULL(dbf, i, dbfcol); if (!(val->is_null)) { switch (db.tables[t].cols[j].type) { case DBF_INT: val->i = DBFReadIntegerAttribute(dbf, i, dbfcol); break; case DBF_CHAR: buf = (char *)DBFReadStringAttribute(dbf, i, dbfcol); save_string(val, buf); break; case DBF_DOUBLE: val->d = DBFReadDoubleAttribute(dbf, i, dbfcol); break; } } } } DBFClose(dbf); db.tables[t].rows = rows; db.tables[t].nrows = nrows; db.tables[t].loaded = TRUE; return DB_OK; }
static struct DataStruct * build_index (SHPHandle shp, DBFHandle dbf) { struct DataStruct *data; SHPObject *feat; int i; int j; /* make array */ data = malloc (sizeof *data * nShapes); if (!data) { fputs("malloc failed!\n", stderr); exit(EXIT_FAILURE); } /* populate array */ for (i = 0; i < nShapes; i++) { data[i].value = malloc(sizeof data[0].value[0] * nFields); if (0 == data[i].value) { fputs("malloc failed!\n", stderr); exit(EXIT_FAILURE); } data[i].record = i; for (j = 0; j < nFields; j++) { data[i].value[j].null = 0; switch (fldType[j]) { case FIDType: data[i].value[j].u.i = i; break; case SHPType: feat = SHPReadObject(shp, i); switch (feat->nSHPType) { case SHPT_NULL: fprintf(stderr, "Shape %d is a null feature!\n", i); data[i].value[j].null = 1; break; case SHPT_POINT: case SHPT_POINTZ: case SHPT_POINTM: case SHPT_MULTIPOINT: case SHPT_MULTIPOINTZ: case SHPT_MULTIPOINTM: case SHPT_MULTIPATCH: /* Y-sort bounds */ data[i].value[j].u.d = feat->dfYMax; break; case SHPT_ARC: case SHPT_ARCZ: case SHPT_ARCM: data[i].value[j].u.d = shp_length(feat); break; case SHPT_POLYGON: case SHPT_POLYGONZ: case SHPT_POLYGONM: data[i].value[j].u.d = shp_area(feat); break; default: fputs("Can't sort on Shapefile feature type!\n", stderr); exit(EXIT_FAILURE); } SHPDestroyObject(feat); break; case FTString: data[i].value[j].null = DBFIsAttributeNULL(dbf, i, fldIdx[j]); if (!data[i].value[j].null) { data[i].value[j].u.s = dupstr(DBFReadStringAttribute(dbf, i, fldIdx[j])); } break; case FTInteger: case FTLogical: data[i].value[j].null = DBFIsAttributeNULL(dbf, i, fldIdx[j]); if (!data[i].value[j].null) { data[i].value[j].u.i = DBFReadIntegerAttribute(dbf, i, fldIdx[j]); } break; case FTDouble: data[i].value[j].null = DBFIsAttributeNULL(dbf, i, fldIdx[j]); if (!data[i].value[j].null) { data[i].value[j].u.d = DBFReadDoubleAttribute(dbf, i, fldIdx[j]); } break; } } } #ifdef DEBUG PrintDataStruct(data); fputs("build_index: sorting array\n", stdout); #endif qsort (data, nShapes, sizeof data[0], compare); #ifdef DEBUG PrintDataStruct(data); fputs("build_index: returning array\n", stdout); #endif return data; }
SEXP Rdbfread(SEXP dbfnm) { DBFHandle hDBF; int i, iRecord, nflds, nrecs, nRvar, pc=0; char labelbuff[81]; const char *pszFilename = NULL; int nWidth, nDecimals, val; char szTitle[12], buf[2]; const char *p; DBFFieldType eType; SEXP df, tmp, varlabels, row_names, DataTypes; short *types; /* -------------------------------------------------------------------- */ /* Handle arguments. */ /* -------------------------------------------------------------------- */ pszFilename = CHAR(STRING_ELT(dbfnm, 0)); /* -------------------------------------------------------------------- */ /* Open the file. */ /* -------------------------------------------------------------------- */ hDBF = DBFOpen(pszFilename, "rb" ); if( hDBF == NULL ) error(_("unable to open DBF file")); /* -------------------------------------------------------------------- */ /* If there is no data in this file let the user know. */ /* -------------------------------------------------------------------- */ if( DBFGetFieldCount(hDBF) == 0 ) { DBFClose( hDBF ); error(_("no fields in DBF table")); } nRvar = 0; nflds = DBFGetFieldCount(hDBF); nrecs = DBFGetRecordCount(hDBF); types = (short *) R_alloc(nflds, sizeof(short)); PROTECT(DataTypes = allocVector(STRSXP, nflds)); pc++; for( i = 0; i < nflds; i++ ) { eType = DBFGetFieldInfo( hDBF, i, szTitle, &nWidth, &nDecimals ); switch(eType) { case FTString: types[i] = 1; nRvar++; break; case FTInteger: types[i] = 2; nRvar++; break; case FTDouble: types[i] = 3; nRvar++; break; case FTLogical: types[i] = 4; nRvar++; break; default: /* doesn't seem to be possible */ types[i] = 0; } buf[0] = hDBF->pachFieldType[i]; buf[1] = '\0'; SET_STRING_ELT(DataTypes, i, mkChar(buf)); } PROTECT(df = allocVector(VECSXP, nRvar)); pc++; PROTECT(varlabels = allocVector(STRSXP, nRvar)); pc++; for(i = 0, nRvar = 0; i < nflds; i++) { eType = DBFGetFieldInfo( hDBF, i, szTitle, &nWidth, &nDecimals ); switch(types[i]) { case 1: SET_VECTOR_ELT(df, nRvar, allocVector(STRSXP,nrecs)); break; case 2: SET_VECTOR_ELT(df, nRvar, allocVector(INTSXP,nrecs)); break; case 3: SET_VECTOR_ELT(df, nRvar, allocVector(REALSXP,nrecs)); break; case 4: SET_VECTOR_ELT(df, nRvar, allocVector(LGLSXP,nrecs)); break; default: continue; } SET_STRING_ELT(varlabels, nRvar, mkChar(szTitle)); nRvar++; } for(iRecord = 0; iRecord < nrecs; iRecord++) { nRvar = 0; for(i = 0; i < nflds; i++) switch(types[i]) { case 1: if( DBFIsAttributeNULL( hDBF, iRecord, i )) SET_STRING_ELT(VECTOR_ELT(df, nRvar), iRecord, NA_STRING); else SET_STRING_ELT(VECTOR_ELT(df, nRvar), iRecord, mkChar(DBFReadStringAttribute( hDBF, iRecord, i))); nRvar++; break; case 2: if( DBFIsAttributeNULL( hDBF, iRecord, i )) INTEGER(VECTOR_ELT(df, nRvar))[iRecord] = NA_INTEGER; else { double dtmp = DBFReadDoubleAttribute( hDBF, iRecord, i ); if((dtmp > 2147483647.0) || (dtmp < -2147483646.0)) { int ii, *it; double *r; /* allow for NA_INTEGER = -(2^31 -1)*/ PROTECT(tmp = VECTOR_ELT(df, nRvar)); it = INTEGER(tmp); SET_VECTOR_ELT(df, nRvar, allocVector(REALSXP, nrecs)); r = REAL(VECTOR_ELT(df, nRvar)); for (ii = 0; ii < iRecord; ii++) { int itmp = it[ii]; r[ii] = (itmp == NA_INTEGER) ? NA_REAL : itmp; } UNPROTECT(1); r[iRecord] = dtmp; types[i] = 3; } else INTEGER(VECTOR_ELT(df, nRvar))[iRecord] = (int) dtmp; } nRvar++; break; case 3: if( DBFIsAttributeNULL( hDBF, iRecord, i )) REAL(VECTOR_ELT(df, nRvar))[iRecord] = NA_REAL; else REAL(VECTOR_ELT(df, nRvar))[iRecord] = DBFReadDoubleAttribute( hDBF, iRecord, i ); nRvar++; break; case 4: if( DBFIsAttributeNULL( hDBF, iRecord, i )) LOGICAL(VECTOR_ELT(df, nRvar))[iRecord] = NA_LOGICAL; else { p = DBFReadStringAttribute( hDBF, iRecord, i ); switch(*p){ case 'f': case 'F': case 'n': case 'N': val = 0; break; case 't': case 'T': case 'y': case 'Y': val = 1; break; case '?': val = NA_LOGICAL; break; default: warning(_("value |%d| found in logical field"), *p); val = NA_LOGICAL; break; } LOGICAL(VECTOR_ELT(df, nRvar))[iRecord] = val; } nRvar++; break; default: break; } } DBFClose( hDBF ); PROTECT(tmp = mkString("data.frame")); pc++; setAttrib(df, R_ClassSymbol, tmp); setAttrib(df, R_NamesSymbol, varlabels); setAttrib(df, install("data_types"), DataTypes); PROTECT(row_names = allocVector(STRSXP, nrecs)); pc++; for (i = 0; i < nrecs; i++) { sprintf(labelbuff, "%d", i+1); SET_STRING_ELT(row_names, i, mkChar(labelbuff)); } setAttrib(df, R_RowNamesSymbol, row_names); UNPROTECT(pc); return(df); }
/* Return an allocated string representation of a specified record item */ int ShpLoaderGenerateSQLRowStatement(SHPLOADERSTATE *state, int item, char **strrecord) { SHPObject *obj = NULL; stringbuffer_t *sb; stringbuffer_t *sbwarn; char val[MAXVALUELEN]; char *escval; char *geometry=NULL, *ret; char *utf8str; int res, i; int rv; /* Clear the stringbuffers */ sbwarn = stringbuffer_create(); stringbuffer_clear(sbwarn); sb = stringbuffer_create(); stringbuffer_clear(sb); /* If we are reading the DBF only and the record has been marked deleted, return deleted record status */ if (state->config->readshape == 0 && DBFIsRecordDeleted(state->hDBFHandle, item)) { *strrecord = NULL; return SHPLOADERRECDELETED; } /* If we are reading the shapefile, open the specified record */ if (state->config->readshape == 1) { obj = SHPReadObject(state->hSHPHandle, item); if (!obj) { snprintf(state->message, SHPLOADERMSGLEN, _("Error reading shape object %d"), item); return SHPLOADERERR; } /* If we are set to skip NULLs, return a NULL record status */ if (state->config->null_policy == POLICY_NULL_SKIP && obj->nVertices == 0 ) { SHPDestroyObject(obj); *strrecord = NULL; return SHPLOADERRECISNULL; } } /* If not in dump format, generate the INSERT string */ if (!state->config->dump_format) { if (state->config->schema) { stringbuffer_aprintf(sb, "INSERT INTO \"%s\".\"%s\" %s VALUES (", state->config->schema, state->config->table, state->col_names); } else { stringbuffer_aprintf(sb, "INSERT INTO \"%s\" %s VALUES (", state->config->table, state->col_names); } } /* Read all of the attributes from the DBF file for this item */ for (i = 0; i < DBFGetFieldCount(state->hDBFHandle); i++) { /* Special case for NULL attributes */ if (DBFIsAttributeNULL(state->hDBFHandle, item, i)) { if (state->config->dump_format) stringbuffer_aprintf(sb, "\\N"); else stringbuffer_aprintf(sb, "NULL"); } else { /* Attribute NOT NULL */ switch (state->types[i]) { case FTInteger: case FTDouble: rv = snprintf(val, MAXVALUELEN, "%s", DBFReadStringAttribute(state->hDBFHandle, item, i)); if (rv >= MAXVALUELEN || rv == -1) { stringbuffer_aprintf(sbwarn, "Warning: field %d name truncated\n", i); val[MAXVALUELEN - 1] = '\0'; } /* If the value is an empty string, change to 0 */ if (val[0] == '\0') { val[0] = '0'; val[1] = '\0'; } /* If the value ends with just ".", remove the dot */ if (val[strlen(val) - 1] == '.') val[strlen(val) - 1] = '\0'; break; case FTString: case FTLogical: case FTDate: rv = snprintf(val, MAXVALUELEN, "%s", DBFReadStringAttribute(state->hDBFHandle, item, i)); if (rv >= MAXVALUELEN || rv == -1) { stringbuffer_aprintf(sbwarn, "Warning: field %d name truncated\n", i); val[MAXVALUELEN - 1] = '\0'; } break; default: snprintf(state->message, SHPLOADERMSGLEN, _("Error: field %d has invalid or unknown field type (%d)"), i, state->types[i]); SHPDestroyObject(obj); stringbuffer_destroy(sbwarn); stringbuffer_destroy(sb); return SHPLOADERERR; } if (state->config->encoding) { char *encoding_msg = _("Try \"LATIN1\" (Western European), or one of the values described at http://www.postgresql.org/docs/current/static/multibyte.html."); rv = utf8(state->config->encoding, val, &utf8str); if (rv != UTF8_GOOD_RESULT) { if ( rv == UTF8_BAD_RESULT ) snprintf(state->message, SHPLOADERMSGLEN, _("Unable to convert data value \"%s\" to UTF-8 (iconv reports \"%s\"). Current encoding is \"%s\". %s"), utf8str, strerror(errno), state->config->encoding, encoding_msg); else if ( rv == UTF8_NO_RESULT ) snprintf(state->message, SHPLOADERMSGLEN, _("Unable to convert data value to UTF-8 (iconv reports \"%s\"). Current encoding is \"%s\". %s"), strerror(errno), state->config->encoding, encoding_msg); else snprintf(state->message, SHPLOADERMSGLEN, _("Unexpected return value from utf8()")); if ( rv == UTF8_BAD_RESULT ) free(utf8str); return SHPLOADERERR; } strncpy(val, utf8str, MAXVALUELEN); free(utf8str); } /* Escape attribute correctly according to dump format */ if (state->config->dump_format) { escval = escape_copy_string(val); stringbuffer_aprintf(sb, "%s", escval); } else { escval = escape_insert_string(val); stringbuffer_aprintf(sb, "'%s'", escval); } /* Free the escaped version if required */ if (val != escval) free(escval); } /* Only put in delimeter if not last field or a shape will follow */ if (state->config->readshape == 1 || i < DBFGetFieldCount(state->hDBFHandle) - 1) { if (state->config->dump_format) stringbuffer_aprintf(sb, "\t"); else stringbuffer_aprintf(sb, ","); } /* End of DBF attribute loop */ } /* Add the shape attribute if we are reading it */ if (state->config->readshape == 1) { /* Handle the case of a NULL shape */ if (obj->nVertices == 0) { if (state->config->dump_format) stringbuffer_aprintf(sb, "\\N"); else stringbuffer_aprintf(sb, "NULL"); } else { /* Handle all other shape attributes */ switch (obj->nSHPType) { case SHPT_POLYGON: case SHPT_POLYGONM: case SHPT_POLYGONZ: res = GeneratePolygonGeometry(state, obj, &geometry); break; case SHPT_POINT: case SHPT_POINTM: case SHPT_POINTZ: res = GeneratePointGeometry(state, obj, &geometry, 0); break; case SHPT_MULTIPOINT: case SHPT_MULTIPOINTM: case SHPT_MULTIPOINTZ: /* Force it to multi unless using -S */ res = GeneratePointGeometry(state, obj, &geometry, state->config->simple_geometries ? 0 : 1); break; case SHPT_ARC: case SHPT_ARCM: case SHPT_ARCZ: res = GenerateLineStringGeometry(state, obj, &geometry); break; default: snprintf(state->message, SHPLOADERMSGLEN, _("Shape type is not supported, type id = %d"), obj->nSHPType); SHPDestroyObject(obj); stringbuffer_destroy(sbwarn); stringbuffer_destroy(sb); return SHPLOADERERR; } /* The default returns out of the function, so res will always have been set. */ if (res != SHPLOADEROK) { /* Error message has already been set */ SHPDestroyObject(obj); stringbuffer_destroy(sbwarn); stringbuffer_destroy(sb); return SHPLOADERERR; } /* Now generate the geometry string according to the current configuration */ if (!state->config->dump_format) { if (state->to_srid != state->from_srid) { stringbuffer_aprintf(sb, "ST_Transform("); } stringbuffer_aprintf(sb, "'"); } stringbuffer_aprintf(sb, "%s", geometry); if (!state->config->dump_format) { stringbuffer_aprintf(sb, "'"); /* Close the ST_Transform if reprojecting. */ if (state->to_srid != state->from_srid) { /* We need to add an explicit cast to geography/geometry to ensure that PostgreSQL doesn't get confused with the ST_Transform() raster function. */ if (state->config->geography) stringbuffer_aprintf(sb, "::geometry, %d)::geography", state->to_srid); else stringbuffer_aprintf(sb, "::geometry, %d)", state->to_srid); } } free(geometry); } /* Tidy up everything */ SHPDestroyObject(obj); } /* Close the line correctly for dump/insert format */ if (!state->config->dump_format) stringbuffer_aprintf(sb, ");"); /* Copy the string buffer into a new string, destroying the string buffer */ ret = (char *)malloc(strlen((char *)stringbuffer_getstring(sb)) + 1); strcpy(ret, (char *)stringbuffer_getstring(sb)); stringbuffer_destroy(sb); *strrecord = ret; /* If any warnings occurred, set the returned message string and warning status */ if (strlen((char *)stringbuffer_getstring(sbwarn)) > 0) { snprintf(state->message, SHPLOADERMSGLEN, "%s", stringbuffer_getstring(sbwarn)); stringbuffer_destroy(sbwarn); return SHPLOADERWARN; } else { /* Everything went okay */ stringbuffer_destroy(sbwarn); return SHPLOADEROK; } }
/* Return an allocated string representation of a specified record item */ int ShpLoaderGenerateSQLRowStatement(SHPLOADERSTATE *state, int item, char **strrecord) { SHPObject *obj = NULL; stringbuffer_t *sb; stringbuffer_t *sbwarn; char val[MAXVALUELEN]; char *escval; char *geometry=NULL, *ret; char *utf8str; int res, i; int rv; /* Clear the stringbuffers */ sbwarn = stringbuffer_create(); stringbuffer_clear(sbwarn); sb = stringbuffer_create(); stringbuffer_clear(sb); /* If we are reading the DBF only and the record has been marked deleted, return deleted record status */ if (state->config->readshape == 0 && DBFReadDeleted(state->hDBFHandle, item)) { *strrecord = NULL; return SHPLOADERRECDELETED; } /* If we are reading the shapefile, open the specified record */ if (state->config->readshape == 1) { obj = SHPReadObject(state->hSHPHandle, item); if (!obj) { snprintf(state->message, SHPLOADERMSGLEN, "Error reading shape object %d", item); return SHPLOADERERR; } /* If we are set to skip NULLs, return a NULL record status */ if (state->config->null_policy == POLICY_NULL_SKIP && obj->nVertices == 0 ) { SHPDestroyObject(obj); *strrecord = NULL; return SHPLOADERRECISNULL; } } /* If not in dump format, generate the INSERT string */ if (!state->config->dump_format) { if (state->config->schema) { vasbappend(sb, "INSERT INTO \"%s\".\"%s\" %s VALUES (", state->config->schema, state->config->table, state->col_names); } else { vasbappend(sb, "INSERT INTO \"%s\" %s VALUES (", state->config->table, state->col_names); } } /* Read all of the attributes from the DBF file for this item */ for (i = 0; i < DBFGetFieldCount(state->hDBFHandle); i++) { /* Special case for NULL attributes */ if (DBFIsAttributeNULL(state->hDBFHandle, item, i)) { if (state->config->dump_format) vasbappend(sb, "\\N"); else vasbappend(sb, "NULL"); } else { /* Attribute NOT NULL */ switch (state->types[i]) { case FTInteger: case FTDouble: rv = snprintf(val, MAXVALUELEN, "%s", DBFReadStringAttribute(state->hDBFHandle, item, i)); if (rv >= MAXVALUELEN || rv == -1) { vasbappend(sbwarn, "Warning: field %d name truncated\n", i); val[MAXVALUELEN - 1] = '\0'; } /* If the value is an empty string, change to 0 */ if (val[0] == '\0') { val[0] = '0'; val[1] = '\0'; } /* If the value ends with just ".", remove the dot */ if (val[strlen(val) - 1] == '.') val[strlen(val) - 1] = '\0'; break; case FTString: case FTLogical: case FTDate: rv = snprintf(val, MAXVALUELEN, "%s", DBFReadStringAttribute(state->hDBFHandle, item, i)); if (rv >= MAXVALUELEN || rv == -1) { vasbappend(sbwarn, "Warning: field %d name truncated\n", i); val[MAXVALUELEN - 1] = '\0'; } break; default: snprintf(state->message, SHPLOADERMSGLEN, "Error: field %d has invalid or unknown field type (%d)", i, state->types[i]); SHPDestroyObject(obj); stringbuffer_destroy(sbwarn); stringbuffer_destroy(sb); return SHPLOADERERR; } if (state->config->encoding) { static char *encoding_msg = "Try \"LATIN1\" (Western European), or one of the values described at http://www.postgresql.org/docs/current/static/multibyte.html."; /* If we are converting from another encoding to UTF8, convert the field value to UTF8 */ int rv = utf8(state->config->encoding, val, &utf8str); if ( !UTF8_DROP_BAD_CHARACTERS && rv != UTF8_GOOD_RESULT ) { if( rv == UTF8_BAD_RESULT ) snprintf(state->message, SHPLOADERMSGLEN, "Unable to convert data value \"%s\" to UTF-8 (iconv reports \"%s\"). Current encoding is \"%s\". %s", utf8str, strerror(errno), state->config->encoding, encoding_msg); else if( rv == UTF8_NO_RESULT ) snprintf(state->message, SHPLOADERMSGLEN, "Unable to convert data value to UTF-8 (iconv reports \"%s\"). Current encoding is \"%s\". %s", strerror(errno), state->config->encoding, encoding_msg); else snprintf(state->message, SHPLOADERMSGLEN, "Unexpected return value from utf8()"); if( rv == UTF8_BAD_RESULT ) free(utf8str); return SHPLOADERERR; } /* Optionally (compile-time) suppress bad UTF8 values */ if ( UTF8_DROP_BAD_CHARACTERS && rv != UTF8_GOOD_RESULT ) { val[0] = '.'; val[1] = '\0'; } /* The utf8str buffer is only alloc'ed if the UTF8 conversion works */ if ( rv == UTF8_GOOD_RESULT ) { strncpy(val, utf8str, MAXVALUELEN); free(utf8str); } } /* Escape attribute correctly according to dump format */ if (state->config->dump_format) { escval = escape_copy_string(val); vasbappend(sb, "%s", escval); } else { escval = escape_insert_string(val); vasbappend(sb, "'%s'", escval); } /* Free the escaped version if required */ if (val != escval) free(escval); } /* Only put in delimeter if not last field or a shape will follow */ if (state->config->readshape == 1 || i < DBFGetFieldCount(state->hDBFHandle) - 1) { if (state->config->dump_format) vasbappend(sb, "\t"); else vasbappend(sb, ","); } /* End of DBF attribute loop */ } /* Add the shape attribute if we are reading it */ if (state->config->readshape == 1) { /* Handle the case of a NULL shape */ if (obj->nVertices == 0) { if (state->config->dump_format) vasbappend(sb, "\\N"); else vasbappend(sb, "NULL"); } else { /* Handle all other shape attributes */ switch (obj->nSHPType) { case SHPT_POLYGON: case SHPT_POLYGONM: case SHPT_POLYGONZ: res = GeneratePolygonGeometry(state, obj, &geometry); if (res != SHPLOADEROK) { /* Error message has already been set */ SHPDestroyObject(obj); stringbuffer_destroy(sbwarn); stringbuffer_destroy(sb); return SHPLOADERERR; } break; case SHPT_POINT: case SHPT_POINTM: case SHPT_POINTZ: case SHPT_MULTIPOINT: case SHPT_MULTIPOINTM: case SHPT_MULTIPOINTZ: res = GeneratePointGeometry(state, obj, &geometry); if (res != SHPLOADEROK) { /* Error message has already been set */ SHPDestroyObject(obj); stringbuffer_destroy(sbwarn); stringbuffer_destroy(sb); return SHPLOADERERR; } break; case SHPT_ARC: case SHPT_ARCM: case SHPT_ARCZ: res = GenerateLineStringGeometry(state, obj, &geometry); if (res != SHPLOADEROK) { /* Error message has already been set */ SHPDestroyObject(obj); stringbuffer_destroy(sbwarn); stringbuffer_destroy(sb); return SHPLOADERERR; } break; default: snprintf(state->message, SHPLOADERMSGLEN, "Shape type is NOT SUPPORTED, type id = %d", obj->nSHPType); SHPDestroyObject(obj); stringbuffer_destroy(sbwarn); stringbuffer_destroy(sb); return SHPLOADERERR; } /* Now generate the geometry string according to the current configuration */ if (state->config->hwgeom) { /* Old-style hwgeom (WKT) */ if (!state->config->dump_format) vasbappend(sb, "GeomFromText('"); else { /* Output SRID if relevant */ if (state->config->sr_id != 0) vasbappend(sb, "SRID=%d;", state->config->sr_id); } vasbappend(sb, "%s", geometry); if (!state->config->dump_format) { vasbappend(sb, "'"); /* Output SRID if relevant */ if (state->config->sr_id != 0) vasbappend(sb, ", %d)", state->config->sr_id); else vasbappend(sb, ")"); } } else { /* New style lwgeom (HEXEWKB) */ if (!state->config->dump_format) vasbappend(sb, "'"); vasbappend(sb, "%s", geometry); if (!state->config->dump_format) vasbappend(sb, "'"); } free(geometry); } /* Tidy up everything */ SHPDestroyObject(obj); } /* Close the line correctly for dump/insert format */ if (!state->config->dump_format) vasbappend(sb, ");"); /* Copy the string buffer into a new string, destroying the string buffer */ ret = (char *)malloc(strlen((char *)stringbuffer_getstring(sb)) + 1); strcpy(ret, (char *)stringbuffer_getstring(sb)); stringbuffer_destroy(sb); *strrecord = ret; /* If any warnings occurred, set the returned message string and warning status */ if (strlen((char *)stringbuffer_getstring(sbwarn)) > 0) { snprintf(state->message, SHPLOADERMSGLEN, "%s", stringbuffer_getstring(sbwarn)); stringbuffer_destroy(sbwarn); return SHPLOADERWARN; } else { /* Everything went okay */ stringbuffer_destroy(sbwarn); return SHPLOADEROK; } }
int load_shape_attributes( const std::string & filename, IShapeAttributeLoadCallback & callback ) { std::vector< std::string> fields; DBFHandle hDBF; int *panWidth, i, iRecord; char szFormat[32]; const char * pszFilename = NULL; int nWidth, nDecimals; // int bHeader = 0; // int bRaw = 0; // int bMultiLine = 0; char szTitle[12]; // fprintf( stdout, "load_shape_attributes\n" ); // fflush( stdout); /* -------------------------------------------------------------------- */ /* Handle arguments. */ /* -------------------------------------------------------------------- */ // bMultiLine = 1; #if 0 for( i = 1; i < argc; i++ ) { if( strcmp(argv[i],"-h") == 0 ) bHeader = 1; else if( strcmp(argv[i],"-r") == 0 ) bRaw = 1; else if( strcmp(argv[i],"-m") == 0 ) bMultiLine = 1; else pszFilename = argv[i]; } #endif /* -------------------------------------------------------------------- */ /* Display a usage message. */ /* -------------------------------------------------------------------- */ pszFilename = filename.c_str(); #if 0 if( pszFilename == NULL ) { printf( "dbfdump [-h] [-r] [-m] xbase_file\n" ); printf( " -h: Write header info (field descriptions)\n" ); printf( " -r: Write raw field info, numeric values not reformatted\n" ); printf( " -m: Multiline, one line per field.\n" ); exit( 1 ); } #endif /* -------------------------------------------------------------------- */ /* Open the file. */ /* -------------------------------------------------------------------- */ hDBF = DBFOpen( pszFilename, "rb" ); if( hDBF == NULL ) { printf( "DBFOpen(\"r\") failed.\n" ); exit( 2 ); } else { // fprintf( stdout, "opened dbf file\n" ); } /* -------------------------------------------------------------------- */ /* If there is no data in this file let the user know. */ /* -------------------------------------------------------------------- */ if( DBFGetFieldCount(hDBF) == 0 ) { printf( "There are no fields in this table!\n" ); exit( 3 ); } /* -------------------------------------------------------------------- */ /* Dump header definitions. */ /* -------------------------------------------------------------------- */ #if 0 if( bHeader ) { for( i = 0; i < DBFGetFieldCount(hDBF); i++ ) { DBFFieldType eType; const char *pszTypeName; eType = DBFGetFieldInfo( hDBF, i, szTitle, &nWidth, &nDecimals ); if( eType == FTString ) pszTypeName = "String"; else if( eType == FTInteger ) pszTypeName = "Integer"; else if( eType == FTDouble ) pszTypeName = "Double"; else if( eType == FTInvalid ) pszTypeName = "Invalid"; printf( "Field %d: Type=%s, Title=`%s', Width=%d, Decimals=%d\n", i, pszTypeName, szTitle, nWidth, nDecimals ); } } #endif /* -------------------------------------------------------------------- */ /* Compute offsets to use when printing each of the field */ /* values. We make each field as wide as the field title+1, or */ /* the field value + 1. */ /* -------------------------------------------------------------------- */ #if 0 panWidth = (int *) malloc( DBFGetFieldCount( hDBF ) * sizeof(int) ); for( i = 0; i < DBFGetFieldCount(hDBF) && !bMultiLine; i++ ) { DBFFieldType eType; eType = DBFGetFieldInfo( hDBF, i, szTitle, &nWidth, &nDecimals ); if( strlen(szTitle) > nWidth ) panWidth[i] = strlen(szTitle); else panWidth[i] = nWidth; if( eType == FTString ) sprintf( szFormat, "%%-%ds ", panWidth[i] ); else sprintf( szFormat, "%%%ds ", panWidth[i] ); printf( szFormat, szTitle ); } printf( "\n" ); #endif /* -------------------------------------------------------------------- */ /* Read all the records */ /* -------------------------------------------------------------------- */ // loop the field names for( i = 0; i < DBFGetFieldCount(hDBF); i++ ) { DBFFieldType eType; eType = DBFGetFieldInfo( hDBF, i, szTitle, &nWidth, &nDecimals ); // printf( "name %s: ", szTitle ); fields.push_back( szTitle ) ; } for( iRecord = 0; iRecord < DBFGetRecordCount(hDBF); iRecord++ ) { // std::cout << "iRecord " << iRecord << std::endl; //records.push_back( std::vector< std::string> () ) ; // if( bMultiLine ) // printf( "Record: %d\n", iRecord ); // loop the fields for( i = 0; i < DBFGetFieldCount(hDBF); i++ ) { DBFFieldType eType; eType = DBFGetFieldInfo( hDBF, i, szTitle, &nWidth, &nDecimals ); // printf( "name %s: ", szTitle ); // if( bMultiLine ) // { // } /* -------------------------------------------------------------------- */ /* Print the record according to the type and formatting */ /* information implicit in the DBF field description. */ /* -------------------------------------------------------------------- */ //if( !bRaw ) if( DBFIsAttributeNULL( hDBF, iRecord, i ) ) { // callback.add_attr( iRecord, fields.at( i), (void *)0 ); } else { switch( eType ) { case FTString: { // sprintf( szFormat, "string %%-%ds", nWidth ); const char *value = DBFReadStringAttribute( hDBF, iRecord, i ); //fprintf( stdout, "str '%s'", s ); //printf( szFormat, DBFReadStringAttribute( hDBF, iRecord, i ) ); // do we have to free the memory.... callback.add_attr( iRecord, fields.at( i), std::string( value )); break; } case FTInteger: { /* sprintf( szFormat, "integer %%%dd", nWidth ); printf( szFormat, DBFReadIntegerAttribute( hDBF, iRecord, i ) ); */ int value = DBFReadIntegerAttribute( hDBF, iRecord, i ); callback.add_attr( iRecord, fields.at( i), value ); break; } case FTDouble: { /* sprintf( szFormat, "double %%%d.%dlf", nWidth, nDecimals ); printf( szFormat, DBFReadDoubleAttribute( hDBF, iRecord, i ) ); */ double value = DBFReadDoubleAttribute( hDBF, iRecord, i ); callback.add_attr( iRecord, fields.at( i), value ); break; } default: assert( 0); break; } } /* -------------------------------------------------------------------- */ /* Just dump in raw form (as formatted in the file). */ /* -------------------------------------------------------------------- */ #if 0 else { sprintf( szFormat, "%%-%ds", nWidth ); printf( szFormat, DBFReadStringAttribute( hDBF, iRecord, i ) ); } #endif /* -------------------------------------------------------------------- */ /* Write out any extra spaces required to pad out the field */ /* width. */ /* -------------------------------------------------------------------- */ #if 0 if( !bMultiLine ) { sprintf( szFormat, "%%%ds", panWidth[i] - nWidth + 1 ); printf( szFormat, "" ); } if( bMultiLine ) #endif #if 0 printf( "\n" ); fflush( stdout ); #endif } // printf( "\n" ); }