ThinkGeo Wiki

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== ThinkGeo.MapSuite.Core.EditTools ======
This class is a wrapper class for the FeatureLayer that isolates only the editing methods to make them easily accessible to the programmer.
===== Inheritance Hierarchy =====
  *System.Object
    ***ThinkGeo.MapSuite.Core.EditTools**
===== Members Summary =====
==== Public Constructors ====
** {{wiki:PublicMethod.gif|}} EditTools(FeatureSource) **

This is a constructor for the class.
== Remarks ==
None
== Parameters ==
  * //featureSource//
    * Type:[[ThinkGeo.MapSuite.Core.FeatureSource|FeatureSource]]
    * Description:This parameter is the FeatureSource that the edit operations will pass through to.

<div newline></div>
==== Protected Constructors ====
** {{wiki:ProtectedMethod.gif|}} EditTools() **

This is a constructor for the class.
== Remarks ==
This is the default constructor. It is protected and not meant to be used.
== Parameters ==
<div newline></div>
==== Public Methods ====
** {{wiki:PublicMethod.gif|}} BeginTransaction() **

This method starts a new transaction if the FeatureLayer allows editing.
== Remarks ==
This method is used to start a transaction, assuming that the FeatureLayer allows editing. There are some additional prerequisites to beginning a transaction, such as ensuring that a transaction is not already in progress. You must also be sure that the FeatureSource has been opened. The Transaction System The transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer. In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object. As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures.  The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again.  This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed. In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records.  In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes.

== Return Value ==
  * Type:Void
  * Description:None

== Parameters ==
<div newline></div>
** {{wiki:PublicMethod.gif|}} Add(BaseShape) **

This method adds a new Feature to an existing transaction.
== Remarks ==
This method adds a new Feature to an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction. The Transaction System The transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer. In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object. As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures.  The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again.  This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed. In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records.  In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes.

== Return Value ==
  * Type:String
  * Description:This string is the ID that will uniquely identify this Feature while it is in a transaction.

== Parameters ==
  * //shape//
    * Type:[[ThinkGeo.MapSuite.Core.BaseShape|BaseShape]]
    * Description:This parameter represents the new shape that will be added to the transaction.

<div newline></div>
** {{wiki:PublicMethod.gif|}} Add(Feature) **

This method adds a new Feature to an existing transaction.
== Remarks ==
This method adds a new Feature to an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction. The Transaction System The transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer. In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object. As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures.  The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again.  This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed. In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records.  In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes.

== Return Value ==
  * Type:String
  * Description:This string is the ID that will uniquely identify this Feature while it is in a transaction.

== Parameters ==
  * //feature//
    * Type:[[ThinkGeo.MapSuite.Core.Feature|Feature]]
    * Description:This parameter represents the new Feature that will be added to the transaction.

<div newline></div>
** {{wiki:PublicMethod.gif|}} Add(BaseShape,Dictionary<String,String>) **

N/A
== Remarks ==
N/A

== Return Value ==
  * Type:String
  * Description:N/A

== Parameters ==
  * //shape//
    * Type:[[ThinkGeo.MapSuite.Core.BaseShape|BaseShape]]
    * Description:N/A

  * //columnValues//
    * Type:Dictionary<String,String>
    * Description:N/A

<div newline></div>
** {{wiki:PublicMethod.gif|}} ScaleUp(String,Double) **

This method increases the size of the feature by the percentage given in the percentage parameter.
== Remarks ==
This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource. This method is useful when you would like to increase the size of the Feature. Note that a larger percentage will scale the shape up faster as you apply the operation multiple times. There is also a ScaleDown method that will shrink the shape as well.

== Return Value ==
  * Type:Void
  * Description:N/A

== Parameters ==
  * //featureId//
    * Type:String
    * Description:This parameter is the Id of the Feature you want to scale.

  * //percentage//
    * Type:Double
    * Description:This is the percentage by which to increase the Feature's size.

<div newline></div>
** {{wiki:PublicMethod.gif|}} ScaleDown(String,Double) **

This method decreases the size of the feature by the percentage given in the percentage parameter.
== Remarks ==
This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource. This method is useful when you would like to decrease the size of the Feature. Note that a larger percentage will scale the shape down faster as you apply the operation multiple times. There is also a ScaleUp method that will expand the shape as well.

== Return Value ==
  * Type:Void
  * Description:N/A

== Parameters ==
  * //featureId//
    * Type:String
    * Description:This parameter is the Id of the Feature you want to scale.

  * //percentage//
    * Type:Double
    * Description:This is the percentage by which to decrease the Feature's size.

<div newline></div>
** {{wiki:PublicMethod.gif|}} TranslateByDegree(String,Double,Double,GeographyUnit,DistanceUnit) **

This method moves the Feature from one location to another based on a distance and a direction in degrees.
== Remarks ==
This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource. This method moves the Feature from one location to another based on angleInDegrees and the distance parameter. With this overload, it is important to note that the distance units are based on the specified distanceUnit parameter. For example, if your Feature is in decimal degrees and you call this method with a specified distanceUnit of miles, you're going to move this shape a number of miles based on the distance and angleInDegrees. In this way, you could easily move a shape in decimal degrees five miles to the north.If you pass a distance of 0, the operation is ignored.

== Return Value ==
  * Type:Void
  * Description:None

== Parameters ==
  * //featureId//
    * Type:String
    * Description:This parameter is the Feature you want to move.

  * //distance//
    * Type:Double
    * Description:The distance is the number of units to move the shape using the angle specified. The distance unit will be the DistanceUnit specified in the distanceUnit parameter. The distance must be greater than or equal to 0.

  * //angleInDegrees//
    * Type:Double
    * Description:A number between 0 and 360 degrees that represents the direction you wish to move the shape, with zero being up.

  * //shapeUnit//
    * Type:[[ThinkGeo.MapSuite.Core.GeographyUnit|GeographyUnit]]
    * Description:This is the GeographicUnit of the shape you are performing the operation on.

  * //distanceUnit//
    * Type:[[ThinkGeo.MapSuite.Core.DistanceUnit|DistanceUnit]]
    * Description:This is the DistanceUnit you would like to use as the measure of the translate. For example, if you select miles as your distanceUnit, then the distance will be calculated in miles.

<div newline></div>
** {{wiki:PublicMethod.gif|}} TranslateByOffset(String,Double,Double,GeographyUnit,DistanceUnit) **

This method moves the Feature from one location to another based on a X and Y offset distance.
== Remarks ==
This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource. This method moves the Feature from one location to another based on an X and Y offset distance. With this overload, it is important to note that the distance units are based on the specified distanceUnit parameter. For example, if your Feature is in decimal degrees and you call this method with an X offset of 1 and a Y offset of 1, you're going to move this Feature one unit of the distanceUnit in the horizontal direction and one unit of the distanceUnit in the vertical direction. In this way, you could easily move a Feature in decimal degrees five miles on the X axis and 3 miles on the Y axis.

== Return Value ==
  * Type:Void
  * Description:None

== Parameters ==
  * //featureId//
    * Type:String
    * Description:This parameter is the Feature you want to move.

  * //xOffset//
    * Type:Double
    * Description:This is the number of horizontal units of movement in the DistanceUnit specified in the distanceUnit parameter.

  * //yOffset//
    * Type:Double
    * Description:This is the number of horizontal units of movement in the DistanceUnit specified in the distanceUnit parameter.

  * //shapeUnit//
    * Type:[[ThinkGeo.MapSuite.Core.GeographyUnit|GeographyUnit]]
    * Description:This is the GeographicUnit of the shape you are performing the operation on.

  * //offsetUnit//
    * Type:[[ThinkGeo.MapSuite.Core.DistanceUnit|DistanceUnit]]
    * Description:This is the DistanceUnit you would like to use as the measure of the translate. For example, if you select miles as your distanceUnit, then the xOffsetDistance and yOffsetDistance will be calculated in miles.

<div newline></div>
** {{wiki:PublicMethod.gif|}} Rotate(String,PointShape,Single) **

This method rotates the Feature any number of degrees based on a pivot point.
== Remarks ==
This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource. This method rotates the Feature based on a pivot point by a number of degrees. By placing the pivot point in the center of the Feature, you can achieve in-place rotation. By moving the pivot point outside of the center of the Feature, you can translate the shape in a circular motion. Moving the pivot point further outside of the center will make the circular area larger.

== Return Value ==
  * Type:Void
  * Description:None

== Parameters ==
  * //featureId//
    * Type:String
    * Description:This parameter is the Feature you want to rotate.

  * //pivotPoint//
    * Type:[[ThinkGeo.MapSuite.Core.PointShape|PointShape]]
    * Description:The pivotPoint represents the center of rotation.

  * //degreeAngle//
    * Type:Single
    * Description:The number of degrees of rotation, from 0 to 360.

<div newline></div>
** {{wiki:PublicMethod.gif|}} Union(String,AreaBaseShape) **

This method returns the union of the Feature and the target shapes, which are defined as the set of all points in the Feature or the target shape.
== Remarks ==
This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource. This is useful for adding area shapes together to form a larger area shape.

== Return Value ==
  * Type:Void
  * Description:None

== Parameters ==
  * //featureId//
    * Type:String
    * Description:This parameter is the Feature you want to add the new area to.

  * //targetShape//
    * Type:[[ThinkGeo.MapSuite.Core.AreaBaseShape|AreaBaseShape]]
    * Description:The shape you are trying to find the union with.

<div newline></div>
** {{wiki:PublicMethod.gif|}} Union(String,Feature) **

This method returns the union of the Feature and the target features, which are defined as the set of all points in the Feature or the target shape.
== Remarks ==
This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource. This is useful for adding area shapes together to form a larger area shape.

== Return Value ==
  * Type:Void
  * Description:None

== Parameters ==
  * //featureId//
    * Type:String
    * Description:This parameter is the Feature you want to add the new area to.

  * //targetAreaFeature//
    * Type:[[ThinkGeo.MapSuite.Core.Feature|Feature]]
    * Description:The feature you are trying to find the union with.

<div newline></div>
** {{wiki:PublicMethod.gif|}} GetDifference(String,AreaBaseShape) **

This method returns the difference between two shapes, which are defined as the set of all points that lie in the Feature but not in the targetShape.
== Remarks ==
This method is a helpful function that allows you to easily edit InternalFeatures directly in the FeatureSource without having to retrieve them, convert them to a shape, manipulate them and put them back into the FeatureSource.

== Return Value ==
  * Type:Void
  * Description:None

== Parameters ==
  * //featureId//
    * Type:String
    * Description:This is the Feature you want to remove area from.

  * //targetShape//
    * Type:[[ThinkGeo.MapSuite.Core.AreaBaseShape|AreaBaseShape]]
    * Description:The shape you are trying to find the difference with.

<div newline></div>
** {{wiki:PublicMethod.gif|}} GetDifference(String,Feature) **

This method returns the difference between two features, which are defined as the set of all points which lie in the Feature but not in the targetFeature.
== Remarks ==
N/A

== Return Value ==
  * Type:Void
  * Description:None

== Parameters ==
  * //featureId//
    * Type:String
    * Description:This is the Feature you want to remove area from.

  * //targetAreaFeature//
    * Type:[[ThinkGeo.MapSuite.Core.Feature|Feature]]
    * Description:The feature you are trying to find the difference with.

<div newline></div>
** {{wiki:PublicMethod.gif|}} Delete(String) **

This method deletes a Feature from an existing transaction.
== Remarks ==
This method deletes a Feature from an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction. The Transaction System The transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer. In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object. As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures.  The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again.  This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed. In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records.  In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes.

== Return Value ==
  * Type:Void
  * Description:None

== Parameters ==
  * //id//
    * Type:String
    * Description:This string is the Id of the feature in the FeatureLayer that you wish to delete.

<div newline></div>
** {{wiki:PublicMethod.gif|}} Update(BaseShape) **

This method updates a Feature in an existing transaction.
== Remarks ==
This method updates a Feature in an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction.The Transaction SystemThe transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer.In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object.As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures.  The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again.  This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed.In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records.  In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes.

== Return Value ==
  * Type:Void
  * Description:None

== Parameters ==
  * //shape//
    * Type:[[ThinkGeo.MapSuite.Core.BaseShape|BaseShape]]
    * Description:The shape you wish to update in the transaction. The Id of the Shape should be the feature Id which you wish to update.

<div newline></div>
** {{wiki:PublicMethod.gif|}} Update(Feature) **

This method updates a Feature in an existing transaction.
== Remarks ==
This method updates a Feature in an existing transaction. You will need to ensure that you have started a transaction by calling BeginTransaction.The Transaction SystemThe transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer.In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object.As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures.  The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again.  This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed.In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records.  In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes.

== Return Value ==
  * Type:Void
  * Description:None

== Parameters ==
  * //feature//
    * Type:[[ThinkGeo.MapSuite.Core.Feature|Feature]]
    * Description:The Feature you wish to update in the transaction.

<div newline></div>
** {{wiki:PublicMethod.gif|}} Update(BaseShape,Dictionary<String,String>) **

N/A
== Remarks ==
N/A

== Return Value ==
  * Type:Void
  * Description:N/A

== Parameters ==
  * //shape//
    * Type:[[ThinkGeo.MapSuite.Core.BaseShape|BaseShape]]
    * Description:N/A

  * //columnValues//
    * Type:Dictionary<String,String>
    * Description:N/A

<div newline></div>
** {{wiki:PublicMethod.gif|}} RollbackTransaction() **

This method will cancel an existing transaction. It will free up the internal memory cache of any InternalFeatures added, updated or deleted.
== Remarks ==
This method will cancel an existing transaction. It will free up the internal memory cache of any InternalFeatures added, updated or deleted. You will need to ensure that you have started a transaction by calling BeginTransaction.The Transaction SystemThe transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer.In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object.As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures.  The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again.  This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed.In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records.  In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes.

== Return Value ==
  * Type:Void
  * Description:None

== Parameters ==
<div newline></div>
** {{wiki:PublicMethod.gif|}} CommitTransaction() **

This method will commit the existing transaction to its underlying source of data.
== Remarks ==
This method will commit the existing transaction to its underlying source of data. It will then pass back the results of the commit, including any error(s) received. Finally, it will free up the internal memory cache of any InternalFeatures added, updated or deleted. You will need to ensure that you have started a transaction by calling BeginTransaction.The Transaction SystemThe transaction system of a FeatureLayer sits on top of the inherited implementation of any specific source, such as Oracle Spatial or Shape files. In this way, it functions the same way for every FeatureLayer. You start by calling BeginTransaction. This allocates a collection of in-memory change buffers that are used to store changes until you commit the transaction. So, for example, when you call the Add, Delete or Update method, the changes to the feature are stored in memory only. If for any reason you choose to abandon the transaction, you can call RollbackTransaction at any time and the in-memory buffer will be deleted and the changes will be lost. When you are ready to commit the transaction, you call CommitTransaction and the collections of changes are then passed to the CommitTransactionCore method and the implementer of the specific FeatureLayer is responsible for integrating your changes into the underlying FeatureLayer. By default the IsLiveTransaction property is set to false, which means that until you commit the changes, the FeatureLayer API will not reflect any changes that are in the temporary editing buffer.In the case where the IsLiveTransaction is set to true, then things function slightly differently. The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object.As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures.  The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again.  This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed.In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records.  In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes.

== Return Value ==
  * Type:[[ThinkGeo.MapSuite.Core.TransactionResult|TransactionResult]]
  * Description:The returned decimalDegreesValue of this method is a TransactionResult class, which gives you the status of the transaction you just committed. It includes how many of the updates, adds, and deletes were successful and any errors that were encountered during the committing of the transaction.

== Parameters ==
<div newline></div>
** {{wiki:PublicMethod.gif|}} ToString() **

N/A
== Remarks ==
N/A

== Return Value ==
  * Type:String
  * Description:N/A

== Parameters ==
<div newline></div>
** {{wiki:PublicMethod.gif|}} Equals(Object) **

N/A
== Remarks ==
N/A

== Return Value ==
  * Type:Boolean
  * Description:N/A

== Parameters ==
  * //obj//
    * Type:Object
    * Description:N/A

<div newline></div>
** {{wiki:PublicMethod.gif|}} GetHashCode() **

N/A
== Remarks ==
N/A

== Return Value ==
  * Type:Int32
  * Description:N/A

== Parameters ==
<div newline></div>
** {{wiki:PublicMethod.gif|}} GetType() **

N/A
== Remarks ==
N/A

== Return Value ==
  * Type:Type
  * Description:N/A

== Parameters ==
<div newline></div>
==== Protected Methods ====
** {{wiki:ProtectedMethod.gif|}} Finalize() **

N/A
== Remarks ==
N/A

== Return Value ==
  * Type:Void
  * Description:N/A

== Parameters ==
<div newline></div>
** {{wiki:ProtectedMethod.gif|}} MemberwiseClone() **

N/A
== Remarks ==
N/A

== Return Value ==
  * Type:Object
  * Description:N/A

== Parameters ==
<div newline></div>
==== Public Properties ====
** {{wiki:PublicProperty.gif|}} IsInTransaction **

This property returns true if the FeatureLayer is in a transaction and false if it is not.
== Remarks ==
To enter a transaction, you must first call the BeginTransaction method of the FeatureLayer. It is possible that some FeatureLayers are read only and do not allow edits. To end a transaction, you must either call CommitTransaction or RollbackTransaction.
== Return Value ==
  * Type:Boolean

** {{wiki:PublicProperty.gif|}} IsTransactionLive **

This property returns true if the features currently modified in a transaction are expected to reflect their state when calling other methods on the FeatureLayer, such as spatial queries.
== Remarks ==
The live transaction concept means that all of the modifications you perform during a transaction are live from the standpoint of the querying methods on the object. As an example, imagine that you have a FeatureLayer that has 10 records in it. Next, you begin a transaction and then call GetAllFeatures.  The result would be 10 records. After that, you call a delete on one of the records and call the GetAllFeatures again.  This time you only get nine records, even though the transaction has not yet been committed. In the same sense, you could have added a new record or modified an existing one and those changes would be considered live, though not committed. In the case where you modify records -- such as expanding the size of a polygon -- those changes are reflected as well. For example, you expand a polygon by doubling its size and then do a spatial query that would not normally return the smaller record, but instead would return the larger records.  In this case, the larger records are returned. You can set this property to be false, as well; in which case, all of the spatially related methods would ignore anything that is currently in the transaction buffer waiting to be committed. In such a case, only after committing the transaction would the FeatureLayer reflect the changes.
== Return Value ==
  * Type:Boolean

** {{wiki:PublicProperty.gif|}} IsEditable **

This property returns whether the FeatureLayer allows edits or is read only.
== Remarks ==
This property is useful to check if a specific FeatureLayer accepts editing. If you call BeginTransaction and this property is false, then an exception will be raised.
== Return Value ==
  * Type:Boolean

** {{wiki:PublicProperty.gif|}} TransactionBuffer **

This property allows you get and set the transaction buffer.
== Remarks ==
N/A
== Return Value ==
  * Type:[[ThinkGeo.MapSuite.Core.TransactionBuffer|TransactionBuffer]]

==== Protected Properties ====
==== Public Events ====
User Tools

Site Tools

Page Tools
