// Copyright 2005, 2006 - Morten Nielsen (www.iter.dk)

// Copyright 2014 - Spartaco Giubbolini, Felix Obermaier

//

// This file is part of SharpMap.

// SharpMap is free software; you can redistribute it and/or modify

// it under the terms of the GNU Lesser General Public License as published by

// the Free Software Foundation; either version 2 of the License, or

// (at your option) any later version.

//

// SharpMap is distributed in the hope that it will be useful,

// but WITHOUT ANY WARRANTY; without even the implied warranty of

// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

// GNU Lesser General Public License for more details.

// You should have received a copy of the GNU Lesser General Public License

// along with SharpMap; if not, write to the Free Software

// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

using System;

using System.Collections;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Diagnostics;

using System.Globalization;

using System.IO;

using System.Linq;

using System.Runtime.Serialization;

using GeoAPI;

using GeoAPI.Geometries;

using NetTopologySuite.IO;

namespace SharpMap.Data

{

/// <summary>

/// Represents an in-memory cache of spatial data. The FeatureDataSet is an extension of System.Data.DataSet

/// </summary>

/// <remarks>Serialization is achieved using the approach described in http://support.microsoft.com/kb/829740/en-us

/// </remarks>

[Serializable]

public class FeatureDataSet : DataSet, ISerializable

{

/// <summary>

/// Initializes a new instance of the FeatureDataSet class.

/// </summary>

public FeatureDataSet()

{}

/// <summary>

/// Initializes a new instance of the FeatureDataSet class.

/// </summary>

/// <param name="info">serialization info</param>

/// <param name="context">streaming context</param>

protected FeatureDataSet(SerializationInfo info, StreamingContext context)

{

DataSetName = info.GetString("name");

Namespace = info.GetString("ns");

Prefix = info.GetString("prefix");

CaseSensitive = info.GetBoolean("case");

Locale = new CultureInfo(info.GetInt32("locale"));

EnforceConstraints = info.GetBoolean("enforceCons");

var tables = (DataTable[]) info.GetValue("tables", typeof (DataTable[]));

base.Tables.AddRange(tables);

var constraints = (ArrayList)info.GetValue("constraints", typeof(ArrayList));

SetForeignKeyConstraints(constraints);

var relations = (ArrayList)info.GetValue("relations", typeof(ArrayList));

SetRelations(relations);

var extendedProperties = (PropertyCollection)info.GetValue("extendedProperties", typeof (PropertyCollection));

if (extendedProperties.Count > 0) // otherwise the next foreach throws exception... weird.

foreach (DictionaryEntry keyPair in extendedProperties)

ExtendedProperties.Add(keyPair.Key, keyPair.Value); }

/// <summary>

/// Gets the collection of tables contained in the FeatureDataSet

/// </summary>

public new FeatureTableCollection Tables

{

get { return new FeatureTableCollection(base.Tables); }

}

/// <summary>

/// Copies the structure of the FeatureDataSet, including all FeatureDataTable schemas, relations, and constraints. Does not copy any data.

/// </summary>

/// <returns></returns>

public new FeatureDataSet Clone()

{

var cln = ((FeatureDataSet) (base.Clone()));

return cln;

}

//private void InitClass()

//{

// Prefix = "";

// Namespace = "sm";

// Locale = new CultureInfo("en-US");

// CaseSensitive = false;

// EnforceConstraints = true;

//}

void ISerializable.GetObjectData(SerializationInfo info, StreamingContext context)

{

info.AddValue("name", DataSetName);

info.AddValue("ns", Namespace);

info.AddValue("prefix", Prefix);

info.AddValue("case", CaseSensitive);

info.AddValue("locale", Locale.LCID);

info.AddValue("enforceCons", EnforceConstraints);

info.AddValue("tables", base.Tables.OfType<DataTable>().ToArray());

info.AddValue("constraints", GetForeignKeyConstraints());

info.AddValue("relations", GetRelations());

info.AddValue("extendedProperties", ExtendedProperties);

}

private ArrayList GetForeignKeyConstraints()

{

var constraintList = new ArrayList();

var tables = base.Tables;

for (int i = 0; i < tables.Count; i++)

{

DataTable dt = tables[i];

for (int j = 0; j < dt.Constraints.Count; j++)

{

Constraint c = dt.Constraints[j];

var fk = c as ForeignKeyConstraint;

if (fk != null)

{

string constraintName = c.ConstraintName;

var parentInfo = new int[fk.RelatedColumns.Length + 1];

parentInfo[0] = tables.IndexOf(fk.RelatedTable);

for (int k = 1; k < parentInfo.Length; k++)

{

parentInfo[k] = fk.RelatedColumns[k - 1].Ordinal;

}

int[] childInfo = new int[fk.Columns.Length + 1];

childInfo[0] = i;//Since the constraint is on the current table, this is the child table.

for (int k = 1; k < childInfo.Length; k++)

{

childInfo[k] = fk.Columns[k - 1].Ordinal;

}

var list = new ArrayList

{

constraintName,

parentInfo,

childInfo,

new[] {(int) fk.AcceptRejectRule, (int) fk.UpdateRule, (int) fk.DeleteRule}

};

var extendedProperties = new Hashtable();

if (fk.ExtendedProperties.Keys.Count > 0)

{

foreach (object propertyKey in fk.ExtendedProperties.Keys)

{

extendedProperties.Add(propertyKey, fk.ExtendedProperties[propertyKey]);

}

}

list.Add(extendedProperties);

constraintList.Add(list);

}

}

}

return constraintList;

}

private ArrayList GetRelations()

{

var relationList = new ArrayList();

var tables = base.Tables;

foreach (DataRelation rel in Relations)

{

string relationName = rel.RelationName;

var parentInfo = new int[rel.ParentColumns.Length + 1];

parentInfo[0] = tables.IndexOf(rel.ParentTable);

for (int j = 1; j < parentInfo.Length; j++)

{

parentInfo[j] = rel.ParentColumns[j - 1].Ordinal;

}

var childInfo = new int[rel.ChildColumns.Length + 1];

childInfo[0] = tables.IndexOf(rel.ChildTable);

for (int j = 1; j < childInfo.Length; j++)

{

childInfo[j] = rel.ChildColumns[j - 1].Ordinal;

}

var list = new ArrayList {relationName, parentInfo, childInfo, rel.Nested};

var extendedProperties = new Hashtable();

if (rel.ExtendedProperties.Keys.Count > 0)

{

foreach (object propertyKey in rel.ExtendedProperties.Keys)

{

extendedProperties.Add(propertyKey, rel.ExtendedProperties[propertyKey]);

}

}

list.Add(extendedProperties);

relationList.Add(list);

}

return relationList;

}

private void SetForeignKeyConstraints(ArrayList constraintList)

{

Debug.Assert(constraintList != null);

var tables = base.Tables;

foreach (ArrayList list in constraintList)

{

Debug.Assert(list.Count == 5);

string constraintName = (string)list[0];

int[] parentInfo = (int[])list[1];

int[] childInfo = (int[])list[2];

int[] rules = (int[])list[3];

Hashtable extendedProperties = (Hashtable)list[4];

//ParentKey Columns.

Debug.Assert(parentInfo.Length >= 1);

DataColumn[] parentkeyColumns = new DataColumn[parentInfo.Length - 1];

for (int i = 0; i < parentkeyColumns.Length; i++)

{

Debug.Assert(tables.Count > parentInfo[0]);

Debug.Assert(tables[parentInfo[0]].Columns.Count > parentInfo[i + 1]);

parentkeyColumns[i] = tables[parentInfo[0]].Columns[parentInfo[i + 1]];

}

//ChildKey Columns.

Debug.Assert(childInfo.Length >= 1);

DataColumn[] childkeyColumns = new DataColumn[childInfo.Length - 1];

for (int i = 0; i < childkeyColumns.Length; i++)

{

Debug.Assert(tables.Count > childInfo[0]);

Debug.Assert(tables[childInfo[0]].Columns.Count > childInfo[i + 1]);

childkeyColumns[i] = tables[childInfo[0]].Columns[childInfo[i + 1]];

}

//Create the Constraint.

ForeignKeyConstraint fk = new ForeignKeyConstraint(constraintName, parentkeyColumns, childkeyColumns);

Debug.Assert(rules.Length == 3);

fk.AcceptRejectRule = (AcceptRejectRule)rules[0];

fk.UpdateRule = (Rule)rules[1];

fk.DeleteRule = (Rule)rules[2];

//Extended Properties.

Debug.Assert(extendedProperties != null);

if (extendedProperties.Keys.Count > 0)

{

foreach (object propertyKey in extendedProperties.Keys)

{

fk.ExtendedProperties.Add(propertyKey, extendedProperties[propertyKey]);

}

}

//Add the constraint to the child datatable.

Debug.Assert(tables.Count > childInfo[0]);

tables[childInfo[0]].Constraints.Add(fk);

}

}

private void SetRelations(ArrayList relationList)

{

Debug.Assert(relationList != null);

var tables = base.Tables;

foreach (ArrayList list in relationList)

{

Debug.Assert(list.Count == 5);

var relationName = (string)list[0];

var parentInfo = (int[])list[1];

var childInfo = (int[])list[2];

var isNested = (bool)list[3];

var extendedProperties = (Hashtable)list[4];

//ParentKey Columns.

Debug.Assert(parentInfo.Length >= 1);

var parentkeyColumns = new DataColumn[parentInfo.Length - 1];

for (int i = 0; i < parentkeyColumns.Length; i++)

{

Debug.Assert(tables.Count > parentInfo[0]);

Debug.Assert(tables[parentInfo[0]].Columns.Count > parentInfo[i + 1]);

parentkeyColumns[i] = tables[parentInfo[0]].Columns[parentInfo[i + 1]];

}

//ChildKey Columns.

Debug.Assert(childInfo.Length >= 1);

var childkeyColumns = new DataColumn[childInfo.Length - 1];

for (int i = 0; i < childkeyColumns.Length; i++)

{

Debug.Assert(tables.Count > childInfo[0]);

Debug.Assert(tables[childInfo[0]].Columns.Count > childInfo[i + 1]);

childkeyColumns[i] = tables[childInfo[0]].Columns[childInfo[i + 1]];

}

//Create the Relation, without any constraints[Assumption: The constraints are added earlier than the relations]

var rel = new DataRelation(relationName, parentkeyColumns, childkeyColumns, false);

rel.Nested = isNested;

//Extended Properties.

Debug.Assert(extendedProperties != null);

if (extendedProperties.Keys.Count > 0)

{

foreach (object propertyKey in extendedProperties.Keys)

{

rel.ExtendedProperties.Add(propertyKey, extendedProperties[propertyKey]);

}

}

//Add the relations to the dataset.

Relations.Add(rel);

}

}

}

/// <summary>

/// Represents the method that will handle the RowChanging, RowChanged, RowDeleting, and RowDeleted events of a FeatureDataTable.

/// </summary>

/// <param name="sender"></param>

/// <param name="e"></param>

public delegate void FeatureDataRowChangeEventHandler(object sender, FeatureDataRowChangeEventArgs e);

/// <summary>

/// Represents one feature table of in-memory spatial data.

/// </summary>

[DebuggerStepThrough]

[Serializable]

public class FeatureDataTable : DataTable, IEnumerable

{

/// <summary>

/// Initializes a new instance of the FeatureDataTable class with no arguments.

/// </summary>

public FeatureDataTable()

{

//InitClass();

}

/// <summary>

/// Creates an instance of this class from serialization

/// </summary>

/// <param name="info">The serialization info</param>

/// <param name="context">The streaming context</param>

public FeatureDataTable(SerializationInfo info, StreamingContext context)

: base(info, context)

{

using (var ms = new MemoryStream((byte[]) info.GetValue("geometries", typeof(byte[]))))

{

using (var reader = new BinaryReader(ms))

{

var wkbReader = new WKBReader();

while (reader.BaseStream.Position < reader.BaseStream.Length)

{

var rowIndex = reader.ReadInt32();

var row = (FeatureDataRow) Rows[rowIndex];

var srid = reader.ReadInt32();

var wkbSize = reader.ReadInt32();

var wkb = reader.ReadBytes(wkbSize);

row.Geometry = wkbReader.Read(wkb);

row.Geometry.SRID = srid;

}

}

}

}

/// <summary>

/// Initializes a new instance of the FeatureDataTable class with the specified table name.

/// </summary>

/// <param name="table"></param>

public FeatureDataTable(DataTable table)

: base(table.TableName)

{

if (table.DataSet != null)

{

if ((table.CaseSensitive != table.DataSet.CaseSensitive))

{

CaseSensitive = table.CaseSensitive;

}

if ((table.Locale.ToString() != table.DataSet.Locale.ToString()))

{

Locale = table.Locale;

}

if ((table.Namespace != table.DataSet.Namespace))

{

Namespace = table.Namespace;

}

}

Prefix = table.Prefix;

MinimumCapacity = table.MinimumCapacity;

DisplayExpression = table.DisplayExpression;

}

/// <summary>

/// Gets the number of rows in the table

/// </summary>

[Browsable(false)]

public int Count

{

get { return Rows.Count; }

}

/// <summary>

/// Gets the feature data row at the specified index

/// </summary>

/// <param name="index">row index</param>

/// <returns>FeatureDataRow</returns>

public FeatureDataRow this[int index]

{

get { return (FeatureDataRow) Rows[index]; }

}

#region IEnumerable Members

/// <summary>

/// Returns an enumerator for enumerating the rows of the FeatureDataTable

/// </summary>

/// <returns></returns>

public IEnumerator GetEnumerator()

{

return Rows.GetEnumerator();

}

#endregion

/// <summary>

/// Occurs after a FeatureDataRow has been changed successfully.

/// </summary>

public event FeatureDataRowChangeEventHandler FeatureDataRowChanged;

/// <summary>

/// Occurs when a FeatureDataRow is changing.

/// </summary>

public event FeatureDataRowChangeEventHandler FeatureDataRowChanging;

/// <summary>

/// Occurs after a row in the table has been deleted.

/// </summary>

public event FeatureDataRowChangeEventHandler FeatureDataRowDeleted;

/// <summary>

/// Occurs before a row in the table is about to be deleted.

/// </summary>

public event FeatureDataRowChangeEventHandler FeatureDataRowDeleting;

/// <summary>

/// Adds a row to the FeatureDataTable

/// </summary>

/// <param name="row"></param>

public void AddRow(FeatureDataRow row)

{

Rows.Add(row);

}

/// <summary>

/// Clones the structure of the FeatureDataTable, including all FeatureDataTable schemas and constraints.

/// </summary>

/// <returns></returns>

public new FeatureDataTable Clone()

{

var cln = ((FeatureDataTable) (base.Clone()));

//cln.InitVars();

return cln;

}

/// <summary>

///

/// </summary>

/// <returns></returns>

protected override DataTable CreateInstance()

{

return new FeatureDataTable();

}

//internal void InitVars()

//{

// //this.columnFeatureGeometry = this.Columns["FeatureGeometry"];

//}

//private void InitClass()

//{

// //this.columnFeatureGeometry = new DataColumn("FeatureGeometry", typeof(GeoAPI.Geometries.IGeometry), null, System.Data.MappingType.Element);

// //this.Columns.Add(this.columnFeatureGeometry);

//}

/// <summary>

/// Creates a new FeatureDataRow with the same schema as the table.

/// </summary>

/// <returns></returns>

public new FeatureDataRow NewRow()

{

return (FeatureDataRow) base.NewRow();

}

/// <summary>

/// Creates a new FeatureDataRow with the same schema as the table, based on a datarow builder

/// </summary>

/// <param name="builder"></param>

/// <returns></returns>

protected override DataRow NewRowFromBuilder(DataRowBuilder builder)

{

return new FeatureDataRow(builder);

}

/// <summary>

///

/// </summary>

/// <returns></returns>

protected override Type GetRowType()

{

return typeof (FeatureDataRow);

}

/// <summary>

/// Raises the FeatureDataRowChanged event.

/// </summary>

/// <param name="e"></param>

protected override void OnRowChanged(DataRowChangeEventArgs e)

{

base.OnRowChanged(e);

if ((FeatureDataRowChanged != null))

{

FeatureDataRowChanged(this, new FeatureDataRowChangeEventArgs(((FeatureDataRow) (e.Row)), e.Action));

}

}

/// <summary>

/// Raises the FeatureDataRowChanging event.

/// </summary>

/// <param name="e"></param>

protected override void OnRowChanging(DataRowChangeEventArgs e)

{

base.OnRowChanging(e);

if ((FeatureDataRowChanging != null))

{

FeatureDataRowChanging(this, new FeatureDataRowChangeEventArgs(((FeatureDataRow) (e.Row)), e.Action));

}

}

/// <summary>

/// Raises the FeatureDataRowDeleted event

/// </summary>

/// <param name="e"></param>

protected override void OnRowDeleted(DataRowChangeEventArgs e)

{

base.OnRowDeleted(e);

if ((FeatureDataRowDeleted != null))

{

FeatureDataRowDeleted(this, new FeatureDataRowChangeEventArgs(((FeatureDataRow) (e.Row)), e.Action));

}

}

/// <summary>

/// Raises the FeatureDataRowDeleting event.

/// </summary>

/// <param name="e"></param>

protected override void OnRowDeleting(DataRowChangeEventArgs e)

{

base.OnRowDeleting(e);

if ((FeatureDataRowDeleting != null))

{

FeatureDataRowDeleting(this, new FeatureDataRowChangeEventArgs(((FeatureDataRow) (e.Row)), e.Action));

}

}

///// <summary>

///// Gets the collection of rows that belong to this table.

///// </summary>

//public new DataRowCollection Rows

//{

// get { throw (new NotSupportedException()); }

// set { throw (new NotSupportedException()); }

//}

/// <summary>

/// Removes the row from the table

/// </summary>

/// <param name="row">Row to remove</param>

public void RemoveRow(FeatureDataRow row)

{

Rows.Remove(row);

}

/// <summary>

/// Populates a serialization information object with the data needed to serialize the <see cref="T:System.Data.DataTable"/>.

/// </summary>

/// <param name="info">A <see cref="T:System.Runtime.Serialization.SerializationInfo"/> object that holds the serialized data associated with the <see cref="T:System.Data.DataTable"/>.</param><param name="context">A <see cref="T:System.Runtime.Serialization.StreamingContext"/> object that contains the source and destination of the serialized stream associated with the <see cref="T:System.Data.DataTable"/>.</param><exception cref="T:System.ArgumentNullException">The <paramref name="info"/> parameter is a null reference (Nothing in Visual Basic).</exception>

public override void GetObjectData(SerializationInfo info, StreamingContext context)

{

base.GetObjectData(info, context);

var rowIndex = 0;

using (var ms = new MemoryStream())

{

using (var writer = new BinaryWriter(ms))

{

foreach (FeatureDataRow row in Rows)

{

if (row.IsFeatureGeometryNull()) continue;

writer.Write(rowIndex++);

writer.Write(row.Geometry.SRID);

var wkb = row.Geometry.AsBinary();

writer.Write(wkb.Length);

writer.Write(wkb);

}

ms.Seek(0, SeekOrigin.Begin);

info.AddValue("geometries", ms.ToArray(), typeof(byte[]));

}

}

}

}

/*

/// <summary>

/// Represents the collection of tables for the FeatureDataSet.

/// </summary>

[Serializable()]

public class FeatureTableCollection : List<FeatureDataTable>

{

}

*/

/// <summary>

/// Represents the collection of tables for the FeatureDataSet.

/// It is a proxy to the <see cref="DataSet.Tables"/> object.

/// It filters out those <see cref="T:System.Data.DataTable"/>

/// that are <see cref="T:SharpMap.Data.FeatureDataTable"/>s.

/// </summary>

public class FeatureTableCollection : ICollection<FeatureDataTable>

{

private readonly DataTableCollection _dataTables;

internal FeatureTableCollection(DataTableCollection dataTables)

{

_dataTables = dataTables;

}

/// <iheritdoc cref="IEnumerable{T}.GetEnumerator"/>

public IEnumerator<FeatureDataTable> GetEnumerator()

{

var dataTables = new DataTable[_dataTables.Count];

_dataTables.CopyTo(dataTables, 0);

foreach (var dataTable in dataTables)

{

if (dataTable is FeatureDataTable)

yield return (FeatureDataTable) dataTable;

}

}

/// <summary>

/// Returns an enumerator that iterates through a collection.

/// </summary>

/// <returns>

/// An <see cref="T:System.Collections.IEnumerator"/> object that can be used to iterate through the collection.

/// </returns>

/// <filterpriority>2</filterpriority>

IEnumerator IEnumerable.GetEnumerator()

{

return GetEnumerator();

}

/// <summary>

/// Method to add a <see cref="FeatureDataTable"/> to this set.

/// </summary>

/// <remarks>If <paramref name="item"/> belongs to a different <see cref="FeatureDataSet"/>,

/// this method attempts to remove it from that. If that is not possible, <paramref name="item"/>

/// is copied (<see cref="DataTable.Copy"/>) and the copy is then added.

/// </remarks>

/// <param name="item">The feature data table to add</param>

public void Add(FeatureDataTable item)

{

var itemDataSet = item.DataSet;

if (itemDataSet != null)

{

if (itemDataSet.Tables.CanRemove(item))

itemDataSet.Tables.Remove(item);

else

item = (FeatureDataTable) item.Copy();

}

_dataTables.Add(item);

}

/// <summary>

/// Method to add a range of <see cref="FeatureDataTable"/>s to the (Feature)DataTableCollection.

/// </summary>

/// <param name="items">The tables to add</param>

public void AddRange(IEnumerable<FeatureDataTable> items)

{

foreach (var item in items)

{

_dataTables.Add(item);

}

}

/// <summary>

/// Removes all items from the <see cref="T:System.Collections.Generic.ICollection`1"/>.

/// </summary>

/// <exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.ICollection`1"/> is read-only. </exception>

public void Clear()

{

_dataTables.Clear();

}

/// <summary>

/// Determines whether the <see cref="T:System.Collections.Generic.ICollection`1"/> contains a specific value.

/// </summary>

/// <returns>

/// true if <paramref name="item"/> is found in the <see cref="T:System.Collections.Generic.ICollection`1"/>; otherwise, false.

/// </returns>

/// <param name="item">The object to locate in the <see cref="T:System.Collections.Generic.ICollection`1"/>.</param>

public bool Contains(FeatureDataTable item)

{

return _dataTables.Contains(item.TableName, item.Namespace);

}

/// <summary>

/// Copies the elements of the <see cref="T:System.Collections.Generic.ICollection`1"/> to an <see cref="T:System.Array"/>, starting at a particular <see cref="T:System.Array"/> index.

/// </summary>

/// <param name="array">The one-dimensional <see cref="T:System.Array"/> that is the destination of the elements copied from <see cref="T:System.Collections.Generic.ICollection`1"/>. The <see cref="T:System.Array"/> must have zero-based indexing.</param><param name="arrayIndex">The zero-based index in <paramref name="array"/> at which copying begins.</param><exception cref="T:System.ArgumentNullException"><paramref name="array"/> is null.</exception><exception cref="T:System.ArgumentOutOfRangeException"><paramref name="arrayIndex"/> is less than 0.</exception><exception cref="T:System.ArgumentException">The number of elements in the source <see cref="T:System.Collections.Generic.ICollection`1"/> is greater than the available space from <paramref name="arrayIndex"/> to the end of the destination <paramref name="array"/>.</exception>

public void CopyTo(FeatureDataTable[] array, int arrayIndex)

{

if (array == null)

throw new ArgumentNullException("array");

if (arrayIndex < 0)

throw new ArgumentException("Negative arrayIndex");

var j = 0;

for (var i = 0; i < _dataTables.Count; i++)

{

if (_dataTables[i] is FeatureDataTable)

{

if (j >= array.Length)

throw new ArgumentException("Insufficient space provided for array");

array[j++] = (FeatureDataTable) _dataTables[i];

}

}

}

/// <summary>

/// Removes the first occurrence of a specific object from the <see cref="T:System.Collections.Generic.ICollection`1"/>.

/// </summary>

/// <returns>

/// true if <paramref name="item"/> was successfully removed from the <see cref="T:System.Collections.Generic.ICollection`1"/>; otherwise, false. This method also returns false if <paramref name="item"/> is not found in the original <see cref="T:System.Collections.Generic.ICollection`1"/>.

/// </returns>

/// <param name="item">The object to remove from the <see cref="T:System.Collections.Generic.ICollection`1"/>.</param><exception cref="T:System.NotSupportedException">The <see cref="T:System.Collections.Generic.ICollection`1"/> is read-only.</exception>

public bool Remove(FeatureDataTable item)

{

if (_dataTables.CanRemove(item))

{

_dataTables.Remove(item);

return true;

}

return false;

}

/// <summary>

/// Remove the feature data table at the provided index

/// </summary>

/// <param name="index">The index of the table to remove</param>

/// <returns><c>true</c> if the table was successfully removed</returns>

/// <exception cref="ArgumentOutOfRangeException"></exception>

public bool RemoveAt(int index)

{

if (index < 0)

throw new ArgumentOutOfRangeException("index");

var tmp = 0;

DataTable tableToRemove = null;

foreach (DataTable dataTable in _dataTables)

{

if (dataTable is FeatureDataTable)

{

if (tmp == index)

{

tableToRemove = dataTable;

break;

}

tmp++;

}

}

if (tableToRemove != null)

return Remove((FeatureDataTable)tableToRemove);

return false;

}

/// <summary>

/// Gets the number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1"/>.

/// </summary>

/// <returns>

/// The number of elements contained in the <see cref="T:System.Collections.Generic.ICollection`1"/>.

/// </returns>

public int Count

{

get

{

var i = 0;

foreach (var dataTable in _dataTables)

{

if (dataTable is FeatureDataTable)

i++;

}

return i;

}

}

/// <summary>

/// Gets a value indicating whether the <see cref="T:System.Collections.Generic.ICollection`1"/> is read-only.

/// </summary>

/// <returns>

/// true if the <see cref="T:System.Collections.Generic.ICollection`1"/> is read-only; otherwise, false.

/// </returns>

public bool IsReadOnly

{

get { return false; }

}

/// <summary>

/// An indexer to the feature data tables in this set

/// </summary>

/// <param name="index">The index of the feature data table to get</param>

/// <returns>The feature data table at index <paramref name="index"/>.</returns>

/// <exception cref="ArgumentOutOfRangeException">Thrown, if the index is not in the valid range.</exception>

public FeatureDataTable this[int index]

{

get

{

var i = 0;

foreach (var dataTable in _dataTables)

{

if (dataTable is FeatureDataTable)

{

if (i == index)

return (FeatureDataTable) dataTable;

i++;

}

}

throw new ArgumentOutOfRangeException("index");

}

}

}

/// <summary>

/// Represents a row of data in a FeatureDataTable.

/// </summary>

[DebuggerStepThrough]

[Serializable]

public class FeatureDataRow : DataRow

{

//private FeatureDataTable tableFeatureTable;

private IGeometry _geometry;

/// <summary>

/// Creates an instance of this class

/// </summary>

/// <param name="rb">The row builder</param>

public FeatureDataRow(DataRowBuilder rb)

: base(rb)

{

}

/// <summary>

/// The geometry of the current feature

/// </summary>

public IGeometry Geometry

{

get { return _geometry; }

set

{

if (_geometry == null) {

_geometry = value;

} else {

if (ReferenceEquals(_geometry, value))

return;

if (_geometry != null && _geometry.EqualsTopologically(value))

return;

_geometry = value;

if (RowState == DataRowState.Unchanged) SetModified();

}

}

}

/// <summary>

/// Returns true of the geometry is null

/// </summary>

/// <returns></returns>

public bool IsFeatureGeometryNull()

{

return _geometry == null;

}

/// <summary>

/// Sets the geometry column to null

/// </summary>

public void SetFeatureGeometryNull()

{

_geometry = null;

}

}

/// <summary>

/// Occurs after a FeatureDataRow has been changed successfully.

/// </summary>

[DebuggerStepThrough]

public class FeatureDataRowChangeEventArgs : EventArgs

{

private readonly DataRowAction _eventAction;

private readonly FeatureDataRow _eventRow;

/// <summary>

/// Initializes a new instance of the FeatureDataRowChangeEventArgs class.

/// </summary>

/// <param name="row"></param>

/// <param name="action"></param>

public FeatureDataRowChangeEventArgs(FeatureDataRow row, DataRowAction action)

{

_eventRow = row;

_eventAction = action;

}

/// <summary>

/// Gets the row upon which an action has occurred.

/// </summary>

public FeatureDataRow Row

{

get { return _eventRow; }

}

/// <summary>

/// Gets the action that has occurred on a FeatureDataRow.

/// </summary>

public DataRowAction Action

{

get { return _eventAction; }

}

}

}