internal FeatureRow(DataRowBuilder rb) :
     base(rb)
 {
     tableFeature = ((FeatureDataTable) (Table));
 }

 public void AddedRowChangesRowState()
 {
     FeatureDataTable table = new FeatureDataTable();
     FeatureDataRow row = table.NewRow();
     table.AddRow(row);
     Assert.AreEqual(DataRowState.Added, row.RowState);
 }

        /// <summary>
        /// reloads the data
        /// </summary>
        public void Reload()
        {
            using (System.Data.OleDb.OleDbConnection conn = new OleDbConnection(_ConnectionString))
            {
                string strSQL = "Select * FROM " + this.Table;

                using (System.Data.OleDb.OleDbDataAdapter adapter = new OleDbDataAdapter(strSQL, conn))
                {
                    conn.Open();
                    System.Data.DataSet ds2 = new System.Data.DataSet();
                    adapter.Fill(ds2);
                    conn.Close();
                    if (ds2.Tables.Count > 0)
                    {
                        m_fdt = new FeatureDataTable(ds2.Tables[0]);
                        foreach (System.Data.DataColumn col in ds2.Tables[0].Columns)
                            m_fdt.Columns.Add(col.ColumnName, col.DataType, col.Expression);
                        foreach (System.Data.DataRow dr in ds2.Tables[0].Rows)
                        {
                            SharpMap.Data.FeatureDataRow fdr = m_fdt.NewRow();
                            foreach (System.Data.DataColumn col in ds2.Tables[0].Columns)
                                fdr[col.ColumnName] = dr[col];
                            SharpMap.Geometries.Geometry geom = SharpMap.Converters.WellKnownBinary.GeometryFromWKB.Parse((byte[])dr[this.GeometryColumn]);
                            fdr.Geometry = geom;
                            m_fdt.AddRow(fdr);
                        }
                    }
                }
            }
        }

        /// <summary>
        /// Protected constructor for the abstract class.
        /// </summary>
        /// <param name="httpClientUtil">A configured <see cref="HttpClientUtil"/> instance for performing web requests</param>
        /// <param name="featureTypeInfo">A <see cref="WfsFeatureTypeInfo"/> instance providing metadata of the featuretype to query</param>
        /// <param name="labelInfo">A FeatureDataTable for labels</param>
        protected GeometryFactory(HttpClientUtil httpClientUtil, WfsFeatureTypeInfo featureTypeInfo,
                                  FeatureDataTable labelInfo)
        {
            _FeatureTypeInfo = featureTypeInfo;
            _HttpClientUtil = httpClientUtil;
            createReader(httpClientUtil);

            try
            {
                if (labelInfo != null)
                {
                    _LabelInfo = labelInfo;
                    _LabelNode = new PathNode(_FeatureTypeInfo.FeatureTypeNamespace, _LabelInfo.Columns[0].ColumnName,
                                              (NameTable) _XmlReader.NameTable);
                }
            }
            catch (Exception ex)
            {
                Trace.TraceError("An exception occured while initializing the label path node!");
                throw ex;
            }

            initializePathNodes();
            initializeSeparators();
        }

        /// <summary>
        /// This method takes a pre-populated FeatureDataTable and removes rows that do not truly intersect testGeometry
        /// </summary>
        /// <param name="featureDataTable">The FeatureDataTable instance to filter</param>
        /// <param name="testGeometry">the geometry to compare against</param>
        public void PostFilterExistingFeatureDataTable(FeatureDataTable featureDataTable, Geometry testGeometry)
        {
            //first we create a new GeometryFactory.
            GeometryFactory geometryFactory = new GeometryFactory();


            //then we convert the testGeometry into the equivalent NTS geometry
            GeoAPI.Geometries.IGeometry testGeometryAsNtsGeom = GeometryConverter.ToNTSGeometry(testGeometry, geometryFactory);


            //now we loop backwards through the FeatureDataTable 
            for (int i = featureDataTable.Rows.Count - 1; i > -1; i--)
            {
                //we get each row
                FeatureDataRow featureDataRow = featureDataTable.Rows[i] as FeatureDataRow;
                //and get the rows' geometry
                Geometry compareGeometry = featureDataRow.Geometry;
                //convert the rows' geometry into the equivalent NTS geometry
                GeoAPI.Geometries.IGeometry compareGeometryAsNts = GeometryConverter.ToNTSGeometry(compareGeometry, geometryFactory);
                //now test for intesection (note other operations such as Contains, Within, Disjoint etc can all be done the same way)
                bool intersects = testGeometryAsNtsGeom.Intersects(compareGeometryAsNts);

                //if it doesn't intersect remove the row.
                if (!intersects)
                    featureDataTable.Rows.RemoveAt(i);
            }
        }

        /// <summary>
        /// Protected constructor for the abstract class.
        /// </summary>
        /// <param name="httpClientUtil">A configured <see cref="HttpClientUtil"/> instance for performing web requests</param>
        /// <param name="featureTypeInfo">A <see cref="WfsFeatureTypeInfo"/> instance providing metadata of the featuretype to query</param>
        /// <param name="labelInfo">A FeatureDataTable for labels</param>
        protected GeometryFactory(HttpClientUtil httpClientUtil, WfsFeatureTypeInfo featureTypeInfo,
                                  FeatureDataTable labelInfo)
        {
            _FeatureTypeInfo = featureTypeInfo;
            Factory = featureTypeInfo.Factory;
            _httpClientUtil = httpClientUtil;
            createReader(httpClientUtil);

            try
            {
                if (labelInfo != null)
                {
                    _LabelInfo = labelInfo;
                    var pathNodes = new IPathNode[labelInfo.Columns.Count];
                    for (var i = 0; i < pathNodes.Length; i++)
                    {
                        pathNodes[i] = new PathNode(_FeatureTypeInfo.FeatureTypeNamespace, _LabelInfo.Columns[i].ColumnName, (NameTable)_XmlReader.NameTable);
                    }
                    _LabelNode = new AlternativePathNodesCollection(pathNodes);
                }
            }
            catch (Exception ex)
            {
                Trace.TraceError("An exception occured while initializing the label path node!");
                throw ex;
            }

            initializePathNodes();
            initializeSeparators();
        }

        /// <summary>
        /// little util wich just adds one vector layer to the map and assigns it a random theme.
        /// </summary>
        /// <param name="context"></param>
        /// <param name="m"></param>
        public static void SetupMap(HttpContext context, Map m)
        {
            var l = new VectorLayer(
                "Countries",
                new ShapeFile(context.Server.MapPath(ConfigurationManager.AppSettings["shpfilePath"])));

            l.Style = RandomStyle.RandomVectorStyleNoSymbols();
            l.Theme = new CustomTheme<IVectorStyle>(
                delegate { return RandomStyle.RandomVectorStyleNoSymbols(); });
            m.Layers.Add(l);

            FeatureDataTable labelData = new FeatureDataTable();
            labelData.Columns.Add("Name", typeof (string));
            FeatureDataRow r = labelData.NewRow();
            r["Name"] = "My Lair";
            r.Geometry = new Point(5, 5);
            labelData.AddRow(r);

            LabelLayer labelLayer = new LabelLayer("labelLayer")
                            {
                                DataSource = new GeometryFeatureProvider(labelData),
                                Enabled = true,
                                LabelColumn = "Name",
                                Style = new LabelStyle
                                            {
                                                BackColor = new SolidBrush(Color.Black),
                                                ForeColor = Color.White,
                                                Halo = new Pen(Color.Yellow, 0.1F),
                                                CollisionDetection = false,
                                                Font = new Font("Arial", 10, GraphicsUnit.Point)
                                            }
                            };

            m.Layers.Add(labelLayer);
        }

        internal static FeatureDataTable<uint> GetFeatureTableForFields(IEnumerable<DbaseField> _dbaseColumns)
        {
            FeatureDataTable<uint> table = new FeatureDataTable<uint>(OidColumnName);

            foreach (DbaseField dbf in _dbaseColumns)
            {
                DataColumn col = table.Columns.Add(dbf.ColumnName, dbf.DataType);

				if (dbf.DataType == typeof(string))
				{
					col.MaxLength = dbf.Length;
				}
				else
				{
                    col.ExtendedProperties[ProviderSchemaHelper.LengthExtendedProperty] = dbf.Length;
				}

				if (dbf.Decimals > 0)
				{
                    col.ExtendedProperties[ProviderSchemaHelper.NumericPrecisionExtendedProperty] = dbf.Decimals;
				}
            }

            return table;
        }

        public void GetSetAttributesViaIFeature()
        {
            var featureTable = new FeatureDataTable();
            featureTable.Columns.Add("name", typeof (string));
            featureTable.Columns.Add("attribute1", typeof(int));

            var feature1 = featureTable.NewRow();
            feature1.Geometry = new Point(0, 0);
            feature1["name"] = "feature1";
            feature1["attribute1"] = 1;
            featureTable.Rows.Add(feature1);

            // now access it using IFeature iterfaces
            IFeature f1 = feature1;

            f1.Attributes.Count
                .Should().Be.EqualTo(2);

            f1.Attributes.Keys
                .Should().Have.SameSequenceAs(new[] {"name", "attribute1"});

            f1.Attributes["name"]
                .Should().Be.EqualTo("feature1");

            f1.Attributes["attribute1"]
                .Should().Be.EqualTo(1);

            f1.Attributes[0]
                .Should().Be.EqualTo("feature1");

            f1.Attributes[1]
                .Should().Be.EqualTo(1);
        }

        public void ShowMapWithPointLayerBasedOnFeatureDataTable()
        {
            var table = new FeatureDataTable();
            table.Columns.Add("X", typeof(double));
            table.Columns.Add("Y", typeof(double));
            table.Columns.Add("Category", typeof(string));
            DataRow row = table.NewRow();
            table.Rows.Add(row);
            row.ItemArray = new object[] { 100000, 400000, "testCategory" };
            row = table.NewRow();
            table.Rows.Add(row);
            row.ItemArray = new object[] { 200000, 400000, "TestCategory" };

            var dataTablePoint = new DataTablePoint(table, "Category", "X", "Y");
            var vectorLayer = new VectorLayer("test", dataTablePoint);


            vectorLayer.Theme =ThemeFactory.CreateSingleFeatureTheme(vectorLayer.Style.GeometryType, Color.Blue, 10);
            var map = new Map { Name = "testmap" };

            map.Layers.Add(vectorLayer);
            map.Center = new Coordinate(150000, 400000);

            map.Zoom = 200000;
            //map.ZoomToExtents();
            //map.ZoomToBox(map.Envelope);
            
            MapTestHelper.Show(map);
        }

 public void AddedRowAppearsAsChange()
 {
     FeatureDataTable table = new FeatureDataTable();
     FeatureDataRow row = table.NewRow();
     table.AddRow(row);
     FeatureDataTable changes = table.GetChanges();
     Assert.AreEqual(1, changes.FeatureCount);
 }

 public void AcceptChangesAppearAsUnchanged()
 {
     FeatureDataTable table = new FeatureDataTable();
     FeatureDataRow row = table.NewRow();
     table.AddRow(row);
     table.AcceptChanges();
     Assert.AreEqual(DataRowState.Unchanged, row.RowState);
 }

 protected static FeatureDataTable CreateTable()
 {
     var res = new FeatureDataTable();
     res.Columns.Add(new DataColumn("Oid", typeof(ushort)));
     res.Columns.Add(new DataColumn("Value", typeof(double)));
     res.Constraints.Add("PK_OID", res.Columns[0], true);
     return res;
 }

 public void AddedRowIncreasesRowCount()
 {
     FeatureDataTable table = new FeatureDataTable();
     FeatureDataRow row = table.NewRow();
     table.AddRow(row);
     Assert.AreEqual(1, table.Rows.Count);
     Assert.AreEqual(1, table.FeatureCount);
 }

 public void NewRowReturnsDetachedFeatureDataRow()
 {
     FeatureDataTable table = new FeatureDataTable();
     FeatureDataRow row = table.NewRow();
     Assert.IsNotNull(row);
     Assert.AreEqual(0, table.Rows.Count);
     Assert.AreEqual(DataRowState.Detached, row.RowState);
     Assert.AreSame(table, row.Table);
 }

 public void AcceptChangesReturnsNullChangesTable()
 {
     FeatureDataTable table = new FeatureDataTable();
     FeatureDataRow row = table.NewRow();
     table.AddRow(row);
     table.AcceptChanges();
     FeatureDataTable changes = table.GetChanges();
     Assert.IsNull(changes);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="GeometryProvider"/>
 /// </summary>
 /// <param name="geometries">Set of geometries that this datasource should contain</param>
 public GeometryFeatureProvider(Collection<Geometry> geometries)
 {
     _features = new FeatureDataTable();
     foreach (Geometry geom in geometries)
     {
         FeatureDataRow fdr = _features.NewRow();
         fdr.Geometry = geom;
         _features.AddRow(fdr);
     }
 }

 private static FeatureDataTable CreateFeatureDataTable(string name)
 {
     var t1 = new FeatureDataTable { TableName = name };
     t1.Columns.Add(new DataColumn("oid", typeof(uint)));
     t1.Columns.Add(new DataColumn("P1", typeof(string)));
     t1.Columns.Add(new DataColumn("P2", typeof(double)));
     t1.Columns.Add(new DataColumn("P3", typeof(DateTime)));
     t1.PrimaryKey = new[] { t1.Columns[0] };
     return t1;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="GeometryProvider"/>
 /// </summary>
 /// <param name="geometries">Set of geometries that this datasource should contain</param>
 public GeometryFeatureProvider(IEnumerable<IGeometry> geometries)
 {
     _features = new FeatureDataTable();
     foreach (var geom in geometries)
     {
         var fdr = _features.NewRow();
         fdr.Geometry = geom;
         _features.AddRow(fdr);
     }
     _features.TableCleared += HandleFeaturesCleared;
 }

        public void KeepColumnNamesInSync()
        {
            var table = new FeatureDataTable();
            var row = table.NewRow();
            table.Rows.Add(row);

            var accessor = new FeatureDataRowAttributeAccessor(row);

            // now add column and check if it is available via accessor
            table.Columns.Add("Name", typeof (string));

            accessor.Count
                .Should().Be.EqualTo(1);
        }