You can create or delete features, or update existing features, using the FeatureTable API.
The API gives you more fine-grained control over feature editing operations, including create and edit features, add, edit, or remove feature attachments, and edit feature geometry.
For editing workflows that use a local geodatabase, you can use geodatabase transactions to group and manage a set of edits as a single item (transaction). This makes it easier to control when those edits are committed (saved) or rolled back (discarded) as a single unit.
The enterprise geodatabase can use versioning to support multiuser editing scenarios and long transactions. If you require multiple editors to concurrently access services with the ability to undo and redo their edits, you can implement branch versions in your ArcGIS Enterprise portal. For more information, see Branch versioned data in this guide or Share branch versioned data in the ArcGIS Pro documentation.
For some feature service editing workflows, it's recommended that an analyst using ArcGIS Pro periodically review edits and verify data integrity. Although the API can perform some types of data validation, other validation tasks, such as validating topologies, cannot be performed using the API alone.
If necessary, feature editing can be separated into two parts: geometry editing and attribute editing. In certain scenarios, you may only be interested in editing the location of a feature, while at other times you might only want to edit attributes and attachments. The referenced documentation explores editing the individual parts of the feature in greater detail.
Add features
Apps often allow users to create a new feature by clicking on the map to indicate the feature's location. You can provide this capability by listening for a click event on your map view and adding a new feature in the event handler.
To add features to a feature table, create a new feature from geometry (for example, point, line, or polygon), create attributes for the new feature, and then call add feature. This adds the feature to a table stored locally on your device.
If these local edits need to be shared with the parent feature service, call ServiceGeodatabase::applyEdits() on the table's ServiceGeodatabase. See Apply edits from the service geodatabase for more information.
// Connect to the mouse clicked signal on the MapQuickView.
connect(m_mapView, &MapQuickView::mouseClicked, this, [this](QMouseEvent& mouseEvent)
{
// Obtain the map point where the user clicked with the mouse in the map view.
const Point newPoint = m_mapView->screenToLocation(mouseEvent.position().x(),
mouseEvent.position().y());
// Create the feature attributes (i.e. a key/value pair collection) and set a
// few attribute values.
QMap<QString, QVariant> featureAttributes;
featureAttributes.insert("typdamage", "Minor");
featureAttributes.insert("primcause", "Earthquake");
// Create a feature using the feature attribute and the map point.
Feature* feature = m_featureTable->createFeature(featureAttributes, newPoint, this);
// Add the feature to the feature table using the add feature async method.
m_featureTable->addFeatureAsync(feature).then(this,[]()
{
// continue processing....
});
});
Add true curves
Your app can add features with true curves to ArcGIS feature services that support true curves.
You can use ArcGISFeatureServiceInfo to find out what type of curve support a feature service has and adapt your app's behavior accordingly. For example, if the service doesn't support true curves, you can densify any curve geometries before sending them to the service. Or, if the service does support true curves, you could use the setServiceCurveGeometryMode() to fetch curve geometries, and reactively enable a curve-aware user experience in your app. ArcGIS REST API feature service reference contains more details about curve support.
For geometry information about true curves, see the Segments section in the Geometry topic.
Delete features
You can delete several features from a feature table using the delete features method that accepts a list of features, or just a single feature with a call to delete feature. All edits are stored in the feature table on the client.
If these edits need to be shared with the parent feature service, apply them to the table's service geodatabase. See Apply edits from the service geodatabase for more information.
// Delete the list of selected features in the hospital feature table
// using the delete features async method.
hospitalTable->deleteFeaturesAsync(selectedFeatures).then(this,[]()
{
// continue processing....
});
Update features
Feature updates include moving or reshaping a feature's geometry or making edits to attribute values. All edits are stored in the feature table on the client.
If these edits need to be shared with the parent feature service, apply them to the table's service geodatabase. See Apply edits from the service geodatabase for more information.
// Loop thru the list of selected features.
for (Feature* feature : selectedFeatures)
{
// Replace all of the "TraumaLevel" attributes with the number 101.
feature->attributes()->replaceAttribute("TraumaLevel", 101);
}
// Update the list of selected features in the hospital feature table
// using the update features async method.
hospitalTable->updateFeaturesAsync(selectedFeatures).then(this,[]()
{
// continue processing....
});
Update true curves
Feature services can be published with protections that disallow edits to existing true curves from curve-unaware clients. If your app supports preserving curve segments when editing, you can use the new setServiceCurveGeometryMode() and ServiceCurveGeometryMode enum to inform the service your app is a true-curve client. Use properties on ArcGISFeatureServiceInfo to find out what curve support a feature service has. ArcGIS REST API feature service reference contains more details about curve support.
Edit attachments
If the feature's table has attachments enabled, you can associate documents and photographs with individual features. You can add any file, that has a supported attachment format, to the feature's collection of attachments using AttachmentListModel::addAttachmentAsync(). For more information about enabling attachments on the feature layer, see the ArcGIS Online, ArcGIS Enterprise, and ArcGIS Pro documentation.
// Proceeded if the "damage" ArcGIS feature table has attachments.
if (damageTable->hasAttachments())
{
// Get the attachment list model from the ArcGIS feature.
AttachmentListModel* attachmentListModel = arcgisFeature->attachments();
// Call the add attachment async method using the supplied parameters to add
// an attachment to the ArcGIS feature.
attachmentListModel->addAttachmentAsync(
file /* QFile */,
".png" /* file extension type */,
"BrokenStreetSign.png" /* file name */
).then(this , [](QFuture<Attachment*>)
{
// continue processing....
});
}
If the feature's table has attachments enabled and the feature's attachment collection can be edited, you can update any attachment with new details.
// Proceeded if the "damage" ArcGIS feature table has attachments and
// the ArcGIS feature can edit attachments.
if (damageTable->hasAttachments() && arcgisFeature->canEditAttachments())
{
// Get the attachment list model from the ArcGIS feature.
AttachmentListModel* attachmentListModel = arcgisFeature->attachments();
// Call the update attachment async method using the supplied parameters to update
// the attachment on the ArcGIS feature.
attachmentListModel->updateAttachmentAsync(
attachment /* the attachment to update */,
file /* QFile */,
".png" /* file extension type */,
"DamagedTree.png" /* file name */
).then(this , [](QFuture<void>)
{
// continue processing....
});
// Alternatively, you can also use this version (via an index number):
// Call the update attachment async method using the supplied parameters to update
// the attachment on the ArcGIS feature.
attachmentListModel->updateAttachmentAsync(
1 /* the attachment via its index number in the attachment list model */,
file /* QFile */,
".png" /* file extension type */,
"DamagedTree.png" /* file name */
).then(this , [](QFuture<void>)
{
// continue processing....
});
}
Or, you can remove any attachment from the feature's attachment collection.
// Get the attachment list model from the ArcGIS feature.
AttachmentListModel* attachmentListModel = arcgisFeature->attachments();
// Call the delete attachment async method using the supplied parameters.
attachmentListModel->deleteAttachmentAsync(
attachment /* the attachment to update */
).then(this , [](QFuture<void>)
{
// continue processing....
});
// Alternatively, you can also use this version (via an index number):
// Call the delete attachment async method using the supplied parameters.
attachmentListModel->deleteAttachmentAsync(
1 /* the attachment via its index number in the attachment list model */
).then(this , [](QFuture<void>)
{
// continue processing....
});
Undo changes
There are times when making changes to data that you might want to undo all the edits in all of the local tables you are working with. The ServiceGeodatabase, a container for a collection of ServiceFeatureTables connected to a feature service, provides ServiceGeodatabase::hasLocalEdits() to determine if any of the tables have unapplied edits. If you confirm that edits exist, then you can use ServiceGeodatabase::undoLocalEdits() to asynchronously undo all of the local edits in all the tables. This logic could be applied before or after you apply or synchronize edits back to the feature service. In addition, you could utilize this logic during an editing workflow where you wish to provide a UI component to allow a user to undo their changes.
// Continue if the service geodatabase has local edits.
if (serviceGdb->hasLocalEdits())
{
// Call the undo local edits async method to undo all local edits
// in all tables of the geodatabase.
serviceGdb->undoLocalEditsAsync().then(this,[]()
{
// continue processing....
});
}
Work with geometry
There are many ways you can create or edit geometries while editing features. If you have your geometry coordinates prepared before you begin, you can use geometry constructors to create the geometry all at once. When a more iterative process is required, you may need geometry builders to build or edit your geometry. Some actions that you perform on existing geometries can result in new geometries. In this case, the geometry engine provides geometric operations to help with that workflow. Lastly, if your application users want to create or edit geometries interactively in a map view, you can use the geometry editor. To learn more about these options and to help you determine which one fits your requirements, see the Edit geometry topic.
Work with attributes and attachments
The code examples illustrated above show a typical workflow for editing attribute values and attachments when adding, deleting, and updating features. In these scenarios, the manner in which the attribute values are obtained and validated are left to your creativity during application development.
Layers that implement FeatureFormSource support a ** feature form** that is designed to ease attribute and attachment editing and validation for a feature. This form guides the users to the correct fields, constrains allowed values for a field, and supports the addition of new attachments or replacement of existing ones. We recommend that you display this feature form in your app by utilizing the toolkit component. For more information, see the Edit using toolkit topic in this guide.
Edit data from a branch version
Edits can be made to service feature tables from a branch version the same way they are made to any ServiceFeatureTable. You can also follow the process described above for adding, deleting, and updating features or their attachments.