コード例 #1
0
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
		public static FieldDescriptor IdField()
		{
			FieldDescriptor shpfield = new FieldDescriptor();
			shpfield.Name="Row";
			shpfield._type='I';
			return shpfield;
		}
コード例 #2
0
        /// <summary>
        /// 
        /// </summary>
        /// <returns></returns>
		public static FieldDescriptor ShapeField()
		{
			FieldDescriptor shpfield = new FieldDescriptor();
			shpfield.Name="Geometry";
			shpfield._type='B';
			return shpfield;
		}
コード例 #3
0
        /// <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));
		}
コード例 #4
0
        /// <summary>
        /// 
        /// </summary>
        /// <param name="dbaseFields"></param>
        /// <param name="columnValues"></param>
		public RowStructure(FieldDescriptor[] dbaseFields, ArrayList columnValues) 
		{
			_dbaseFields = dbaseFields;
			_columnValues  = columnValues;
		}
コード例 #5
0
		/// <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);        
		}
コード例 #6
0
		/// <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;
		}
コード例 #7
0
		/// <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;
		}
コード例 #8
0
		/// <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;	
		}