/// <summary>
///
/// </summary>
/// <returns></returns>
public static DbaseFieldDescriptor ShapeField()
{
DbaseFieldDescriptor shpfield = new DbaseFieldDescriptor();
shpfield.Name = "Geometry";
shpfield._type = 'B';
return(shpfield);
}
/// <summary>
///
/// </summary>
/// <returns></returns>
public static DbaseFieldDescriptor IdField()
{
DbaseFieldDescriptor shpfield = new DbaseFieldDescriptor();
shpfield.Name = "Row";
shpfield._type = 'I';
return(shpfield);
}
/// <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;
DbaseFieldDescriptor[] tempFieldDescriptors =
new DbaseFieldDescriptor[_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>
/// Read the header data from the DBF file.
/// </summary>
/// <param name="reader">BinaryReader containing the header.</param>
/// <param name="filename">Filename </param>
public void ReadHeader(BinaryReader reader, string filename)
{
// type of reader.
_fileType = reader.ReadByte();
if (_fileType != 0x03)
{
throw new NotSupportedException("Unsupported DBF reader Type " + _fileType);
}
// parse the update date information.
int year = reader.ReadByte();
int month = reader.ReadByte();
int day = 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);
byte[] data = reader.ReadBytes(20);
byte lcid = data[29 - 12]; //get the 29th byte in the file... we've first to read into arry was no 12
_encoding = DetectEncodingFromMark(lcid, filename);
//Replace reader with one with correct encoding..
reader = new BinaryReader(reader.BaseStream, _encoding);
// calculate the number of Fields in the header
_numFields = (_headerLength - FileDescriptorSize - 1) / FileDescriptorSize;
// read all of the header records
_fieldDescriptions = new DbaseFieldDescriptor[_numFields];
for (int i = 0; i < _numFields; i++)
{
_fieldDescriptions[i] = new DbaseFieldDescriptor();
// read the field name
byte[] buffer = reader.ReadBytes(11);
// NOTE: only this _encoding.GetString method is available in Silverlight
String name = _encoding.GetString(buffer, 0, buffer.Length);
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 = reader.ReadByte();
if (tempLength < 0)
{
tempLength = tempLength + 256;
}
_fieldDescriptions[i].Length = tempLength;
// read the field decimal count in bytes
_fieldDescriptions[i].DecimalCount = reader.ReadByte();
// read the reserved bytes.
//reader.skipBytes(14);
reader.ReadBytes(14);
}
// Last byte is a marker for the end of the field definitions.
// Trond Benum: This fails for some presumeably valid test shapefiles, so I have commented it out.
byte lastByte = reader.ReadBytes(1)[0];
// if (lastByte != 0x0d)
// throw new ShapefileException("DBase Header is not terminated");
// Assure we are at the end of the header!
if (reader.BaseStream.Position != _headerLength)
{
reader.BaseStream.Seek(_headerLength, SeekOrigin.Begin);
}
}
/// <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;
}
int tempLength = 1; // the length is used for the offset, and there is a * for deleted as the first byte
DbaseFieldDescriptor[] tempFieldDescriptors = new DbaseFieldDescriptor[_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 DbaseFieldDescriptor();
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 > FieldNameMaxLength)
{
string s = String.Format("FieldName {0} is longer than {1} characters", fieldName, FieldNameMaxLength);
throw new ArgumentException(s);
}
tempFieldDescriptors[_fieldDescriptions.Length].Name = tempFieldName;
// the field type
switch (fieldType)
{
case 'C':
case '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");
}
break;
case 'S':
case '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;
break;
case 'D':
case '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;
break;
case 'F':
case '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.");
}
break;
case 'N':
case '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;
}
break;
case 'L':
case '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;
break;
default:
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(DbaseFieldDescriptor dbaseField, int index) : base(dbaseField.Name, null)
{
_dbaseField = dbaseField;
_index = index;
}
