int main( int nArgc, char ** papszArgv ) { DDFModule oModule; const char *pszFilename = NULL; int bFSPTHack = FALSE; int bXML = FALSE; /* -------------------------------------------------------------------- */ /* Check arguments. */ /* -------------------------------------------------------------------- */ for( int iArg = 1; iArg < nArgc; iArg++ ) { if( EQUAL(papszArgv[iArg],"-fspt_repeating") ) bFSPTHack = TRUE; else if( EQUAL(papszArgv[iArg],"-xml") ) bXML = TRUE; else pszFilename = papszArgv[iArg]; } if( pszFilename == NULL ) { printf( "Usage: 8211dump [-xml] [-fspt_repeating] filename\n" ); exit( 1 ); } /* -------------------------------------------------------------------- */ /* Open file. */ /* -------------------------------------------------------------------- */ if( !oModule.Open( pszFilename ) ) exit( 1 ); /* -------------------------------------------------------------------- */ /* Apply FSPT hack if required. */ /* -------------------------------------------------------------------- */ if( bFSPTHack ) { DDFFieldDefn *poFSPT = oModule.FindFieldDefn( "FSPT" ); if( poFSPT == NULL ) fprintf( stderr, "unable to find FSPT field to set repeating flag.\n" ); else poFSPT->SetRepeatingFlag( TRUE ); } /* -------------------------------------------------------------------- */ /* Dump header, and all records. */ /* -------------------------------------------------------------------- */ DDFRecord *poRecord; if( bXML ) { printf("<DDFModule>\n"); int nFieldDefnCount = oModule.GetFieldCount(); for( int i = 0; i < nFieldDefnCount; i++ ) { DDFFieldDefn* poFieldDefn = oModule.GetField(i); const char* pszDataStructCode; switch( poFieldDefn->GetDataStructCode() ) { case dsc_elementary: pszDataStructCode = "elementary"; break; case dsc_vector: pszDataStructCode = "vector"; break; case dsc_array: pszDataStructCode = "array"; break; case dsc_concatenated: pszDataStructCode = "concatenated"; break; default: pszDataStructCode = "(unknown)"; break; } const char* pszDataTypeCode; switch( poFieldDefn->GetDataTypeCode() ) { case dtc_char_string: pszDataTypeCode = "char_string"; break; case dtc_implicit_point: pszDataTypeCode = "implicit_point"; break; case dtc_explicit_point: pszDataTypeCode = "explicit_point"; break; case dtc_explicit_point_scaled: pszDataTypeCode = "explicit_point_scaled"; break; case dtc_char_bit_string: pszDataTypeCode = "char_bit_string"; break; case dtc_bit_string: pszDataTypeCode = "bit_string"; break; case dtc_mixed_data_type: pszDataTypeCode = "mixed_data_type"; break; default: pszDataTypeCode = "(unknown)"; break; } printf("<DDFFieldDefn tag=\"%s\" fieldName=\"%s\" arrayDescr=\"%s\" " "formatControls=\"%s\" dataStructCode=\"%s\" dataTypeCode=\"%s\">\n", poFieldDefn->GetName(), poFieldDefn->GetDescription(), poFieldDefn->GetArrayDescr(), poFieldDefn->GetFormatControls(), pszDataStructCode, pszDataTypeCode); int nSubfieldCount = poFieldDefn->GetSubfieldCount(); for( int iSubField = 0; iSubField < nSubfieldCount; iSubField++ ) { DDFSubfieldDefn* poSubFieldDefn = poFieldDefn->GetSubfield(iSubField); printf(" <DDFSubfieldDefn name=\"%s\" format=\"%s\"/>\n", poSubFieldDefn->GetName(), poSubFieldDefn->GetFormat()); } printf("</DDFFieldDefn>\n"); } for( poRecord = oModule.ReadRecord(); poRecord != NULL; poRecord = oModule.ReadRecord() ) { printf("<DDFRecord>\n"); int nFieldCount = poRecord->GetFieldCount(); for( int iField = 0; iField < nFieldCount; iField++ ) { DDFField* poField = poRecord->GetField(iField); DDFFieldDefn* poDefn = poField->GetFieldDefn(); const char* pszFieldName = poDefn->GetName(); printf(" <DDFField name=\"%s\"", pszFieldName); if( poField->GetRepeatCount() > 1 ) printf(" repeatCount=\"%d\"", poField->GetRepeatCount()); int iOffset = 0, nLoopCount; int nRepeatCount = poField->GetRepeatCount(); const char* pachData = poField->GetData(); int nDataSize = poField->GetDataSize(); if( nRepeatCount == 1 && poDefn->GetSubfieldCount() == 0 ) { printf(" value=\"0x"); for( int i = 0; i < nDataSize - 1; i++ ) printf( "%02X", pachData[i] ); printf("\">\n"); } else printf(">\n"); for( nLoopCount = 0; nLoopCount < nRepeatCount; nLoopCount++ ) { for( int iSubField = 0; iSubField < poDefn->GetSubfieldCount(); iSubField++ ) { int nBytesConsumed; DDFSubfieldDefn* poSubFieldDefn = poDefn->GetSubfield(iSubField); const char* pszSubFieldName = poSubFieldDefn->GetName(); printf(" <DDFSubfield name=\"%s\" ", pszSubFieldName); DDFDataType eType = poSubFieldDefn->GetType(); const char* pachSubdata = pachData + iOffset; int nMaxBytes = nDataSize - iOffset; if( eType == DDFFloat ) printf("type=\"float\">%f", poSubFieldDefn->ExtractFloatData( pachSubdata, nMaxBytes, NULL ) ); else if( eType == DDFInt ) printf("type=\"integer\">%d", poSubFieldDefn->ExtractIntData( pachSubdata, nMaxBytes, NULL ) ); else if( eType == DDFBinaryString ) { int nBytes, i; GByte *pabyBString = (GByte *) poSubFieldDefn->ExtractStringData( pachSubdata, nMaxBytes, &nBytes ); printf( "type=\"binary\">0x" ); for( i = 0; i < nBytes; i++ ) printf( "%02X", pabyBString[i] ); } else { GByte* pabyString = (GByte *)poSubFieldDefn->ExtractStringData( pachSubdata, nMaxBytes, NULL ); int bBinary = FALSE; int i; for( i = 0; pabyString[i] != '\0'; i ++ ) { if( pabyString[i] < 32 || pabyString[i] > 127 ) { bBinary = TRUE; break; } } if( bBinary ) { printf( "type=\"binary\">0x" ); for( i = 0; pabyString[i] != '\0'; i ++ ) printf( "%02X", pabyString[i] ); } else { char* pszEscaped = CPLEscapeString((const char*)pabyString, -1, CPLES_XML); printf("type=\"string\">%s", pszEscaped); CPLFree(pszEscaped); } } printf("</DDFSubfield>\n"); poSubFieldDefn->GetDataLength( pachSubdata, nMaxBytes, &nBytesConsumed ); iOffset += nBytesConsumed; } } printf(" </DDFField>\n"); } printf("</DDFRecord>\n"); } printf("</DDFModule>\n"); } else { oModule.Dump( stdout ); long nStartLoc; nStartLoc = VSIFTellL( oModule.GetFP() ); for( poRecord = oModule.ReadRecord(); poRecord != NULL; poRecord = oModule.ReadRecord() ) { printf( "File Offset: %ld\n", nStartLoc ); poRecord->Dump( stdout ); nStartLoc = VSIFTellL( oModule.GetFP() ); } } oModule.Close(); #ifdef DBMALLOC malloc_dump(1); #endif }
static void WriteAttrRecordToDBF( DBFHandle hDBF, int iRecord, SDTSTransfer * poTransfer, DDFField * poSR ) { /* -------------------------------------------------------------------- */ /* Process each subfield in the record. */ /* -------------------------------------------------------------------- */ DDFFieldDefn *poFDefn = poSR->GetFieldDefn(); for( int iSF=0; iSF < poFDefn->GetSubfieldCount(); iSF++ ) { DDFSubfieldDefn *poSFDefn = poFDefn->GetSubfield( iSF ); int iField; int nMaxBytes; const char * pachData = poSR->GetSubfieldData(poSFDefn, &nMaxBytes); /* -------------------------------------------------------------------- */ /* Identify the related DBF field, if any. */ /* -------------------------------------------------------------------- */ for( iField = 0; iField < hDBF->nFields; iField++ ) { if( EQUALN(poSFDefn->GetName(), hDBF->pszHeader+iField*32,10) ) break; } if( iField == hDBF->nFields ) iField = -1; /* -------------------------------------------------------------------- */ /* Handle each of the types. */ /* -------------------------------------------------------------------- */ switch( poSFDefn->GetType() ) { case DDFString: const char *pszValue; pszValue = poSFDefn->ExtractStringData(pachData, nMaxBytes, NULL); if( iField != -1 ) DBFWriteStringAttribute(hDBF, iRecord, iField, pszValue ); break; case DDFFloat: double dfValue; dfValue = poSFDefn->ExtractFloatData(pachData, nMaxBytes, NULL); if( iField != -1 ) DBFWriteDoubleAttribute( hDBF, iRecord, iField, dfValue ); break; case DDFInt: int nValue; nValue = poSFDefn->ExtractIntData(pachData, nMaxBytes, NULL); if( iField != -1 ) DBFWriteIntegerAttribute( hDBF, iRecord, iField, nValue ); break; default: break; } } /* next subfield */ }
OGRSDTSLayer::OGRSDTSLayer( SDTSTransfer * poTransferIn, int iLayerIn, OGRSDTSDataSource * poDSIn ) : bPolygonsBuilt(FALSE) { poDS = poDSIn; poTransfer = poTransferIn; iLayer = iLayerIn; poReader = poTransfer->GetLayerIndexedReader( iLayer ); /* -------------------------------------------------------------------- */ /* Define the feature. */ /* -------------------------------------------------------------------- */ int iCATDEntry = poTransfer->GetLayerCATDEntry( iLayer ); poFeatureDefn = new OGRFeatureDefn(poTransfer->GetCATD()->GetEntryModule(iCATDEntry)); SetDescription( poFeatureDefn->GetName() ); poFeatureDefn->Reference(); poFeatureDefn->GetGeomFieldDefn(0)->SetSpatialRef(poDS->GetSpatialRef()); OGRFieldDefn oRecId( "RCID", OFTInteger ); poFeatureDefn->AddFieldDefn( &oRecId ); if( poTransfer->GetLayerType(iLayer) == SLTPoint ) { poFeatureDefn->SetGeomType( wkbPoint ); } else if( poTransfer->GetLayerType(iLayer) == SLTLine ) { poFeatureDefn->SetGeomType( wkbLineString ); oRecId.SetName( "SNID" ); poFeatureDefn->AddFieldDefn( &oRecId ); oRecId.SetName( "ENID" ); poFeatureDefn->AddFieldDefn( &oRecId ); } else if( poTransfer->GetLayerType(iLayer) == SLTPoly ) { poFeatureDefn->SetGeomType( wkbPolygon ); } else if( poTransfer->GetLayerType(iLayer) == SLTAttr ) { poFeatureDefn->SetGeomType( wkbNone ); } /* -------------------------------------------------------------------- */ /* Add schema from referenced attribute records. */ /* -------------------------------------------------------------------- */ char **papszATIDRefs = NULL; if( poTransfer->GetLayerType(iLayer) != SLTAttr ) papszATIDRefs = poReader->ScanModuleReferences(); else papszATIDRefs = CSLAddString( papszATIDRefs, poTransfer->GetCATD()->GetEntryModule(iCATDEntry) ); for( int iTable = 0; papszATIDRefs != NULL && papszATIDRefs[iTable] != NULL; iTable++ ) { SDTSAttrReader *poAttrReader; DDFFieldDefn *poFDefn; /* -------------------------------------------------------------------- */ /* Get the attribute table reader, and the associated user */ /* attribute field. */ /* -------------------------------------------------------------------- */ int nLayerIdx = poTransfer->FindLayer( papszATIDRefs[iTable] ); if( nLayerIdx < 0 ) continue; poAttrReader = (SDTSAttrReader *) poTransfer->GetLayerIndexedReader(nLayerIdx); if( poAttrReader == NULL ) continue; poFDefn = poAttrReader->GetModule()->FindFieldDefn( "ATTP" ); if( poFDefn == NULL ) poFDefn = poAttrReader->GetModule()->FindFieldDefn( "ATTS" ); if( poFDefn == NULL ) continue; /* -------------------------------------------------------------------- */ /* Process each user subfield on the attribute table into an */ /* OGR field definition. */ /* -------------------------------------------------------------------- */ for( int iSF=0; iSF < poFDefn->GetSubfieldCount(); iSF++ ) { DDFSubfieldDefn *poSFDefn = poFDefn->GetSubfield( iSF ); int nWidth = poSFDefn->GetWidth(); char *pszFieldName; if( poFeatureDefn->GetFieldIndex( poSFDefn->GetName() ) != -1 ) pszFieldName = CPLStrdup( CPLSPrintf( "%s_%s", papszATIDRefs[iTable], poSFDefn->GetName() ) ); else pszFieldName = CPLStrdup( poSFDefn->GetName() ); switch( poSFDefn->GetType() ) { case DDFString: { OGRFieldDefn oStrField( pszFieldName, OFTString ); if( nWidth != 0 ) oStrField.SetWidth( nWidth ); poFeatureDefn->AddFieldDefn( &oStrField ); } break; case DDFInt: { OGRFieldDefn oIntField( pszFieldName, OFTInteger ); if( nWidth != 0 ) oIntField.SetWidth( nWidth ); poFeatureDefn->AddFieldDefn( &oIntField ); } break; case DDFFloat: { OGRFieldDefn oRealField( pszFieldName, OFTReal ); // We don't have a precision in DDF files, so we never even // use the width. Otherwise with a precision of zero the // result would look like an integer. poFeatureDefn->AddFieldDefn( &oRealField ); } break; default: break; } CPLFree( pszFieldName ); } /* next iSF (subfield) */ } /* next iTable */ CSLDestroy( papszATIDRefs ); }
static void AddPrimaryAttrToDBFSchema( DBFHandle hDBF, SDTSTransfer *poTransfer, char ** papszModuleList ) { for( int iModule = 0; papszModuleList != NULL && papszModuleList[iModule] != NULL; iModule++ ) { SDTSAttrReader *poAttrReader; /* -------------------------------------------------------------------- */ /* Get a reader on the desired module. */ /* -------------------------------------------------------------------- */ poAttrReader = (SDTSAttrReader *) poTransfer->GetLayerIndexedReader( poTransfer->FindLayer( papszModuleList[iModule] ) ); if( poAttrReader == NULL ) { printf( "Unable to open attribute module %s, skipping.\n" , papszModuleList[iModule] ); continue; } poAttrReader->Rewind(); /* -------------------------------------------------------------------- */ /* Read the first record so we can clone schema information off */ /* of it. */ /* -------------------------------------------------------------------- */ SDTSAttrRecord *poAttrFeature; poAttrFeature = (SDTSAttrRecord *) poAttrReader->GetNextFeature(); if( poAttrFeature == NULL ) { fprintf( stderr, "Didn't find any meaningful attribute records in %s.\n", papszModuleList[iModule] ); continue; } /* -------------------------------------------------------------------- */ /* Clone schema off the first record. Eventually we need to */ /* get the information out of the DDR record, but it isn't */ /* clear to me how to accomplish that with the SDTS++ API. */ /* */ /* The following approach may fail (dramatically) if some */ /* records do not include all subfields. Furthermore, no */ /* effort is made to make DBF field names unique. The SDTS */ /* attributes often have names much beyond the 14 character dbf */ /* limit which may result in non-unique attributes. */ /* -------------------------------------------------------------------- */ DDFFieldDefn *poFDefn = poAttrFeature->poATTR->GetFieldDefn(); int iSF; DDFField *poSR = poAttrFeature->poATTR; for( iSF=0; iSF < poFDefn->GetSubfieldCount(); iSF++ ) { DDFSubfieldDefn *poSFDefn = poFDefn->GetSubfield( iSF ); int nWidth = poSFDefn->GetWidth(); switch( poSFDefn->GetType() ) { case DDFString: if( nWidth == 0 ) { int nMaxBytes; const char * pachData = poSR->GetSubfieldData(poSFDefn, &nMaxBytes); nWidth = strlen(poSFDefn->ExtractStringData(pachData, nMaxBytes, NULL )); } DBFAddField( hDBF, poSFDefn->GetName(), FTString, nWidth, 0 ); break; case DDFInt: if( nWidth == 0 ) nWidth = 9; DBFAddField( hDBF, poSFDefn->GetName(), FTInteger, nWidth, 0 ); break; case DDFFloat: DBFAddField( hDBF, poSFDefn->GetName(), FTDouble, 18, 6 ); break; default: fprintf( stderr, "Dropping attribute `%s' of module `%s'. " "Type unsupported\n", poSFDefn->GetName(), papszModuleList[iModule] ); break; } } if( !poAttrReader->IsIndexed() ) delete poAttrFeature; } /* next module */ }
static void AssignAttrRecordToFeature( OGRFeature * poFeature, CPL_UNUSED SDTSTransfer * poTransfer, DDFField * poSR ) { /* -------------------------------------------------------------------- */ /* Process each subfield in the record. */ /* -------------------------------------------------------------------- */ DDFFieldDefn *poFDefn = poSR->GetFieldDefn(); for( int iSF=0; iSF < poFDefn->GetSubfieldCount(); iSF++ ) { DDFSubfieldDefn *poSFDefn = poFDefn->GetSubfield( iSF ); int iField; int nMaxBytes; const char * pachData = poSR->GetSubfieldData(poSFDefn, &nMaxBytes); /* -------------------------------------------------------------------- */ /* Indentify this field on the feature. */ /* -------------------------------------------------------------------- */ iField = poFeature->GetFieldIndex( poSFDefn->GetName() ); /* -------------------------------------------------------------------- */ /* Handle each of the types. */ /* -------------------------------------------------------------------- */ switch( poSFDefn->GetType() ) { case DDFString: const char *pszValue; pszValue = poSFDefn->ExtractStringData(pachData, nMaxBytes, NULL); if( iField != -1 ) poFeature->SetField( iField, pszValue ); break; case DDFFloat: double dfValue; dfValue = poSFDefn->ExtractFloatData(pachData, nMaxBytes, NULL); if( iField != -1 ) poFeature->SetField( iField, dfValue ); break; case DDFInt: int nValue; nValue = poSFDefn->ExtractIntData(pachData, nMaxBytes, NULL); if( iField != -1 ) poFeature->SetField( iField, nValue ); break; default: break; } } /* next subfield */ }