/// <summary>
///
/// </summary>
/// <returns></returns>
public static FieldDescriptor IdField()
{
FieldDescriptor shpfield = new FieldDescriptor();
shpfield.Name="Row";
shpfield._type='I';
return shpfield;
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public static FieldDescriptor ShapeField()
{
FieldDescriptor shpfield = new FieldDescriptor();
shpfield.Name="Geometry";
shpfield._type='B';
return shpfield;
}
/// <summary>
///
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public static char GetDbaseType(Type type)
{
FieldDescriptor dbaseColumn = new FieldDescriptor();
if (type == typeof(string))
return 'C';
else if (type == typeof(double)) { }
else if (type == typeof(float)) { }
else if (type == typeof(bool))
return 'L';
else if (type == typeof(DateTime))
return 'D';
throw new NotSupportedException(String.Format("{0} does not have a corresponding dbase type.", type.Name));
}
/// <summary>
///
/// </summary>
/// <param name="dbaseFields"></param>
/// <param name="columnValues"></param>
public RowStructure(FieldDescriptor[] dbaseFields, ArrayList columnValues)
{
_dbaseFields = dbaseFields;
_columnValues = columnValues;
}
/// <summary>
/// Read the header data from the DBF file.
/// </summary>
/// <param name="reader">BinaryReader containing the header.</param>
public void ReadHeader(BinaryReader reader)
{
// type of reader.
_fileType = reader.ReadByte();
if (_fileType != 0x03)
throw new NotSupportedException("Unsupported DBF reader Type "+_fileType);
// parse the update date information.
int year = (int)reader.ReadByte();
int month = (int)reader.ReadByte();
int day = (int)reader.ReadByte();
_updateDate = new DateTime(year + 1900, month, day);
// read the number of records.
_numRecords = reader.ReadInt32();
// read the length of the header structure.
_headerLength = reader.ReadInt16();
// read the length of a record
_recordLength = reader.ReadInt16();
// skip the reserved bytes in the header.
//in.skipBytes(20);
reader.ReadBytes(20);
// calculate the number of Fields in the header
_numFields = (_headerLength - FileDescriptorSize -1)/FileDescriptorSize;
// read all of the header records
_fieldDescriptions = new FieldDescriptor[_numFields];
for (int i=0; i<_numFields; i++)
{
_fieldDescriptions[i] = new FieldDescriptor();
// read the field name
char[] buffer = new char[11];
buffer = reader.ReadChars(11);
string name = new string(buffer);
int nullPoint = name.IndexOf((char)0);
if(nullPoint != -1)
name = name.Substring(0,nullPoint);
_fieldDescriptions[i].Name = name;
// read the field type
_fieldDescriptions[i].DbaseType = (char) reader.ReadByte();
// read the field data address, offset from the start of the record.
_fieldDescriptions[i].DataAddress = reader.ReadInt32();
// read the field length in bytes
int tempLength = (int) reader.ReadByte();
if (tempLength < 0) tempLength = tempLength + 256;
_fieldDescriptions[i].Length = tempLength;
// read the field decimal count in bytes
_fieldDescriptions[i].DecimalCount = (int) reader.ReadByte();
// read the reserved bytes.
//reader.skipBytes(14);
reader.ReadBytes(14);
}
// Last byte is a marker for the end of the field definitions.
reader.ReadBytes(1);
}
/// <summary>
/// Remove a column from this DbaseFileHeader.
/// </summary>
/// <param name="fieldName"></param>
/// <returns>return index of the removed column, -1 if no found.</returns>
public int RemoveColumn(string fieldName)
{
int retCol = -1;
int tempLength = 1;
FieldDescriptor[] tempFieldDescriptors =
new FieldDescriptor[_fieldDescriptions.Length - 1];
for (int i = 0, j = 0; i < _fieldDescriptions.Length; i++)
{
if (fieldName.ToLower()!=(_fieldDescriptions[i].Name.Trim().ToLower()))
{
// if this is the last field and we still haven't found the
// named field
if (i == j && i == _fieldDescriptions.Length - 1)
return retCol;
tempFieldDescriptors[j] = _fieldDescriptions[i];
tempFieldDescriptors[j].DataAddress = tempLength;
tempLength += tempFieldDescriptors[j].Length;
// only increment j on non-matching fields
j++;
}
else retCol = i;
}
// set the new fields.
_fieldDescriptions = tempFieldDescriptors;
_headerLength = 33+32*_fieldDescriptions.Length;
_numFields = _fieldDescriptions.Length;
_recordLength = tempLength;
return retCol;
}
/// <summary>
/// Add a column to this DbaseFileHeader.
/// </summary>
/// <param name="fieldName">The name of the field to add.</param>
/// <param name="fieldType">The type is one of (C N L or D) character, number, logical(true/false), or date.</param>
/// <param name="fieldLength"> The Field length is the total length in bytes reserved for this column.</param>
/// <param name="decimalCount">The decimal count only applies to numbers(N), and floating point values (F), and refers to the number of characters to reserve after the decimal point.</param>
public void AddColumn (string fieldName, char fieldType, int fieldLength, int decimalCount)
{
if (fieldLength <=0) fieldLength = 1;
if (_fieldDescriptions == null) _fieldDescriptions = new FieldDescriptor[0];
int tempLength = 1; // the length is used for the offset, and there is a * for deleted as the first byte
FieldDescriptor[] tempFieldDescriptors = new FieldDescriptor[_fieldDescriptions.Length+1];
for (int i=0; i<_fieldDescriptions.Length; i++)
{
_fieldDescriptions[i].DataAddress = tempLength;
tempLength = tempLength + _fieldDescriptions[i].Length;
tempFieldDescriptors[i] = _fieldDescriptions[i];
}
tempFieldDescriptors[_fieldDescriptions.Length] = new FieldDescriptor();
tempFieldDescriptors[_fieldDescriptions.Length].Length = fieldLength;
tempFieldDescriptors[_fieldDescriptions.Length].DecimalCount = decimalCount;
tempFieldDescriptors[_fieldDescriptions.Length].DataAddress = tempLength;
// set the field name
string tempFieldName = fieldName;
if (tempFieldName == null) tempFieldName = "NoName";
if (tempFieldName.Length > 11)
{
tempFieldName = tempFieldName.Substring(0,11);
Trace.Write("FieldName "+fieldName+" is longer than 11 characters, truncating to "+tempFieldName);
}
tempFieldDescriptors[_fieldDescriptions.Length].Name = tempFieldName;
// the field type
if ((fieldType == 'C') || (fieldType == 'c'))
{
tempFieldDescriptors[_fieldDescriptions.Length].DbaseType = 'C';
if (fieldLength > 254) Trace.WriteLine("Field Length for "+fieldName+" set to "+fieldLength+" Which is longer than 254, not consistent with dbase III");
}
else if ((fieldType == 'S') || (fieldType == 's'))
{
tempFieldDescriptors[_fieldDescriptions.Length].DbaseType = 'C';
Trace.WriteLine("Field type for "+fieldName+" set to S which is flat out wrong people!, I am setting this to C, in the hopes you meant character.");
if (fieldLength >254) Trace.WriteLine("Field Length for "+fieldName+" set to "+fieldLength+" Which is longer than 254, not consistent with dbase III");
tempFieldDescriptors[_fieldDescriptions.Length].Length = 8;
}
else if ((fieldType == 'D') || (fieldType == 'd'))
{
tempFieldDescriptors[_fieldDescriptions.Length].DbaseType = 'D';
if (fieldLength != 8) Trace.WriteLine("Field Length for "+fieldName+" set to "+fieldLength+" Setting to 8 digets YYYYMMDD");
tempFieldDescriptors[_fieldDescriptions.Length].Length = 8;
}
else if ((fieldType == 'F') || (fieldType == 'f'))
{
tempFieldDescriptors[_fieldDescriptions.Length].DbaseType = 'F';
if (fieldLength > 20) Trace.WriteLine("Field Length for "+fieldName+" set to "+fieldLength+" Preserving length, but should be set to Max of 20 not valid for dbase IV, and UP specification, not present in dbaseIII.");
}
else if ((fieldType == 'N') || (fieldType == 'n'))
{
tempFieldDescriptors[_fieldDescriptions.Length].DbaseType = 'N';
if (fieldLength > 18) Trace.WriteLine("Field Length for "+fieldName+" set to "+fieldLength+" Preserving length, but should be set to Max of 18 for dbase III specification.");
if (decimalCount < 0)
{
Trace.WriteLine("Field Decimal Position for "+fieldName+" set to "+decimalCount+" Setting to 0 no decimal data will be saved.");
tempFieldDescriptors[_fieldDescriptions.Length].DecimalCount = 0;
}
if(decimalCount>fieldLength-1)
{
Trace.WriteLine("Field Decimal Position for "+fieldName+" set to "+decimalCount+" Setting to "+(fieldLength-1)+" no non decimal data will be saved.");
tempFieldDescriptors[_fieldDescriptions.Length].DecimalCount = fieldLength-1;
}
}
else if ((fieldType == 'L') || (fieldType == 'l'))
{
tempFieldDescriptors[_fieldDescriptions.Length].DbaseType = 'L';
if (fieldLength != 1) Trace.WriteLine("Field Length for "+fieldName+" set to "+fieldLength+" Setting to length of 1 for logical fields.");
tempFieldDescriptors[_fieldDescriptions.Length].Length = 1;
}
else
{
throw new NotSupportedException("Unsupported field type "+fieldType + " For column "+fieldName);
}
// the length of a record
tempLength = tempLength + tempFieldDescriptors[_fieldDescriptions.Length].Length;
// set the new fields.
_fieldDescriptions = tempFieldDescriptors;
_headerLength = 33+32*_fieldDescriptions.Length;
_numFields = _fieldDescriptions.Length;
_recordLength=tempLength;
}
/// <summary>
/// Initializes a new instance of the ColumnStructure class.
/// </summary>
/// <param name="dbaseField"></param>
/// <param name="index"></param>
public ColumnStructure(FieldDescriptor dbaseField, int index) : base(dbaseField.Name, null)
{
_dbaseField = dbaseField;
_index=index;
}