| org.geotools.feature.SimpleFeature
All known Subclasses: org.geotools.feature.DefaultFeature, org.geotools.data.feature.adapter.GTFeatureAdapter,
| SimpleFeature | | public interface SimpleFeature extends Feature(Code) | | A simple feature is one that does not have any nested attributes, and that
has no multiplicity for each attribute. In non xml speak this means that
the attributes returned are guaranteed to be the Objects you would expect -
not Lists as is the case when Features are non-simple. This is thus a
constraining extension - it essentially allows you to make a few more
assumptions about the nature of the
Feature you are getting back.
The notion of a Simple Feature is drawn from the OGC's Simple Features for
SQL specification - where a simple feature represents a single row in a
database table. This extends beyond databases though, to flat files, for
example. A database does not necessarily only return simple features -
indeed by relying on foreign keys much more complex structures can be
created. But at the time of the creation of this class all GeoTools
datastores return Simple Features - they just were not explicitly called
that. Making explicit that they are Simple should hopefully encourage more
complex Features to be returned.
The assumptions one can make with Simple Features are as follows:
-
If
SimpleFeature.getAttribute(int) is called then it will always return an
actual object, instead of a List, as is common in the parent Feature
class. That is to say a Simple Feature will never have more than one
attribute in any of its positions, so the interface just assumes that you
want the actual object, instead of a List containing just the object.
-
If
SimpleFeature.setAttribute(int,Object) is called then a similar assumption is
made about the object being set - it need be a List, will default to
setting the attribute itself.
-
SimpleFeature.getAttribute(String) and
SimpleFeature.setAttribute(String,Object) implicitly append a [0], as that's the behavior implementors expect - to
name an attribute and get it back.
To figure out if a Feature is a SimpleFeature one may call instanceof. For
a number of Features returned from a DataStore it will save much energy if
instanceof is called on the FeatureType, to check if it is a
SimpleFeatureType . And in the future we should have FeatureCollections
that know their types.
author:
David Zwiers, Refractions
author:
Chris Holmes, TOPP
version:
$Id: SimpleFeature.java 20651 2006-07-21 07:51:54Z jgarnett $
since:
2.1 |
| Method Summary | |
| Object | getAttribute(String xPath)
This is the same as the parent declaration, except that when the
instance is not specified for the xPath, [0] will be added as there is
only ever one Attribute value for an AttributeType
Parameters:
xPath - XPath representation of attribute location. | | Object | getAttribute(int index)
Gets an attribute by the given zero-based index. | | FeatureType | getFeatureType()
Gets a reference to the schema for this feature. | | void | setAttribute(int position, Object val)
Sets an attribute by the given zero-based index. | | void | setAttributes(Object[] attributes)
Sets all attributes for this feature, passed as a complex object array.
Note that this array must conform to the internal schema for this
feature, or it will throw an exception. |
| getAttribute | | Object getAttribute(String xPath)(Code) | | This is the same as the parent declaration, except that when the
instance is not specified for the xPath, [0] will be added as there is
only ever one Attribute value for an AttributeType
Parameters:
xPath - XPath representation of attribute location. A copy of the requested attribute, null if the requested xpathis not found, or NULL_ATTRIBUTE.
See Also: Feature.getAttribute(String) |
| getAttribute | | Object getAttribute(int index)(Code) | | Gets an attribute by the given zero-based index. Unlike the parent
interface, this index is guaranteed to match the index of
AttributeType in the FeatureType.
Parameters:
index - The requested index. Must be 0 <= idx <getNumberOfAttributes(). A copy of the requested attribute, or NULL_ATTRIBUTE. |
| getFeatureType | | FeatureType getFeatureType()(Code) | | Gets a reference to the schema for this feature. This method should
always return DefaultFeatureType Object. This will be explicitly
posible in Java 1.5 (dz)
A reference to this simple feature's schema. |
| setAttribute | | void setAttribute(int position, Object val) throws IllegalAttributeException, ArrayIndexOutOfBoundsException(Code) | | Sets an attribute by the given zero-based index. Unlike the parent
interface, this index is guaranteed to match the index of
AttributeType in the FeatureType.
Parameters:
position - The requested index. Must be 0 <= idx <getNumberOfAttributes()
Parameters:
val - An object representing the attribute being set
throws:
IllegalAttributeException - if the passed in val does not validateagainst the AttributeType at that position.
throws:
ArrayIndexOutOfBoundsException - if an invalid position is given |
| setAttributes | | void setAttributes(Object[] attributes) throws IllegalAttributeException(Code) | | Sets all attributes for this feature, passed as a complex object array.
Note that this array must conform to the internal schema for this
feature, or it will throw an exception. Checking this is, of course,
left to the feature to do internally. Well behaved features should
always fully check the passed attributes against thier schema before
adding them. Since this is a SimpleFeature, the number of attributes
will be exactly the same as the number of attribute types. Attribute
values will be paired with attribute types based on array indexes.
Parameters:
attributes - All feature attributes.
throws:
IllegalAttributeException - Passed attributes do not match schema. |
|
|