|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Uses of SimpleFeatureType in org.geotools |
---|
Methods in org.geotools that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
GML.decodeSimpleFeatureType(URL schemaLocation,
Name typeName)
Decode a typeName from the provided schemaLocation. |
protected SimpleFeatureType |
GML.simpleType(Object obj)
|
Methods in org.geotools with parameters of type SimpleFeatureType | |
---|---|
void |
GML.encode(OutputStream out,
SimpleFeatureType simpleFeatureType)
Encode the provided SimpleFeatureType into an XSD file, using a target namespace When encoding the simpleFeatureType: target prefix/namespace can be provided by prefix and namespace parameters. |
protected SimpleFeature |
GML.simpleFeature(Object obj,
SimpleFeatureType schema)
Morph provided obj to a SimpleFeature if possible. |
protected XSDSchema |
GML.xsd(SimpleFeatureType simpleFeatureType)
|
Uses of SimpleFeatureType in org.geotools.arcsde.data |
---|
Methods in org.geotools.arcsde.data that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
ArcSDEDataStore.getQueryType(Query query)
|
SimpleFeatureType |
ArcSdeFeatureCollection.getSchema()
|
SimpleFeatureType |
ArcSdeFeatureSource.getSchema()
|
SimpleFeatureType |
ArcSDEDataStore.getSchema(Name name)
Delegates to ArcSDEDataStore.getSchema(String) with name.getLocalPart() |
SimpleFeatureType |
ArcSDEDataStore.getSchema(String typeName)
Obtains the schema for the given featuretype name. |
Methods in org.geotools.arcsde.data that return types with arguments of type SimpleFeatureType | |
---|---|
FeatureReader<SimpleFeatureType,SimpleFeature> |
ArcSDEDataStore.getFeatureReader(Query query,
Transaction transaction)
Returns an ArcSDEFeatureReader
Preconditions:
query ! |
FeatureReader<SimpleFeatureType,SimpleFeature> |
ArcSDEDataStore.getFeatureReader(Query query,
Transaction transaction,
SimpleFeatureType featureType)
|
FeatureReader<SimpleFeatureType,SimpleFeature> |
ArcSdeFeatureSource.getfeatureReader(SimpleFeatureType targetSchema,
Query query)
|
FeatureReader<SimpleFeatureType,SimpleFeature> |
ArcSdeFeatureCollection.reader()
|
Methods in org.geotools.arcsde.data with parameters of type SimpleFeatureType | |
---|---|
void |
ArcSDEDataStore.createSchema(SimpleFeatureType featureType)
Creates a new ArcSDE FeatureClass if featureType has at least one geometry attribute,
or an ObjectClass (aka, non spatial registered table) if this data store instance allows non
spatial tables and there's no geometry attribute in featureType . |
void |
ArcSDEDataStore.createSchema(SimpleFeatureType featureType,
Map<String,String> hints)
Creates a given FeatureType on the ArcSDE instance this DataStore is running over. |
static void |
ArcSDEAdapter.createSchema(SimpleFeatureType featureType,
Map<String,String> hints,
ISession session)
Creates the given featuretype in the underlying ArcSDE database. |
FeatureReader<SimpleFeatureType,SimpleFeature> |
ArcSDEDataStore.getFeatureReader(Query query,
Transaction transaction,
SimpleFeatureType featureType)
|
FeatureReader<SimpleFeatureType,SimpleFeature> |
ArcSdeFeatureSource.getfeatureReader(SimpleFeatureType targetSchema,
Query query)
|
String[] |
FIDReader.getPropertiesToFetch(SimpleFeatureType schema)
Returns the attribute names of the FeatureType passed to the constructor. |
String[] |
FIDReader.ShapeFidReader.getPropertiesToFetch(SimpleFeatureType schema)
Overrides to include the geometry column whether it is required by the schema or
not, since we need to get the fid from the geometry id. |
void |
ArcSDEDataStore.updateSchema(Name typeName,
SimpleFeatureType featureType)
Delegates to ArcSDEDataStore.updateSchema(String, SimpleFeatureType) with
name.getLocalPart() |
void |
ArcSDEDataStore.updateSchema(String typeName,
SimpleFeatureType featureType)
This operation is not supported at this version of the GeoTools ArcSDE plugin. |
Method parameters in org.geotools.arcsde.data with type arguments of type SimpleFeatureType | |
---|---|
List<FeatureId> |
ArcSdeFeatureStore.addFeatures(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
|
void |
ArcSdeFeatureStore.setFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
|
Constructors in org.geotools.arcsde.data with parameters of type SimpleFeatureType | |
---|---|
ArcSdeFeatureCollection(ArcSdeFeatureSource featureSource,
SimpleFeatureType queryType,
Query namedQuery)
|
Uses of SimpleFeatureType in org.geotools.arcsde.filter |
---|
Constructors in org.geotools.arcsde.filter with parameters of type SimpleFeatureType | |
---|---|
ArcSdeSimplifyingFilterVisitor(SimpleFeatureType schema)
|
|
FilterToSQLSDE(String layerQName,
String layerFidColName,
SimpleFeatureType ft,
PlainSelect definitionQuery,
ISession session)
|
|
GeometryEncoderSDE(SeLayer layer,
SimpleFeatureType featureType)
|
Uses of SimpleFeatureType in org.geotools.brewer.color |
---|
Methods in org.geotools.brewer.color with parameters of type SimpleFeatureType | |
---|---|
static Filter |
StyleGenerator.toExplicitFilter(String styleExpression,
SimpleFeatureType featureType,
String attributeTypeName)
Creates a filter with each value explicitly defined. |
static Filter[] |
StyleGenerator.toFilter(String[] styleExpression,
SimpleFeatureType[] featureType,
String[] attributeTypeName)
Converts an array of styleExpressions and attributes into Filters styleExpression[0] = "1..5"; styleExpression[1] = "5..10"; styleExpression[2] = "11, -13"; ---> filter[0] = [[1 <= attr] AND [attr < 5]] filter[1] = [[6 <= attr] AND [attr <= 10]] filter[2] = [[attr = 11] OR [attr = -13]]
|
static Filter |
StyleGenerator.toRangedFilter(String styleExpression,
SimpleFeatureType featureType,
String attributeTypeName,
boolean upperBoundClosed)
Creates a filter for a range of values. |
Uses of SimpleFeatureType in org.geotools.coverage.grid.io |
---|
Methods in org.geotools.coverage.grid.io that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
GranuleSource.getSchema()
Retrieves the schema (feature type) that will apply to granules retrieved from this GranuleSource . |
Methods in org.geotools.coverage.grid.io with parameters of type SimpleFeatureType | |
---|---|
void |
StructuredGridCoverage2DReader.createCoverage(String coverageName,
SimpleFeatureType schema)
Creates a granule store for a new coverage with the given feature type |
Uses of SimpleFeatureType in org.geotools.data |
---|
Fields in org.geotools.data declared as SimpleFeatureType | |
---|---|
protected SimpleFeatureType |
DataTestCase.lakeType
|
protected SimpleFeatureType |
DataTestCase.riverType
|
protected SimpleFeatureType |
DataTestCase.roadType
|
protected SimpleFeatureType |
DataTestCase.subRiverType
|
protected SimpleFeatureType |
DataTestCase.subRoadType
|
Fields in org.geotools.data with type parameters of type SimpleFeatureType | |
---|---|
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
DiffFeatureWriter.reader
|
Methods in org.geotools.data that return SimpleFeatureType | |
---|---|
protected SimpleFeatureType |
DefaultFeatureReader.createSchema()
|
protected SimpleFeatureType |
FIDFeatureReader.createSchema()
|
static SimpleFeatureType |
DataUtilities.createSubType(SimpleFeatureType featureType,
String[] properties)
Create a type limited to the named properties provided. |
static SimpleFeatureType |
DataUtilities.createSubType(SimpleFeatureType featureType,
String[] properties,
CoordinateReferenceSystem override)
Create a derived FeatureType |
static SimpleFeatureType |
DataUtilities.createSubType(SimpleFeatureType featureType,
String[] properties,
CoordinateReferenceSystem override,
String typeName,
URI namespace)
|
static SimpleFeatureType |
DataUtilities.createType(String typeName,
String typeSpec)
Utility method for FeatureType construction. |
static SimpleFeatureType |
DataUtilities.createType(String namespace,
String name,
String typeSpec)
Utility method for FeatureType construction. |
SimpleFeatureType |
DefaultFeatureReader.getFeatureType()
|
SimpleFeatureType |
EmptyFeatureWriter.getFeatureType()
|
SimpleFeatureType |
FilteringFeatureWriter.getFeatureType()
|
SimpleFeatureType |
DiffFeatureWriter.getFeatureType()
Supplys FeatureTypeFrom reader |
SimpleFeatureType |
ReTypeFeatureReader.getFeatureType()
|
SimpleFeatureType |
FIDFeatureReader.getFeatureType()
|
SimpleFeatureType |
CollectionFeatureReader.getFeatureType()
|
SimpleFeatureType |
CachingFeatureSource.getSchema()
Deprecated. |
SimpleFeatureType |
AbstractFileDataStore.getSchema()
Singular version, returns the FeatureType for the url being read. |
SimpleFeatureType |
DefaultFeatureResults.getSchema()
FeatureSchema for provided query. |
SimpleFeatureType |
FileDataStore.getSchema()
FeatureType for the file being read. |
SimpleFeatureType |
AbstractDataStore.getSchema(Name name)
Delegates to AbstractDataStore.getSchema(String) with name.getLocalPart() |
abstract SimpleFeatureType |
AbstractDataStore.getSchema(String typeName)
Retrive schema information for typeName |
SimpleFeatureType |
DataStore.getSchema(String typeName)
Gets the type information (schema) for the specified feature type. |
static SimpleFeatureType |
DataUtilities.simple(FeatureType featureType)
Go through FeatureType description and convert to a SimpleFeatureType. |
Methods in org.geotools.data that return types with arguments of type SimpleFeatureType | |
---|---|
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
DefaultFeatureResults.boundsReader()
Retrieve a FeatureReader |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
InProcessLockingManager.checkedWriter(FeatureWriter<SimpleFeatureType,SimpleFeature> writer,
Transaction transaction)
Provides a wrapper on the provided writer that checks locks. |
protected FeatureWriter<SimpleFeatureType,SimpleFeature> |
AbstractDataStore.createFeatureWriter(String typeName,
Transaction transaction)
Subclass should implement this to provide writing support. |
FeatureReader<SimpleFeatureType,SimpleFeature> |
AbstractFileDataStore.getFeatureReader()
Singular version, which must be implemented to represent a Reader for the url being read. |
FeatureReader<SimpleFeatureType,SimpleFeature> |
FileDataStore.getFeatureReader()
|
FeatureReader<SimpleFeatureType,SimpleFeature> |
AbstractDataStore.getFeatureReader(Query query,
Transaction transaction)
|
FeatureReader<SimpleFeatureType,SimpleFeature> |
DataStore.getFeatureReader(Query query,
Transaction transaction)
Gets a FeatureReader for features selected by the given
Query . |
protected abstract FeatureReader<SimpleFeatureType,SimpleFeature> |
AbstractDataStore.getFeatureReader(String typeName)
Subclass must implement. |
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
AbstractDataStore.getFeatureReader(String typeName,
Query query)
GR: this method is called from inside getFeatureReader(Query ,Transaction ) to allow subclasses return an optimized FeatureReader query
A subclass that supports the creation of such an optimized FeatureReader
shold override this method. |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
AbstractFileDataStore.getFeatureWriter(Filter filter,
Transaction transaction)
Singular version, calls parent with getSchema().getTypeName() |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
FileDataStore.getFeatureWriter(Filter filter,
Transaction transaction)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
AbstractDataStore.getFeatureWriter(String typeName,
Filter filter,
Transaction transaction)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
DataStore.getFeatureWriter(String typeName,
Filter filter,
Transaction transaction)
Gets a FeatureWriter to modify features in this DataStore . |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
AbstractDataStore.getFeatureWriter(String typeName,
Transaction transaction)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
DataStore.getFeatureWriter(String typeName,
Transaction transaction)
Gets a FeatureWriter to modify features in this DataStore . |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
AbstractFileDataStore.getFeatureWriter(Transaction transaction)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
FileDataStore.getFeatureWriter(Transaction transaction)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
AbstractDataStore.getFeatureWriterAppend(String typeName,
Transaction transaction)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
DataStore.getFeatureWriterAppend(String typeName,
Transaction transaction)
Gets a FeatureWriter that can add new features to the DataStore . |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
AbstractFileDataStore.getFeatureWriterAppend(Transaction transaction)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
FileDataStore.getFeatureWriterAppend(Transaction transaction)
|
FeatureReader<SimpleFeatureType,SimpleFeature> |
DefaultFeatureResults.reader()
Retrieve a FeatureReader |
static FeatureReader<SimpleFeatureType,SimpleFeature> |
DataUtilities.reader(Collection<SimpleFeature> collection)
Adapt a collection to a reader for use with FeatureStore.setFeatures( reader ). |
static FeatureReader<SimpleFeatureType,SimpleFeature> |
DataUtilities.reader(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
Adapt a collection to a reader for use with FeatureStore.setFeatures( reader ). |
static FeatureReader<SimpleFeatureType,SimpleFeature> |
DataUtilities.reader(SimpleFeature[] features)
Creates a FeatureReader |
FeatureReader<SimpleFeatureType,SimpleFeature> |
TransactionStateDiff.reader(String typeName)
Convience Method for a Transaction based FeatureReader. |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
TransactionStateDiff.writer(String typeName,
Filter filter)
Convience Method for a Transaction based FeatureWriter Constructs a DiffFeatureWriter that works against this Transaction. |
Methods in org.geotools.data with parameters of type SimpleFeatureType | |
---|---|
static List<PropertyName> |
DataUtilities.addMandatoryProperties(SimpleFeatureType type,
List<PropertyName> oldProps)
Returns a list of properties of a simple feature type, including all properties from a given list, and all mandatory (minoccurs > 0) added. |
static String[] |
DataUtilities.attributeNames(Expression expression,
SimpleFeatureType featureType)
Traverses the expression and returns any encountered property names. |
static String[] |
DataUtilities.attributeNames(Filter filter,
SimpleFeatureType featureType)
Traverses the filter and returns any encountered property names. |
static String[] |
DataUtilities.attributeNames(SimpleFeatureType featureType)
Retrieve the attributeNames defined by the featureType |
static int |
DataUtilities.compare(SimpleFeatureType typeA,
SimpleFeatureType typeB)
Compare attribute coverage between two feature types (allowing the identification of subTypes). |
static SimpleFeature |
DataUtilities.createFeature(SimpleFeatureType featureType,
String line)
Reads in SimpleFeature that has been encoded into a line of text. |
void |
AbstractDataStore.createSchema(SimpleFeatureType featureType)
Subclass should implement to provide writing support. |
static SimpleFeatureType |
DataUtilities.createSubType(SimpleFeatureType featureType,
String[] properties)
Create a type limited to the named properties provided. |
static SimpleFeatureType |
DataUtilities.createSubType(SimpleFeatureType featureType,
String[] properties,
CoordinateReferenceSystem override)
Create a derived FeatureType |
static SimpleFeatureType |
DataUtilities.createSubType(SimpleFeatureType featureType,
String[] properties,
CoordinateReferenceSystem override,
String typeName,
URI namespace)
|
static Object[] |
DataUtilities.defaultValues(SimpleFeatureType featureType)
Produce a set of default values for the provided FeatureType |
static Object[] |
DataUtilities.defaultValues(SimpleFeatureType featureType,
Object[] values)
Create default values matching the provided feature type. |
static String |
DataUtilities.encodeType(SimpleFeatureType featureType)
Encode the provided featureType as a String suitable for use with DataUtilities.createType(java.lang.String, java.lang.String) . |
static SimpleFeature |
DataUtilities.parse(SimpleFeatureType type,
String fid,
String[] text)
Uses Converters to parse the provided text into the correct values to create a feature. |
static Set<PropertyName> |
DataUtilities.propertyNames(Expression expression,
SimpleFeatureType featureType)
Traverses the expression and returns any encountered property names. |
static Set<PropertyName> |
DataUtilities.propertyNames(Filter filter,
SimpleFeatureType featureType)
Traverses the filter and returns any encountered property names. |
static Filter |
DataUtilities.resolvePropertyNames(Filter filter,
SimpleFeatureType schema)
Transform provided filter; resolving property names |
static Query |
DataUtilities.resolvePropertyNames(Query query,
SimpleFeatureType schema)
This method changes the query object so that all propertyName references are resolved to simple attribute names against the schema of the feature source. |
static SimpleFeature |
CachingFeatureSource.reType(SimpleFeatureType featureType,
SimpleFeature feature)
Deprecated. Same as DataUtilities.reType, but without the cloning that uselessly wastes CPU cycles... |
static SimpleFeature |
DataUtilities.reType(SimpleFeatureType featureType,
SimpleFeature feature)
Creates duplicate of feature adjusted to the provided featureType. |
static SimpleFeature |
DataUtilities.reType(SimpleFeatureType featureType,
SimpleFeature feature,
boolean duplicate)
Retypes the feature to match the provided featureType. |
static SimpleFeature |
DataUtilities.template(SimpleFeatureType featureType)
Constructs an empty feature to use as a Template for new content. |
static SimpleFeature |
DataUtilities.template(SimpleFeatureType featureType,
Object[] providedValues)
Create a new feature from the provided values, using appropriate default values for any nulls provided. |
static SimpleFeature |
DataUtilities.template(SimpleFeatureType featureType,
String featureID)
Use the provided featureType to create an empty feature. |
static SimpleFeature |
DataUtilities.template(SimpleFeatureType featureType,
String featureID,
Object[] providedValues)
Create a new feature from the provided values, using appropriate default values for any nulls provided. |
protected AttributeDescriptor[] |
ReTypeFeatureReader.typeAttributes(SimpleFeatureType target,
SimpleFeatureType origional)
Supplies mapping from original to target FeatureType. |
void |
AbstractDataStore.updateSchema(Name typeName,
SimpleFeatureType featureType)
Delegates to AbstractDataStore.updateSchema(String, SimpleFeatureType) with
name.getLocalPart() |
void |
AbstractFileDataStore.updateSchema(SimpleFeatureType featureType)
Singular version, calls parent with getSchema().getTypeName() |
void |
FileDataStore.updateSchema(SimpleFeatureType featureType)
|
void |
AbstractDataStore.updateSchema(String typeName,
SimpleFeatureType featureType)
|
void |
DataStore.updateSchema(String typeName,
SimpleFeatureType featureType)
Applies a new schema to the given feature type. |
Method parameters in org.geotools.data with type arguments of type SimpleFeatureType | |
---|---|
List<FeatureId> |
AbstractFeatureStore.addFeatures(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
|
Set<String> |
AbstractFeatureStore.addFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
Add Features from reader to this FeatureStore. |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
InProcessLockingManager.checkedWriter(FeatureWriter<SimpleFeatureType,SimpleFeature> writer,
Transaction transaction)
Provides a wrapper on the provided writer that checks locks. |
static DefaultFeatureCollection |
DataUtilities.collection(FeatureCollection<SimpleFeatureType,SimpleFeature> featureCollection)
Copies the provided features into a FeatureCollection. |
static SimpleFeatureCollection |
DataUtilities.collection(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
Copies the provided reader into a FeatureCollection, reader will be closed. |
protected int |
DataTestCase.count(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
Counts the number of Features returned by the specified reader. |
protected int |
DataTestCase.count(FeatureWriter<SimpleFeatureType,SimpleFeature> writer)
Counts the number of Features in the specified writer. |
static FeatureReader<SimpleFeatureType,SimpleFeature> |
DataUtilities.reader(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
Adapt a collection to a reader for use with FeatureStore.setFeatures( reader ). |
void |
AbstractFeatureStore.setFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
Replace with contents of reader. |
static SimpleFeatureCollection |
DataUtilities.simple(FeatureCollection<SimpleFeatureType,SimpleFeature> featureCollection)
A safe cast to SimpleFeatureCollection; that will introduce a wrapper if it has to. |
static SimpleFeatureReader |
DataUtilities.simple(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
|
static SimpleFeatureSource |
DataUtilities.source(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
Wraps up the provided feature collection in as a SimpleFeatureSource. |
Constructors in org.geotools.data with parameters of type SimpleFeatureType | |
---|---|
CollectionFeatureReader(Collection<SimpleFeature> featuresArg,
SimpleFeatureType typeArg)
Create a new instance. |
|
CollectionFeatureReader(SimpleFeatureCollection featuresArg,
SimpleFeatureType typeArg)
Create a new instance. |
|
DefaultFeatureReader(AttributeReader attributeReader,
SimpleFeatureType schema)
Creates a new instance of AbstractFeatureReader |
|
DefaultFIDReader(SimpleFeatureType featureType)
|
|
EmptyFeatureWriter(SimpleFeatureType featureType)
An Empty FeatureWriter of the provided featureType . |
|
FIDFeatureReader(AttributeReader attributeReader,
FIDReader fidReader,
SimpleFeatureType schema)
Creates a new instance of AbstractFeatureReader |
|
ReTypeFeatureReader(FeatureReader<SimpleFeatureType,SimpleFeature> reader,
SimpleFeatureType featureType)
Constructs a FetureReader that will ReType streaming content. |
|
ReTypeFeatureReader(FeatureReader<SimpleFeatureType,SimpleFeature> reader,
SimpleFeatureType featureType,
boolean clone)
Constructs a FetureReader that will ReType streaming content. |
Constructor parameters in org.geotools.data with type arguments of type SimpleFeatureType | |
---|---|
DiffFeatureWriter(FeatureReader<SimpleFeatureType,SimpleFeature> reader,
Diff diff)
DiffFeatureWriter construction. |
|
DiffFeatureWriter(FeatureReader<SimpleFeatureType,SimpleFeature> reader,
Diff diff,
Filter filter)
DiffFeatureWriter construction. |
|
FilteringFeatureWriter(FeatureWriter<SimpleFeatureType,SimpleFeature> writer,
Filter filter)
|
|
ReTypeFeatureReader(FeatureReader<SimpleFeatureType,SimpleFeature> reader,
SimpleFeatureType featureType)
Constructs a FetureReader that will ReType streaming content. |
|
ReTypeFeatureReader(FeatureReader<SimpleFeatureType,SimpleFeature> reader,
SimpleFeatureType featureType,
boolean clone)
Constructs a FetureReader that will ReType streaming content. |
Uses of SimpleFeatureType in org.geotools.data.collection |
---|
Fields in org.geotools.data.collection declared as SimpleFeatureType | |
---|---|
protected SimpleFeatureType |
SpatialIndexFeatureCollection.schema
|
protected SimpleFeatureType |
TreeSetFeatureCollection.schema
FeatureType of contents. |
Methods in org.geotools.data.collection that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
CollectionFeatureSource.getSchema()
|
SimpleFeatureType |
SpatialIndexFeatureCollection.getSchema()
|
SimpleFeatureType |
TreeSetFeatureCollection.getSchema()
|
SimpleFeatureType |
SpatialIndexFeatureSource.getSchema()
|
SimpleFeatureType |
CollectionDataStore.getSchema(String typeName)
|
Methods in org.geotools.data.collection that return types with arguments of type SimpleFeatureType | |
---|---|
FeatureCollection<SimpleFeatureType,SimpleFeature> |
CollectionDataStore.getCollection()
Returns the feature collection held by this data store |
DataAccess<SimpleFeatureType,SimpleFeature> |
CollectionFeatureSource.getDataStore()
|
FeatureReader<SimpleFeatureType,SimpleFeature> |
CollectionDataStore.getFeatureReader(String typeName)
Provides FeatureReader typeName . |
FeatureReader<SimpleFeatureType,SimpleFeature> |
TreeSetFeatureCollection.reader()
|
Method parameters in org.geotools.data.collection with type arguments of type SimpleFeatureType | |
---|---|
boolean |
SpatialIndexFeatureCollection.addAll(FeatureCollection<? extends SimpleFeatureType,? extends SimpleFeature> collection)
|
Constructors in org.geotools.data.collection with parameters of type SimpleFeatureType | |
---|---|
CollectionDataStore(SimpleFeatureType schema)
Builds a data store wrapper around an empty collection. |
|
ListFeatureCollection(SimpleFeatureType schema)
Create a ListFeatureCollection for the provided schema An ArrayList is used internally. |
|
ListFeatureCollection(SimpleFeatureType schema,
List<SimpleFeature> list)
Create a ListFeatureCollection around the provided list. |
|
SpatialIndexFeatureCollection(SimpleFeatureType schema)
|
|
TreeSetFeatureCollection(String id,
SimpleFeatureType memberType)
This constructor should not be used by client code. |
Constructor parameters in org.geotools.data.collection with type arguments of type SimpleFeatureType | |
---|---|
CollectionDataStore(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
Builds a data store wrapper on top of a feature collection |
|
TreeSetFeatureCollection(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
This constructor should not be used by client code. |
Uses of SimpleFeatureType in org.geotools.data.crs |
---|
Fields in org.geotools.data.crs with type parameters of type SimpleFeatureType | |
---|---|
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
ForceCoordinateSystemFeatureReader.reader
|
Methods in org.geotools.data.crs that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
ReprojectFeatureReader.getFeatureType()
Implement getFeatureType. |
SimpleFeatureType |
ForceCoordinateSystemFeatureReader.getFeatureType()
|
SimpleFeatureType |
ReprojectFeatureIterator.getFeatureType()
Implement getFeatureType. |
SimpleFeatureType |
ForceCoordinateSystemIterator.getFeatureType()
|
Methods in org.geotools.data.crs that return types with arguments of type SimpleFeatureType | |
---|---|
FeatureReader<SimpleFeatureType,SimpleFeature> |
ReprojectFeatureReader.getDelegate()
|
FeatureCollection<SimpleFeatureType,SimpleFeature> |
ForceCoordinateSystemFeatureResults.getOrigin()
Returns the feature results wrapped by this ForceCoordinateSystemFeatureResults |
FeatureCollection<SimpleFeatureType,SimpleFeature> |
ReprojectFeatureResults.getOrigin()
Returns the feature results wrapped by this reprojecting feature results |
Constructors in org.geotools.data.crs with parameters of type SimpleFeatureType | |
---|---|
ForceCoordinateSystemIterator(FeatureIterator<SimpleFeature> reader,
SimpleFeatureType type,
CoordinateReferenceSystem cs)
Builds a new ForceCoordinateSystemFeatureReader |
|
ReprojectFeatureIterator(FeatureIterator<SimpleFeature> reader,
SimpleFeatureType schema,
MathTransform transform)
|
|
ReprojectFeatureReader(FeatureReader<SimpleFeatureType,SimpleFeature> reader,
SimpleFeatureType schema,
MathTransform transform)
Direct constructor reprojecting the provided reader into the schema indicated (using the supplied math transformation). |
Uses of SimpleFeatureType in org.geotools.data.db2 |
---|
Methods in org.geotools.data.db2 with parameters of type SimpleFeatureType | |
---|---|
List<ReferencedEnvelope> |
DB2SQLDialect.getOptimizedBounds(String schema,
SimpleFeatureType featureType,
Connection cx)
Since DB2 V10. |
List<ReferencedEnvelope> |
DB2SQLDialectPrepared.getOptimizedBounds(String schema,
SimpleFeatureType featureType,
Connection cx)
|
List<ReferencedEnvelope> |
DB2SQLDialectBasic.getOptimizedBounds(String schema,
SimpleFeatureType featureType,
Connection cx)
|
void |
DB2SQLDialect.postCreateTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
void |
DB2SQLDialectPrepared.postCreateTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
void |
DB2SQLDialectBasic.postCreateTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
Uses of SimpleFeatureType in org.geotools.data.directory |
---|
Methods in org.geotools.data.directory that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
DirectoryFeatureSource.getSchema()
|
SimpleFeatureType |
DirectoryDataStore.getSchema(Name name)
|
SimpleFeatureType |
DirectoryDataStore.getSchema(String typeName)
|
Methods in org.geotools.data.directory that return types with arguments of type SimpleFeatureType | |
---|---|
DataAccess<SimpleFeatureType,SimpleFeature> |
DirectoryFeatureSource.getDataStore()
|
FeatureReader<SimpleFeatureType,SimpleFeature> |
DirectoryDataStore.getFeatureReader(Query query,
Transaction transaction)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
DirectoryDataStore.getFeatureWriter(String typeName,
Filter filter,
Transaction transaction)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
DirectoryDataStore.getFeatureWriter(String typeName,
Transaction transaction)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
DirectoryDataStore.getFeatureWriterAppend(String typeName,
Transaction transaction)
|
Methods in org.geotools.data.directory with parameters of type SimpleFeatureType | |
---|---|
void |
DirectoryDataStore.createSchema(SimpleFeatureType featureType)
|
void |
DirectoryDataStore.updateSchema(Name typeName,
SimpleFeatureType featureType)
|
void |
DirectoryDataStore.updateSchema(String typeName,
SimpleFeatureType featureType)
|
Method parameters in org.geotools.data.directory with type arguments of type SimpleFeatureType | |
---|---|
void |
DirectoryFeatureStore.setFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
|
Uses of SimpleFeatureType in org.geotools.data.gen |
---|
Fields in org.geotools.data.gen declared as SimpleFeatureType | |
---|---|
protected SimpleFeatureType |
PreGeneralizedFeatureIterator.featureTyp
|
protected SimpleFeatureType |
PreGeneralizedFeatureReader.featureTyp
|
protected SimpleFeatureType |
PreGeneralizedFeatureCollection.featureType
|
Fields in org.geotools.data.gen with type parameters of type SimpleFeatureType | |
---|---|
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
PreGeneralizedFeatureReader.backendReader
|
Methods in org.geotools.data.gen that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
PreGeneralizedSimpleFeature.getFeatureType()
|
SimpleFeatureType |
PreGeneralizedFeatureReader.getFeatureType()
|
SimpleFeatureType |
PreGeneralizedFeatureSource.getSchema()
|
SimpleFeatureType |
PreGeneralizedFeatureCollection.getSchema()
|
SimpleFeatureType |
PreGeneralizedDataStore.getSchema(Name name)
|
SimpleFeatureType |
PreGeneralizedDataStore.getSchema(String typeName)
|
SimpleFeatureType |
PreGeneralizedSimpleFeature.getType()
|
Methods in org.geotools.data.gen that return types with arguments of type SimpleFeatureType | |
---|---|
DataAccess<SimpleFeatureType,SimpleFeature> |
PreGeneralizedFeatureSource.getDataStore()
|
FeatureReader<SimpleFeatureType,SimpleFeature> |
PreGeneralizedDataStore.getFeatureReader(Query query,
Transaction transaction)
|
FeatureReader<SimpleFeatureType,SimpleFeature> |
PreGeneralizedFeatureSource.getFeatureReader(Query query,
Transaction transaction)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
PreGeneralizedDataStore.getFeatureWriter(String typeName,
Filter filter,
Transaction transaction)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
PreGeneralizedDataStore.getFeatureWriter(String typeName,
Transaction transaction)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
PreGeneralizedDataStore.getFeatureWriterAppend(String typeName,
Transaction transaction)
|
Methods in org.geotools.data.gen with parameters of type SimpleFeatureType | |
---|---|
void |
PreGeneralizedDataStore.createSchema(SimpleFeatureType featureType)
|
void |
PreGeneralizedDataStore.updateSchema(Name typeName,
SimpleFeatureType featureType)
|
void |
PreGeneralizedDataStore.updateSchema(String typeName,
SimpleFeatureType featureType)
|
Constructors in org.geotools.data.gen with parameters of type SimpleFeatureType | |
---|---|
PreGeneralizedFeatureCollection(SimpleFeatureCollection backendCollection,
SimpleFeatureType featureType,
int[] indexMapping,
String geomPropertyName,
String backendGeomPropertyName)
|
|
PreGeneralizedFeatureIterator(SimpleFeatureIterator backendIterator,
SimpleFeatureType featureTyp,
int[] indexMapping,
String geomPropertyName,
String backendGeomPropertyName)
|
|
PreGeneralizedFeatureReader(SimpleFeatureType featureTyp,
int[] indexMapping,
FeatureReader<SimpleFeatureType,SimpleFeature> backendReader,
String geomPropertyName,
String backendGeomPropertyName)
|
|
PreGeneralizedSimpleFeature(SimpleFeatureType featureTyp,
int[] indexMapping,
SimpleFeature feature,
String geomPropertyName,
String backendGeomPropertyName)
|
Constructor parameters in org.geotools.data.gen with type arguments of type SimpleFeatureType | |
---|---|
PreGeneralizedFeatureReader(SimpleFeatureType featureTyp,
int[] indexMapping,
FeatureReader<SimpleFeatureType,SimpleFeature> backendReader,
String geomPropertyName,
String backendGeomPropertyName)
|
Uses of SimpleFeatureType in org.geotools.data.h2 |
---|
Methods in org.geotools.data.h2 with parameters of type SimpleFeatureType | |
---|---|
void |
H2DialectBasic.postCreateFeatureType(SimpleFeatureType featureType,
DatabaseMetaData metadata,
String schemaName,
Connection cx)
|
void |
H2Dialect.postCreateFeatureType(SimpleFeatureType featureType,
DatabaseMetaData metadata,
String schemaName,
Connection cx)
|
void |
H2DialectPrepared.postCreateFeatureType(SimpleFeatureType featureType,
DatabaseMetaData metadata,
String schemaName,
Connection cx)
|
void |
H2DialectBasic.postCreateTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
void |
H2Dialect.postCreateTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
void |
H2DialectPrepared.postCreateTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
void |
H2DialectBasic.postDropTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
void |
H2DialectPrepared.postDropTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
void |
H2DialectBasic.preDropTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
void |
H2Dialect.preDropTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
void |
H2DialectPrepared.preDropTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
Uses of SimpleFeatureType in org.geotools.data.jdbc |
---|
Fields in org.geotools.data.jdbc declared as SimpleFeatureType | |
---|---|
protected SimpleFeatureType |
FilterToSQL.featureType
the schmema the encoder will be used to be encode sql for |
Methods in org.geotools.data.jdbc with parameters of type SimpleFeatureType | |
---|---|
void |
FilterToSQL.setFeatureType(SimpleFeatureType featureType)
Sets the featuretype the encoder is encoding sql for. |
Uses of SimpleFeatureType in org.geotools.data.memory |
---|
Fields in org.geotools.data.memory with type parameters of type SimpleFeatureType | |
---|---|
protected Map<String,SimpleFeatureType> |
MemoryDataStore.schema
Schema holds FeatureType by typeName |
Methods in org.geotools.data.memory that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
MemoryDataStore.getSchema(String typeName)
SimpleFeatureType access by typeName . |
Methods in org.geotools.data.memory that return types with arguments of type SimpleFeatureType | |
---|---|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
MemoryDataStore.createFeatureWriter(String typeName,
Transaction transaction)
Provides FeatureWriter over the entire contents of typeName . |
FeatureReader<SimpleFeatureType,SimpleFeature> |
MemoryDataStore.getFeatureReader(String typeName)
Provides FeatureReader typeName . |
Methods in org.geotools.data.memory with parameters of type SimpleFeatureType | |
---|---|
void |
MemoryDataStore.createSchema(SimpleFeatureType featureType)
Adds support for a new featureType to MemoryDataStore. |
Method parameters in org.geotools.data.memory with type arguments of type SimpleFeatureType | |
---|---|
void |
MemoryDataStore.addFeatures(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
|
void |
MemoryDataStore.addFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
Configures MemoryDataStore with FeatureReader. |
Constructors in org.geotools.data.memory with parameters of type SimpleFeatureType | |
---|---|
MemoryDataStore(SimpleFeatureType featureType)
Construct an MemoryDataStore around an empty collection of the provided SimpleFeatureType |
|
MemoryFeatureCollection(SimpleFeatureType schema)
|
Constructor parameters in org.geotools.data.memory with type arguments of type SimpleFeatureType | |
---|---|
MemoryDataStore(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
|
|
MemoryDataStore(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
|
Uses of SimpleFeatureType in org.geotools.data.mysql |
---|
Methods in org.geotools.data.mysql with parameters of type SimpleFeatureType | |
---|---|
void |
MySQLDialectPrepared.postCreateTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
void |
MySQLDialect.postCreateTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
void |
MySQLDialectBasic.postCreateTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
Uses of SimpleFeatureType in org.geotools.data.oracle |
---|
Methods in org.geotools.data.oracle with parameters of type SimpleFeatureType | |
---|---|
List<ReferencedEnvelope> |
OracleDialect.getOptimizedBounds(String schema,
SimpleFeatureType featureType,
Connection cx)
|
void |
OracleDialect.postCreateTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
void |
OracleDialect.postDropTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
Uses of SimpleFeatureType in org.geotools.data.postgis |
---|
Methods in org.geotools.data.postgis with parameters of type SimpleFeatureType | |
---|---|
List<ReferencedEnvelope> |
PostGISDialect.getOptimizedBounds(String schema,
SimpleFeatureType featureType,
Connection cx)
|
void |
PostGISDialect.postCreateTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
Creates GEOMETRY_COLUMN registrations and spatial indexes for all geometry columns |
void |
PostGISPSDialect.postCreateTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
void |
PostGISDialect.postDropTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
void |
PostGISPSDialect.postDropTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
void |
PostGISPSDialect.preDropTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
Uses of SimpleFeatureType in org.geotools.data.property |
---|
Methods in org.geotools.data.property that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
PropertyFeatureWriter.getFeatureType()
|
SimpleFeatureType |
PropertyFeatureReader.getFeatureType()
DOCUMENT ME! |
SimpleFeatureType |
PropertyFeatureSource.getSchema()
|
SimpleFeatureType |
PropertyFeatureStore.getSchema()
|
SimpleFeatureType |
PropertyDataStore.getSchema(String typeName)
|
Methods in org.geotools.data.property that return types with arguments of type SimpleFeatureType | |
---|---|
protected FeatureWriter<SimpleFeatureType,SimpleFeature> |
PropertyDataStore.createFeatureWriter(String typeName,
Transaction transaction)
|
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
PropertyDataStore.getFeatureReader(String typeName)
|
Methods in org.geotools.data.property with parameters of type SimpleFeatureType | |
---|---|
void |
PropertyDataStore.createSchema(SimpleFeatureType featureType)
|
Constructors in org.geotools.data.property with parameters of type SimpleFeatureType | |
---|---|
PropertyAttributeWriter(File file,
SimpleFeatureType featureType)
|
Uses of SimpleFeatureType in org.geotools.data.shapefile |
---|
Methods in org.geotools.data.shapefile that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
ShapefileDataStore.getSchema()
|
Methods in org.geotools.data.shapefile that return types with arguments of type SimpleFeatureType | |
---|---|
FeatureReader<SimpleFeatureType,SimpleFeature> |
ShapefileDataStore.getFeatureReader()
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
ShapefileDataStore.getFeatureWriter(Filter filter,
Transaction transaction)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
ShapefileDataStore.getFeatureWriter(Transaction transaction)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
ShapefileDataStore.getFeatureWriterAppend(Transaction transaction)
|
Methods in org.geotools.data.shapefile with parameters of type SimpleFeatureType | |
---|---|
protected static DbaseFileHeader |
ShapefileDataStore.createDbaseHeader(SimpleFeatureType featureType)
Attempt to create a DbaseFileHeader for the FeatureType. |
void |
ShapefileDataStore.createSchema(SimpleFeatureType featureType)
Set the FeatureType of this DataStore. |
void |
ShapefileDataStore.updateSchema(SimpleFeatureType featureType)
|
Uses of SimpleFeatureType in org.geotools.data.simple |
---|
Constructors in org.geotools.data.simple with parameters of type SimpleFeatureType | |
---|---|
DelegateSimpleFeatureReader(SimpleFeatureType featureType,
SimpleFeatureIterator features)
|
|
EmptySimpleFeatureReader(SimpleFeatureType featureType)
|
Uses of SimpleFeatureType in org.geotools.data.sort |
---|
Methods in org.geotools.data.sort that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
SortedFeatureReader.getFeatureType()
|
Methods in org.geotools.data.sort with parameters of type SimpleFeatureType | |
---|---|
static boolean |
SortedFeatureIterator.canSort(SimpleFeatureType schema,
SortBy[] sortBy)
Checks if the schema and the sortBy are suitable for merge/sort. |
static boolean |
SortedFeatureReader.canSort(SimpleFeatureType schema,
SortBy[] sortBy)
Checks if the schema and the sortBy are suitable for merge/sort. |
Constructors in org.geotools.data.sort with parameters of type SimpleFeatureType | |
---|---|
SortedFeatureIterator(SimpleFeatureIterator iterator,
SimpleFeatureType schema,
SortBy[] sortBy,
int maxFeatures)
Builds a new sorting feature iterator |
Uses of SimpleFeatureType in org.geotools.data.spatialite |
---|
Methods in org.geotools.data.spatialite with parameters of type SimpleFeatureType | |
---|---|
void |
SpatiaLiteDialect.postCreateFeatureType(SimpleFeatureType featureType,
DatabaseMetaData metadata,
String schemaName,
Connection cx)
|
void |
SpatiaLiteDialect.postCreateTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
Uses of SimpleFeatureType in org.geotools.data.sqlserver |
---|
Methods in org.geotools.data.sqlserver with parameters of type SimpleFeatureType | |
---|---|
void |
SQLServerDialect.postCreateTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
Uses of SimpleFeatureType in org.geotools.data.store |
---|
Fields in org.geotools.data.store declared as SimpleFeatureType | |
---|---|
protected SimpleFeatureType |
ContentState.featureType
cached feature type |
protected SimpleFeatureType |
ContentFeatureCollection.featureType
feature (possibly retyped from feautre source original) type |
protected SimpleFeatureType |
ContentFeatureSource.schema
cached feature type (only set if this instance is a view) |
protected SimpleFeatureType |
DataFeatureCollection.schema
|
Fields in org.geotools.data.store with type parameters of type SimpleFeatureType | |
---|---|
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
DiffContentFeatureWriter.reader
|
Methods in org.geotools.data.store that return SimpleFeatureType | |
---|---|
protected abstract SimpleFeatureType |
ContentFeatureSource.buildFeatureType()
Creates the feature type or schema for the feature source. |
protected SimpleFeatureType |
ContentFeatureSource.getAbsoluteSchema()
Helper method for returning the underlying schema of the feature source. |
SimpleFeatureType |
EventContentFeatureWriter.getFeatureType()
Supplys FeatureTypeFrom reader |
SimpleFeatureType |
ContentState.getFeatureType()
The cached feature type. |
SimpleFeatureType |
DiffContentFeatureWriter.getFeatureType()
Supplys FeatureTypeFrom reader |
SimpleFeatureType |
ContentFeatureCollection.getSchema()
|
SimpleFeatureType |
ContentFeatureSource.getSchema()
Returns the feature type or the schema of the feature source. |
SimpleFeatureType |
ReTypingFeatureCollection.getSchema()
|
SimpleFeatureType |
ReprojectingFeatureCollection.getSchema()
|
SimpleFeatureType |
DataFeatureCollection.getSchema()
|
SimpleFeatureType |
ContentDataStore.getSchema(Name name)
Delegates to ContentDataStore.getSchema(String) with name.getLocalPart() |
SimpleFeatureType |
ContentDataStore.getSchema(String typeName)
Returns the feature type or schema matching the specified name. |
SimpleFeatureType |
ArrayDataStore.getSchema(String typeName)
|
Methods in org.geotools.data.store that return types with arguments of type SimpleFeatureType | |
---|---|
FeatureReader<SimpleFeatureType,SimpleFeature> |
ContentDataStore.getFeatureReader(Query query,
Transaction tx)
Returns a feature reader for the specified query and transaction. |
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
ArrayDataStore.getFeatureReader(String typeName)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
ContentDataStore.getFeatureWriter(String typeName,
Filter filter,
Transaction tx)
Returns a feature writer for the specified query and transaction. |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
ContentDataStore.getFeatureWriter(String typeName,
Transaction tx)
Returns a feature writer for the specified type name and transaction. |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
ContentDataStore.getFeatureWriterAppend(String typeName,
Transaction tx)
Returns an appending feature writer for the specified type name and transaction. |
FeatureReader<SimpleFeatureType,SimpleFeature> |
ContentFeatureSource.getReader()
Returns a feature reader for all features. |
FeatureReader<SimpleFeatureType,SimpleFeature> |
ContentFeatureSource.getReader(Filter filter)
Returns a reader for features specified by a particular filter. |
FeatureReader<SimpleFeatureType,SimpleFeature> |
ContentFeatureSource.getReader(Query query)
Returns a reader for the features specified by a query. |
protected abstract FeatureReader<SimpleFeatureType,SimpleFeature> |
ContentFeatureSource.getReaderInternal(Query query)
Subclass method for returning a native reader from the datastore. |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
ContentFeatureStore.getWriter(Filter filter)
Returns a writer over features specified by a filter. |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
ContentFeatureStore.getWriter(Filter filter,
int flags)
Returns a writer over features specified by a filter. |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
ContentFeatureStore.getWriter(Query query)
Returns a writer over features specified by a query. |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
ContentFeatureStore.getWriter(Query query,
int flags)
Returns a writer over features specified by a query. |
protected abstract FeatureWriter<SimpleFeatureType,SimpleFeature> |
ContentFeatureStore.getWriterInternal(Query query,
int flags)
Subclass method for returning a native writer from the datastore. |
FeatureReader<SimpleFeatureType,SimpleFeature> |
ReTypingFeatureCollection.reader()
|
FeatureReader<SimpleFeatureType,SimpleFeature> |
ReprojectingFeatureCollection.reader()
|
FeatureReader<SimpleFeatureType,SimpleFeature> |
DataFeatureCollection.reader()
|
protected FeatureWriter<SimpleFeatureType,SimpleFeature> |
DataFeatureCollection.writer()
Subclass may provide an implementation of this method to indicate that read/write support is provided. |
Methods in org.geotools.data.store with parameters of type SimpleFeatureType | |
---|---|
void |
ContentDataStore.createSchema(SimpleFeatureType featureType)
Creates a new schema in the datastore. |
void |
ContentState.setFeatureType(SimpleFeatureType featureType)
Sets the cached feature type. |
protected AttributeDescriptor[] |
ReTypingFeatureIterator.typeAttributes(SimpleFeatureType original,
SimpleFeatureType target)
Supplies mapping from origional to target FeatureType. |
protected AttributeDescriptor[] |
ReTypingIterator.typeAttributes(SimpleFeatureType original,
SimpleFeatureType target)
Deprecated. Supplies mapping from origional to target FeatureType. |
void |
ContentDataStore.updateSchema(Name typeName,
SimpleFeatureType featureType)
Delegates to ContentDataStore.updateSchema(String, SimpleFeatureType) with
name.getLocalPart() |
void |
ContentDataStore.updateSchema(String typeName,
SimpleFeatureType featureType)
|
Method parameters in org.geotools.data.store with type arguments of type SimpleFeatureType | |
---|---|
List<FeatureId> |
ContentFeatureStore.addFeatures(FeatureCollection<SimpleFeatureType,SimpleFeature> featureCollection)
Adds a collection of features to the store. |
void |
ContentFeatureStore.setFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
Sets the feature of the source. |
Constructor parameters in org.geotools.data.store with type arguments of type SimpleFeatureType | |
---|---|
ContentFeatureCollection.WrappingFeatureIterator(FeatureReader<SimpleFeatureType,SimpleFeature> delegate)
|
|
DiffContentFeatureWriter(ContentFeatureStore store,
Diff diff,
FeatureReader<SimpleFeatureType,SimpleFeature> reader)
DiffFeatureWriter construction. |
|
EventContentFeatureWriter(ContentFeatureStore store,
FeatureWriter<SimpleFeatureType,SimpleFeature> writer)
EventContentFeatureWriter construction. |
|
ReprojectingFeatureCollection(FeatureCollection<SimpleFeatureType,SimpleFeature> delegate,
CoordinateReferenceSystem target)
|
|
ReprojectingFeatureCollection(FeatureCollection<SimpleFeatureType,SimpleFeature> delegate,
CoordinateReferenceSystem source,
CoordinateReferenceSystem target)
|
|
ReTypingFeatureCollection(FeatureCollection<SimpleFeatureType,SimpleFeature> delegate,
SimpleFeatureType featureType)
|
Uses of SimpleFeatureType in org.geotools.data.teradata |
---|
Methods in org.geotools.data.teradata with parameters of type SimpleFeatureType | |
---|---|
void |
TeradataDialect.encodePostSelect(SimpleFeatureType featureType,
StringBuffer sql)
|
List<ReferencedEnvelope> |
TeradataDialect.getOptimizedBounds(String schema,
SimpleFeatureType featureType,
Connection cx)
|
void |
TeradataDialect.onDelete(PreparedStatement delete,
Connection cx,
SimpleFeatureType featureType)
|
void |
TeradataDialect.onInsert(PreparedStatement insert,
Connection cx,
SimpleFeatureType featureType)
|
void |
TeradataDialect.onSelect(PreparedStatement select,
Connection cx,
SimpleFeatureType featureType)
|
void |
TeradataDialect.onUpdate(PreparedStatement update,
Connection cx,
SimpleFeatureType featureType)
|
void |
TeradataDialect.postCreateTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
Uses of SimpleFeatureType in org.geotools.data.transform |
---|
Methods in org.geotools.data.transform that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
TransformFeatureSource.getSchema()
|
SimpleFeatureType |
SingleFeatureSourceDataStore.getSchema(Name name)
|
SimpleFeatureType |
SingleFeatureSourceDataStore.getSchema(String typeName)
|
Methods in org.geotools.data.transform that return types with arguments of type SimpleFeatureType | |
---|---|
DataAccess<SimpleFeatureType,SimpleFeature> |
TransformFeatureSource.getDataStore()
|
FeatureReader<SimpleFeatureType,SimpleFeature> |
SingleFeatureSourceDataStore.getFeatureReader(Query query,
Transaction transaction)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
SingleFeatureSourceDataStore.getFeatureWriter(String typeName,
Filter filter,
Transaction transaction)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
SingleFeatureSourceDataStore.getFeatureWriter(String typeName,
Transaction transaction)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
SingleFeatureSourceDataStore.getFeatureWriterAppend(String typeName,
Transaction transaction)
|
Methods in org.geotools.data.transform with parameters of type SimpleFeatureType | |
---|---|
void |
SingleFeatureSourceDataStore.createSchema(SimpleFeatureType featureType)
|
AttributeDescriptor |
Definition.getAttributeDescriptor(SimpleFeatureType originalSchema)
Computes the output attribute descriptor for this Definition given only the original feature type. |
void |
SingleFeatureSourceDataStore.updateSchema(Name typeName,
SimpleFeatureType featureType)
|
void |
SingleFeatureSourceDataStore.updateSchema(String typeName,
SimpleFeatureType featureType)
|
Method parameters in org.geotools.data.transform with type arguments of type SimpleFeatureType | |
---|---|
List<FeatureId> |
TransformFeatureStore.addFeatures(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
|
void |
TransformFeatureStore.setFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
|
Uses of SimpleFeatureType in org.geotools.data.view |
---|
Methods in org.geotools.data.view that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
DefaultView.getSchema()
Implement getSchema. |
Uses of SimpleFeatureType in org.geotools.data.wfs.feature |
---|
Methods in org.geotools.data.wfs.feature with parameters of type SimpleFeatureType | |
---|---|
static SimpleFeature |
LenientBuilder.build(SimpleFeatureType ft,
Object[] atts,
String fid)
|
SimpleFeature |
LenientFeatureFactory.createSimpleFeature(List<Attribute> properties,
SimpleFeatureType type,
String id)
|
Constructors in org.geotools.data.wfs.feature with parameters of type SimpleFeatureType | |
---|---|
LenientBuilder(SimpleFeatureType schmea)
|
|
LenientFeature(List<Attribute> attributes,
SimpleFeatureType schema,
String featureID)
Creates a new instance of flat feature, which must take a flat feature type schema and all attributes as arguments. |
Uses of SimpleFeatureType in org.geotools.data.wfs.protocol.wfs |
---|
Methods in org.geotools.data.wfs.protocol.wfs that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
WFSProtocol.issueDescribeFeatureTypeGET(String prefixedTypeName,
CoordinateReferenceSystem crs)
|
Uses of SimpleFeatureType in org.geotools.data.wfs.v1_0_0 |
---|
Methods in org.geotools.data.wfs.v1_0_0 that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
WFSFeatureSource.getSchema()
|
SimpleFeatureType |
WFSFeatureSource.WFSFeatureResults.getSchema()
|
SimpleFeatureType |
WFS_1_0_0_DataStore.getSchema(Name name)
|
SimpleFeatureType |
WFS_1_0_0_DataStore.getSchema(String typeName)
DOCUMENT ME! |
protected SimpleFeatureType |
WFS_1_0_0_DataStore.getSchemaGet(String typeName)
|
protected SimpleFeatureType |
WFS_1_0_0_DataStore.getSchemaPost(String typeName)
|
Methods in org.geotools.data.wfs.v1_0_0 with parameters of type SimpleFeatureType | |
---|---|
static WFSFeatureReader |
WFSFeatureReader.getFeatureReader(InputStream is,
int capacity,
int timeout,
WFSTransactionState transaction,
SimpleFeatureType ft)
|
static FeatureReader<SimpleFeatureType,SimpleFeature> |
WFSFeatureReader.getFeatureReader(URI document,
int capacity,
int timeout,
WFSTransactionState transaction,
SimpleFeatureType ft)
|
void |
WFS_1_0_0_DataStore.updateSchema(Name typeName,
SimpleFeatureType featureType)
|
Method parameters in org.geotools.data.wfs.v1_0_0 with type arguments of type SimpleFeatureType | |
---|---|
List<FeatureId> |
WFSFeatureStore.addFeatures(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
|
List<FeatureId> |
WFSFeatureStore.addFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
|
void |
WFSFeatureStore.setFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
|
Uses of SimpleFeatureType in org.geotools.data.wfs.v1_0_0.gml |
---|
Methods in org.geotools.data.wfs.v1_0_0.gml that return SimpleFeatureType | |
---|---|
static SimpleFeatureType |
WFSFeatureTypeTransformer.transform(SimpleFeatureType schema,
CoordinateReferenceSystem crs)
|
Methods in org.geotools.data.wfs.v1_0_0.gml with parameters of type SimpleFeatureType | |
---|---|
static SimpleFeatureType |
WFSFeatureTypeTransformer.transform(SimpleFeatureType schema,
CoordinateReferenceSystem crs)
|
Uses of SimpleFeatureType in org.geotools.data.wfs.v1_1_0 |
---|
Methods in org.geotools.data.wfs.v1_1_0 that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
WFSFeatureSource.getSchema()
|
SimpleFeatureType |
WFS_1_1_0_DataStore.getSchema(Name name)
|
SimpleFeatureType |
WFS_1_1_0_DataStore.getSchema(String prefixedTypeName)
Makes a DescribeFeatureType request for typeName feature type, parses the
server response into a SimpleFeatureType and returns it. |
SimpleFeatureType |
WFS_1_1_0_Protocol.issueDescribeFeatureTypeGET(String prefixedTypeName,
CoordinateReferenceSystem crs)
|
Methods in org.geotools.data.wfs.v1_1_0 that return types with arguments of type SimpleFeatureType | |
---|---|
FeatureReader<SimpleFeatureType,SimpleFeature> |
WFS_1_1_0_DataStore.getFeatureReader(Query query,
Transaction transaction)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
WFS_1_1_0_DataStore.getFeatureWriter(String typeName,
Filter filter,
Transaction transaction)
Not supported. |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
WFS_1_1_0_DataStore.getFeatureWriter(String typeName,
Transaction transaction)
Not supported. |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
WFS_1_1_0_DataStore.getFeatureWriterAppend(String typeName,
Transaction transaction)
Not supported. |
Methods in org.geotools.data.wfs.v1_1_0 with parameters of type SimpleFeatureType | |
---|---|
void |
WFS_1_1_0_DataStore.createSchema(SimpleFeatureType featureType)
|
void |
WFS_1_1_0_DataStore.updateSchema(Name typeName,
SimpleFeatureType featureType)
|
void |
WFS_1_1_0_DataStore.updateSchema(String typeName,
SimpleFeatureType featureType)
|
Uses of SimpleFeatureType in org.geotools.data.wfs.v1_1_0.parsers |
---|
Methods in org.geotools.data.wfs.v1_1_0.parsers that return SimpleFeatureType | |
---|---|
static SimpleFeatureType |
EmfAppSchemaParser.parse(Configuration wfsConfiguration,
QName featureName,
URL schemaLocation,
CoordinateReferenceSystem crs,
Map<String,String> mappedURIs,
Map<QName,Class<?>> mappedBindings,
boolean ignoreMissingElementDeclaration)
Parses the FeatureType pointed out by the schemaLocation URL and returns it. |
static SimpleFeatureType |
EmfAppSchemaParser.parseSimpleFeatureType(Configuration wfsConfiguration,
QName featureName,
URL schemaLocation,
CoordinateReferenceSystem crs,
Map<String,String> mappedURIs,
Map<QName,Class<?>> mappedBindings,
boolean ignoreMissingElementDeclaration)
Parses the FeatureType pointed out by the schemaLocation URL and returns a subset
consisting only of the simple attributes found on the original schema. |
static SimpleFeatureType |
EmfAppSchemaParser.parseSimpleFeatureType(QName featureName,
URL schemaLocation,
CoordinateReferenceSystem crs,
Configuration wfsConfiguration,
Map<String,String> mappedURIs,
Map<QName,Class<?>> mappedBindings,
boolean ignoreMissingElementDeclaration)
|
static SimpleFeatureType |
EmfAppSchemaParser.toSimpleFeatureType(FeatureType realType)
Go through FeatureType description and convert to a SimpleFeatureType. |
Constructors in org.geotools.data.wfs.v1_1_0.parsers with parameters of type SimpleFeatureType | |
---|---|
XmlSimpleFeatureParser(InputStream getFeatureResponseStream,
SimpleFeatureType targetType,
QName featureDescriptorName,
String axisOrder,
Map<String,String> mappedURIs)
|
Uses of SimpleFeatureType in org.geotools.feature |
---|
Fields in org.geotools.feature declared as SimpleFeatureType | |
---|---|
static SimpleFeatureType |
FeatureTypes.ABSTRACT_FEATURE_TYPE
abstract base type for all feature types |
static SimpleFeatureType |
FeatureTypes.EMPTY
An feature type with no attributes |
protected SimpleFeatureType |
DefaultFeatureCollection.schema
|
Methods in org.geotools.feature that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
DecoratingFeature.getFeatureType()
|
SimpleFeatureType |
DefaultFeatureCollection.getSchema()
|
SimpleFeatureType |
DecoratingFeature.getType()
|
static SimpleFeatureType |
FeatureTypes.newFeatureType(AttributeDescriptor[] types,
String name)
Create a new FeatureType with the given AttributeTypes. |
static SimpleFeatureType |
FeatureTypes.newFeatureType(AttributeDescriptor[] types,
String name,
URI ns)
Create a new FeatureType with the given AttributeTypes. |
static SimpleFeatureType |
FeatureTypes.newFeatureType(AttributeDescriptor[] types,
String name,
URI ns,
boolean isAbstract)
Create a new FeatureType with the given AttributeTypes. |
static SimpleFeatureType |
FeatureTypes.newFeatureType(AttributeDescriptor[] types,
String name,
URI ns,
boolean isAbstract,
SimpleFeatureType[] superTypes)
The most specific way to create a new FeatureType. |
static SimpleFeatureType |
FeatureTypes.newFeatureType(AttributeDescriptor[] types,
String name,
URI ns,
boolean isAbstract,
SimpleFeatureType[] superTypes,
AttributeDescriptor defaultGeometry)
The most specific way to create a new FeatureType. |
static SimpleFeatureType |
FeatureTypes.newFeatureType(AttributeDescriptor[] types,
String name,
URI ns,
boolean isAbstract,
SimpleFeatureType[] superTypes,
GeometryDescriptor defaultGeometry)
The most specific way to create a new FeatureType. |
static SimpleFeatureType |
FeatureTypes.transform(SimpleFeatureType schema,
CoordinateReferenceSystem crs)
Forces the specified CRS on all geometry attributes |
static SimpleFeatureType |
FeatureTypes.transform(SimpleFeatureType schema,
CoordinateReferenceSystem crs,
boolean forceOnlyMissing)
Forces the specified CRS on geometry attributes (all or some, depends on the parameters). |
Methods in org.geotools.feature that return types with arguments of type SimpleFeatureType | |
---|---|
FeatureReader<SimpleFeatureType,SimpleFeature> |
DefaultFeatureCollection.reader()
|
Methods in org.geotools.feature with parameters of type SimpleFeatureType | |
---|---|
static Set |
FeatureTypes.ancestors(SimpleFeatureType featureType)
|
static AttributeDescriptor |
Schema.attribute(SimpleFeatureType type,
int index)
Deprecated. use getAttribute( type, index ) |
static AttributeDescriptor |
Schema.attribute(SimpleFeatureType type,
String name)
Deprecated. use getAttribute( type, name ) |
static int |
Schema.attributeCount(SimpleFeatureType featureType)
Deprecated. Walk the provided FeatureType and produce a count of distinct attribtues. |
static List |
Schema.attributes(SimpleFeatureType featureType)
Deprecated. use getAttributes( featureType ) |
static List |
Schema.attributes(SimpleFeatureType featureType,
List list)
Deprecated. use getAttributes( featureType, list ) |
protected SimpleFeatureCollection |
DefaultFeatureCollections.createCollection(String id,
SimpleFeatureType ft)
|
SimpleFeature |
AbstractFeatureFactoryImpl.createSimpleFeature(Object[] array,
SimpleFeatureType type,
String id)
|
static boolean |
FeatureTypes.equals(SimpleFeatureType typeA,
SimpleFeatureType typeB)
Exact equality based on typeNames, namespace, attributes and ancestors |
static boolean |
FeatureTypes.equalsAncestors(SimpleFeatureType typeA,
SimpleFeatureType typeB)
This method depends on the correct implementation of FeatureType equals We may need to write an implementation that can detect cycles, |
static boolean |
FeatureTypes.equalsExact(SimpleFeatureType typeA,
SimpleFeatureType typeB)
Exact equality based on typeNames, namespace, attributes and ancestors, including the user maps contents |
static boolean |
FeatureTypes.equalsId(SimpleFeatureType typeA,
SimpleFeatureType typeB)
Quick check of namespace and typename |
static int |
Schema.find(SimpleFeatureType type,
String name)
Deprecated. please use getIndexOf( type, name ) |
AttributeDescriptor |
Schema.getAttribute(SimpleFeatureType type,
int index)
Deprecated. Look up based on name in the provided position. |
AttributeDescriptor |
Schema.getAttribute(SimpleFeatureType type,
String name)
Deprecated. |
int |
Schema.getAttributeCount(SimpleFeatureType featureType)
Deprecated. Walk the provided FeatureType and produce a count of distinct attribtues. |
List |
Schema.getAttributes(SimpleFeatureType featureType)
Deprecated. |
List |
Schema.getAttributes(SimpleFeatureType featureType,
List list)
Deprecated. This order is to be respected, based on Ancestors and so on. |
int |
Schema.getIndexOf(SimpleFeatureType type,
String name)
Deprecated. Lookup can only really be by name. |
List |
Schema.getNames(SimpleFeatureType featureType)
Deprecated. Does a quick walk to detect only a list of attribute names. |
List |
Schema.getNames(SimpleFeatureType featureType,
List names)
Deprecated. This order is to be respected, based on Ancestors and so on. |
Filter |
Schema.getRestrictions(SimpleFeatureType featureType,
String name)
Deprecated. Query featureType information the complete restrictions for the indicated name. |
AttributeDescriptor |
Schema.getXPath(SimpleFeatureType type,
String xpath)
Deprecated. Look up based on name in the provided position. |
static List |
Schema.names(SimpleFeatureType featureType)
Deprecated. use getNames( featureType ) |
static List |
Schema.names(SimpleFeatureType featureType,
List names)
Deprecated. use getNames( featureType, List ) |
static SimpleFeatureType |
FeatureTypes.newFeatureType(AttributeDescriptor[] types,
String name,
URI ns,
boolean isAbstract,
SimpleFeatureType[] superTypes)
The most specific way to create a new FeatureType. |
static SimpleFeatureType |
FeatureTypes.newFeatureType(AttributeDescriptor[] types,
String name,
URI ns,
boolean isAbstract,
SimpleFeatureType[] superTypes,
AttributeDescriptor defaultGeometry)
The most specific way to create a new FeatureType. |
static SimpleFeatureType |
FeatureTypes.newFeatureType(AttributeDescriptor[] types,
String name,
URI ns,
boolean isAbstract,
SimpleFeatureType[] superTypes,
GeometryDescriptor defaultGeometry)
The most specific way to create a new FeatureType. |
static Filter |
Schema.restriction(SimpleFeatureType featureType,
String name)
Deprecated. please use getRestriction( featureType, name ) |
static SimpleFeature |
FeatureTypes.transform(SimpleFeature feature,
SimpleFeatureType schema,
MathTransform transform)
Applies transform to all geometry attribute. |
static SimpleFeatureType |
FeatureTypes.transform(SimpleFeatureType schema,
CoordinateReferenceSystem crs)
Forces the specified CRS on all geometry attributes |
static SimpleFeatureType |
FeatureTypes.transform(SimpleFeatureType schema,
CoordinateReferenceSystem crs,
boolean forceOnlyMissing)
Forces the specified CRS on geometry attributes (all or some, depends on the parameters). |
static AttributeDescriptor |
Schema.xpath(SimpleFeatureType type,
String xpath)
Deprecated. use getXPath( type, xpath ); |
Constructors in org.geotools.feature with parameters of type SimpleFeatureType | |
---|---|
DefaultFeatureCollection(String id,
SimpleFeatureType memberType)
Used to create a feature collection to stage content in memory. |
Constructor parameters in org.geotools.feature with type arguments of type SimpleFeatureType | |
---|---|
DefaultFeatureCollection(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
Used to stage content in memory. |
Uses of SimpleFeatureType in org.geotools.feature.collection |
---|
Fields in org.geotools.feature.collection declared as SimpleFeatureType | |
---|---|
protected SimpleFeatureType |
AdaptorFeatureCollection.schema
|
protected SimpleFeatureType |
AbstractFeatureCollection.schema
|
Methods in org.geotools.feature.collection that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
AdaptorFeatureCollection.getSchema()
|
SimpleFeatureType |
DecoratingSimpleFeatureCollection.getSchema()
|
SimpleFeatureType |
AbstractFeatureCollection.getSchema()
|
Methods in org.geotools.feature.collection that return types with arguments of type SimpleFeatureType | |
---|---|
FeatureReader<SimpleFeatureType,SimpleFeature> |
FilteringSimpleFeatureCollection.reader()
|
Constructors in org.geotools.feature.collection with parameters of type SimpleFeatureType | |
---|---|
AbstractFeatureCollection(SimpleFeatureType memberType)
|
|
AdaptorFeatureCollection(String id,
SimpleFeatureType memberType)
|
|
BaseSimpleFeatureCollection(SimpleFeatureType schema)
|
Constructor parameters in org.geotools.feature.collection with type arguments of type SimpleFeatureType | |
---|---|
DecoratingSimpleFeatureCollection(FeatureCollection<SimpleFeatureType,SimpleFeature> delegate)
|
|
DelegateSimpleFeatureIterator(FeatureCollection<SimpleFeatureType,SimpleFeature> collection,
Iterator<SimpleFeature> iterator)
Wrap the provided iterator up as a FeatureIterator. |
|
FilteringSimpleFeatureCollection(FeatureCollection<SimpleFeatureType,SimpleFeature> delegate,
Filter filter)
|
|
MaxSimpleFeatureCollection(FeatureCollection<SimpleFeatureType,SimpleFeature> delegate,
long max)
|
Uses of SimpleFeatureType in org.geotools.feature.simple |
---|
Classes in org.geotools.feature.simple that implement SimpleFeatureType | |
---|---|
class |
SimpleFeatureTypeImpl
Implementation fo SimpleFeatureType, subtypes must be atomic and are stored in a list. |
Fields in org.geotools.feature.simple declared as SimpleFeatureType | |
---|---|
protected SimpleFeatureType |
SimpleFeatureImpl.featureType
|
protected SimpleFeatureType |
SimpleFeatureTypeBuilder.superType
the parent type. |
Methods in org.geotools.feature.simple that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
SimpleFeatureTypeBuilder.buildFeatureType()
Builds a feature type from compiled state. |
static SimpleFeatureType |
SimpleFeatureTypeBuilder.copy(SimpleFeatureType original)
Copys a feature type. |
SimpleFeatureType |
SimpleFeatureBuilder.getFeatureType()
Returns the simple feature type used by this builder as a feature template |
SimpleFeatureType |
SimpleFeatureImpl.getFeatureType()
|
SimpleFeatureType |
SimpleFeatureTypeBuilder.getSuperType()
The super type of the built type. |
SimpleFeatureType |
SimpleFeatureImpl.getType()
|
static SimpleFeatureType |
SimpleFeatureTypeBuilder.retype(SimpleFeatureType original,
CoordinateReferenceSystem crs)
Create a SimpleFeatureType with the same content; just updating the geometry attribute to match the provided coordinate reference system. |
static SimpleFeatureType |
SimpleFeatureTypeBuilder.retype(SimpleFeatureType original,
List<String> types)
|
static SimpleFeatureType |
SimpleFeatureTypeBuilder.retype(SimpleFeatureType original,
String[] types)
Create a SimpleFeatureType containing just the descriptors indicated. |
Methods in org.geotools.feature.simple with parameters of type SimpleFeatureType | |
---|---|
static SimpleFeature |
SimpleFeatureBuilder.build(SimpleFeatureType type,
List<Object> values,
String id)
* Static method to build a new feature. |
static SimpleFeature |
SimpleFeatureBuilder.build(SimpleFeatureType type,
Object[] values,
String id)
Static method to build a new feature. |
static SimpleFeatureType |
SimpleFeatureTypeBuilder.copy(SimpleFeatureType original)
Copys a feature type. |
void |
SimpleFeatureTypeBuilder.init(SimpleFeatureType type)
Initializes the builder with state from a pre-existing feature type. |
static SimpleFeature |
SimpleFeatureBuilder.retype(SimpleFeature feature,
SimpleFeatureType featureType)
Copies an existing feature, retyping it in the process. |
static SimpleFeatureType |
SimpleFeatureTypeBuilder.retype(SimpleFeatureType original,
CoordinateReferenceSystem crs)
Create a SimpleFeatureType with the same content; just updating the geometry attribute to match the provided coordinate reference system. |
static SimpleFeatureType |
SimpleFeatureTypeBuilder.retype(SimpleFeatureType original,
List<String> types)
|
static SimpleFeatureType |
SimpleFeatureTypeBuilder.retype(SimpleFeatureType original,
String[] types)
Create a SimpleFeatureType containing just the descriptors indicated. |
void |
SimpleFeatureTypeBuilder.setSuperType(SimpleFeatureType superType)
Sets the super type of the built type. |
static SimpleFeature |
SimpleFeatureBuilder.template(SimpleFeatureType featureType,
String featureId)
Builds a new feature whose attribute values are the default ones |
Constructors in org.geotools.feature.simple with parameters of type SimpleFeatureType | |
---|---|
SimpleFeatureBuilder(SimpleFeatureType featureType)
|
|
SimpleFeatureBuilder(SimpleFeatureType featureType,
FeatureFactory factory)
|
|
SimpleFeatureImpl(List<Object> values,
SimpleFeatureType featureType,
FeatureId id)
Builds a new feature based on the provided values and feature type |
|
SimpleFeatureImpl(Object[] values,
SimpleFeatureType featureType,
FeatureId id,
boolean validating)
Fast construction of a new feature. |
|
SimpleFeatureImpl(Object[] values,
SimpleFeatureType featureType,
FeatureId id,
boolean validating,
Map<String,Integer> index)
Fast construction of a new feature. |
Uses of SimpleFeatureType in org.geotools.feature.type |
---|
Fields in org.geotools.feature.type declared as SimpleFeatureType | |
---|---|
static SimpleFeatureType |
AnnotationFeatureType.ANNOTATION
The FeatureType reference that should be used for Anotations. |
static SimpleFeatureType |
BasicFeatureTypes.FEATURE
The base type for all features |
static SimpleFeatureType |
BasicFeatureTypes.LINE
The FeatureType reference that should be used for Lines |
static SimpleFeatureType |
BasicFeatureTypes.POINT
The FeatureType reference that should be used for Points |
static SimpleFeatureType |
BasicFeatureTypes.POLYGON
The FeatureType reference that should be used for Polygons |
Methods in org.geotools.feature.type that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
FeatureTypeFactoryImpl.createSimpleFeatureType(Name name,
List<AttributeDescriptor> schema,
GeometryDescriptor defaultGeometry,
boolean isAbstract,
List<Filter> restrictions,
AttributeType superType,
InternationalString description)
|
Methods in org.geotools.feature.type with parameters of type SimpleFeatureType | |
---|---|
static void |
Types.assertOrderAssignable(SimpleFeatureType expected,
SimpleFeatureType actual)
SimpleFeatureType comparison indicating that data from one FeatureType can be exchanged with another - specifically ensuring that the order / value is a reasonable match with the expected number of attributes on each side and the values correctly assignable. |
Uses of SimpleFeatureType in org.geotools.feature.visitor |
---|
Constructors in org.geotools.feature.visitor with parameters of type SimpleFeatureType | |
---|---|
AverageVisitor(int attributeTypeIndex,
SimpleFeatureType type)
Constructor class for the AverageVisitor using AttributeDescriptor ID |
|
AverageVisitor(String attrName,
SimpleFeatureType type)
Constructor class for the AverageVisitor using AttributeDescriptor Name |
|
MaxVisitor(int attributeTypeIndex,
SimpleFeatureType type)
|
|
MaxVisitor(String attrName,
SimpleFeatureType type)
|
|
MedianVisitor(int attributeTypeIndex,
SimpleFeatureType type)
|
|
MedianVisitor(String attrName,
SimpleFeatureType type)
|
|
MinVisitor(int attributeTypeIndex,
SimpleFeatureType type)
|
|
MinVisitor(String attrName,
SimpleFeatureType type)
|
|
SumVisitor(int attributeTypeIndex,
SimpleFeatureType type)
|
|
SumVisitor(String attrName,
SimpleFeatureType type)
|
|
UniqueVisitor(int attributeTypeIndex,
SimpleFeatureType type)
|
|
UniqueVisitor(String attrName,
SimpleFeatureType type)
|
Uses of SimpleFeatureType in org.geotools.filter |
---|
Fields in org.geotools.filter declared as SimpleFeatureType | |
---|---|
protected SimpleFeatureType |
SQLEncoder.featureType
Deprecated. the schmema the encoder will be used to be encode sql for |
protected SimpleFeatureType |
FilterAttributeExtractor.featureType
feature type to evaluate against |
protected SimpleFeatureType |
AttributeExpressionImpl.schema
Used to validate attribute references to ensure they match the provided schema |
Methods in org.geotools.filter with parameters of type SimpleFeatureType | |
---|---|
static String[] |
Filters.attributeNames(Filter filter,
SimpleFeatureType featureType)
Traverses the filter and returns any encountered property names. |
AttributeExpression |
FilterFactoryImpl.createAttributeExpression(SimpleFeatureType schema)
Creates a Attribute Expression with an initial schema. |
AttributeExpression |
FilterFactory.createAttributeExpression(SimpleFeatureType schema)
Deprecated. use FilterFactory.createAttributeExpression(String) instead. |
AttributeExpression |
FilterFactoryImpl.createAttributeExpression(SimpleFeatureType schema,
String path)
Creates a Attribute Expression given a schema and attribute path. |
AttributeExpression |
FilterFactory.createAttributeExpression(SimpleFeatureType schema,
String xpath)
Deprecated. use createAttributeExpression( xpath ), will be removed for GeoTools 2.3 |
static Set<PropertyName> |
Filters.propertyNames(Expression expression,
SimpleFeatureType featureType)
Traverses the expression and returns any encountered property names. |
static Set<PropertyName> |
Filters.propertyNames(Filter filter,
SimpleFeatureType featureType)
Traverses the filter and returns any encountered property names. |
void |
SQLEncoder.setFeatureType(SimpleFeatureType featureType)
Deprecated. Sets the featuretype the encoder is encoding sql for. |
Constructors in org.geotools.filter with parameters of type SimpleFeatureType | |
---|---|
AttributeExpressionImpl(SimpleFeatureType schema)
Constructor with the schema for this attribute. |
|
AttributeExpressionImpl(SimpleFeatureType schema,
String attPath)
Constructor with schema and path to the attribute. |
|
ExpressionSAXParser(SimpleFeatureType schema)
Constructor with a schema to read the attribute againset. |
|
ExpressionSAXParser(SimpleFeatureType schema,
FilterFactory factory)
Constructor injection |
|
FilterAttributeExtractor(SimpleFeatureType featureType)
Use the provided feature type as a sanity check when extracting property names. |
|
FilterFilter(FilterHandler parent,
SimpleFeatureType schema)
Constructor with parent, which must implement GMLHandlerJTS. |
|
FilterFilter(FilterHandler parent,
SimpleFeatureType schema,
boolean convertLiteralToNumber)
Constructor with parent, which must implement GMLHandlerJTS. |
Uses of SimpleFeatureType in org.geotools.filter.visitor |
---|
Constructors in org.geotools.filter.visitor with parameters of type SimpleFeatureType | |
---|---|
PostPreProcessFilterSplittingVisitor(FilterCapabilities fcs,
SimpleFeatureType parent,
ClientTransactionAccessor transactionAccessor)
Deprecated. Create a new instance. |
|
PropertyNameResolvingVisitor(SimpleFeatureType featureType)
|
Uses of SimpleFeatureType in org.geotools.gce.imagemosaic |
---|
Methods in org.geotools.gce.imagemosaic that return SimpleFeatureType | |
---|---|
static SimpleFeatureType |
CatalogManager.createSchema(CatalogBuilderConfiguration runConfiguration,
String name,
CoordinateReferenceSystem actualCRS)
Create a SimpleFeatureType from the specified configuration. |
Methods in org.geotools.gce.imagemosaic with parameters of type SimpleFeatureType | |
---|---|
void |
ImageMosaicReader.createCoverage(String coverageName,
SimpleFeatureType indexSchema)
|
void |
RasterManager.createStore(SimpleFeatureType indexSchema)
Create a store for the coverage related to this RasterManager using the
provided schema |
Uses of SimpleFeatureType in org.geotools.gce.imagemosaic.catalog |
---|
Methods in org.geotools.gce.imagemosaic.catalog that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
GranuleCatalogSource.getSchema()
|
abstract SimpleFeatureType |
GranuleCatalog.getType(String typeName)
|
Methods in org.geotools.gce.imagemosaic.catalog with parameters of type SimpleFeatureType | |
---|---|
abstract void |
GranuleCatalog.createType(SimpleFeatureType featureType)
|
Uses of SimpleFeatureType in org.geotools.gce.imagemosaic.catalog.oracle |
---|
Methods in org.geotools.gce.imagemosaic.catalog.oracle that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
OracleFeatureTypeMapper.getMappedFeatureType()
|
SimpleFeatureType |
FeatureTypeMapper.getMappedFeatureType()
Get the remapped FeatureType |
SimpleFeatureType |
DataStoreWrapper.getSchema(Name name)
|
SimpleFeatureType |
DataStoreWrapper.getSchema(String typeName)
|
SimpleFeatureType |
OracleFeatureTypeMapper.getWrappedFeatureType()
|
SimpleFeatureType |
FeatureTypeMapper.getWrappedFeatureType()
Get the original FeatureType |
Methods in org.geotools.gce.imagemosaic.catalog.oracle that return types with arguments of type SimpleFeatureType | |
---|---|
DataAccess<SimpleFeatureType,SimpleFeature> |
OracleTransformFeatureStore.getDataStore()
|
FeatureReader<SimpleFeatureType,SimpleFeature> |
DataStoreWrapper.getFeatureReader(Query query,
Transaction transaction)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
DataStoreWrapper.getFeatureWriter(String typeName,
Filter filter,
Transaction transaction)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
DataStoreWrapper.getFeatureWriter(String typeName,
Transaction transaction)
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
DataStoreWrapper.getFeatureWriterAppend(String typeName,
Transaction transaction)
|
Methods in org.geotools.gce.imagemosaic.catalog.oracle with parameters of type SimpleFeatureType | |
---|---|
void |
DataStoreWrapper.createSchema(SimpleFeatureType featureType)
|
protected abstract FeatureTypeMapper |
DataStoreWrapper.getFeatureTypeMapper(SimpleFeatureType featureType)
Return a specific FeatureTypeMapper instance on top of an input featureType |
protected FeatureTypeMapper |
OracleDatastoreWrapper.getFeatureTypeMapper(SimpleFeatureType featureType)
|
void |
DataStoreWrapper.updateSchema(Name typeName,
SimpleFeatureType featureType)
|
void |
DataStoreWrapper.updateSchema(String typeName,
SimpleFeatureType featureType)
|
Constructors in org.geotools.gce.imagemosaic.catalog.oracle with parameters of type SimpleFeatureType | |
---|---|
OracleFeatureTypeMapper(SimpleFeatureType featureType)
Create a new OracleFeatureTypeMapper on top of the original featureType provided |
Uses of SimpleFeatureType in org.geotools.geojson.feature |
---|
Methods in org.geotools.geojson.feature that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
FeatureTypeHandler.getValue()
|
SimpleFeatureType |
FeatureJSON.readFeatureCollectionSchema(InputStream input,
boolean nullValuesEncoded)
Reads the SimpleFeatureType of a GeoJSON feature collection. |
SimpleFeatureType |
FeatureJSON.readFeatureCollectionSchema(Object input,
boolean nullValuesEncoded)
Reads the SimpleFeatureType of a GeoJSON feature collection. |
Methods in org.geotools.geojson.feature with parameters of type SimpleFeatureType | |
---|---|
void |
FeatureJSON.setFeatureType(SimpleFeatureType featureType)
Sets the target feature type for parsing. |
Constructors in org.geotools.geojson.feature with parameters of type SimpleFeatureType | |
---|---|
FeatureCollectionHandler(SimpleFeatureType featureType,
AttributeIO attio)
|
|
FeatureTypeAttributeIO(SimpleFeatureType featureType)
|
Uses of SimpleFeatureType in org.geotools.geopkg |
---|
Methods in org.geotools.geopkg with parameters of type SimpleFeatureType | |
---|---|
void |
GeoPackage.create(FeatureEntry entry,
SimpleFeatureType schema)
Creates a new feature entry in the geopackage. |
void |
GeoPkgDialect.postCreateTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
|
Uses of SimpleFeatureType in org.geotools.gml.producer |
---|
Methods in org.geotools.gml.producer with parameters of type SimpleFeatureType | |
---|---|
protected void |
FeatureTypeTransformer.FeatureTypeTranslator.encode(SimpleFeatureType type)
Encode the supplied feature type. |
Method parameters in org.geotools.gml.producer with type arguments of type SimpleFeatureType | |
---|---|
void |
FeatureTransformer.FeatureTranslator.handleFeatureReader(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
|
Uses of SimpleFeatureType in org.geotools.gml2.bindings |
---|
Methods in org.geotools.gml2.bindings that return SimpleFeatureType | |
---|---|
static SimpleFeatureType |
GML2ParsingUtils.featureType(Node node)
Turns a parse node instance into a geotools feature type. |
static SimpleFeatureType |
GML2ParsingUtils.featureType(XSDElementDeclaration element,
BindingWalkerFactory bwFactory)
Turns a xml type definition into a geotools feature type. |
static SimpleFeatureType |
GML2ParsingUtils.featureType(XSDElementDeclaration element,
BindingWalkerFactory bwFactory,
CoordinateReferenceSystem crs)
Turns a xml type definition into a geotools feature type. |
Methods in org.geotools.gml2.bindings with parameters of type SimpleFeatureType | |
---|---|
static XSDTypeDefinition |
GML2EncodingUtils.createXmlTypeFromFeatureType(SimpleFeatureType featureType,
SchemaIndex schemaIndex,
Set<String> toFilter)
|
XSDTypeDefinition |
GMLEncodingUtils.createXmlTypeFromFeatureType(SimpleFeatureType featureType,
SchemaIndex schemaIndex,
Set<String> toFilter)
|
static SimpleFeature |
GML2ParsingUtils.feature(SimpleFeatureType fType,
String fid,
Node node)
|
Uses of SimpleFeatureType in org.geotools.gml3.bindings |
---|
Methods in org.geotools.gml3.bindings that return SimpleFeatureType | |
---|---|
static SimpleFeatureType |
GML3ParsingUtils.featureType(XSDElementDeclaration element,
BindingWalkerFactory bwFactory)
Turns a xml type definition into a geotools feature type. |
Uses of SimpleFeatureType in org.geotools.gml4wcs.bindings |
---|
Methods in org.geotools.gml4wcs.bindings that return SimpleFeatureType | |
---|---|
static SimpleFeatureType |
GML3ParsingUtils.featureType(XSDElementDeclaration element,
BindingWalkerFactory bwFactory)
Turns a xml type definition into a geotools feature type. |
Uses of SimpleFeatureType in org.geotools.grid |
---|
Methods in org.geotools.grid that return SimpleFeatureType | |
---|---|
protected static SimpleFeatureType |
DefaultGridFeatureBuilder.createType(String typeName,
CoordinateReferenceSystem crs)
Creates the feature TYPE |
SimpleFeatureType |
GridFeatureBuilder.getType()
Gets the feature type. |
Constructors in org.geotools.grid with parameters of type SimpleFeatureType | |
---|---|
GridFeatureBuilder(SimpleFeatureType type)
Creates a GridFeatureBuilder to work with the given feature type. |
Uses of SimpleFeatureType in org.geotools.grid.ortholine |
---|
Methods in org.geotools.grid.ortholine that return SimpleFeatureType | |
---|---|
protected static SimpleFeatureType |
OrthoLineFeatureBuilder.createType(String typeName,
CoordinateReferenceSystem crs)
Creates the feature TYPE |
Uses of SimpleFeatureType in org.geotools.jdbc |
---|
Fields in org.geotools.jdbc declared as SimpleFeatureType | |
---|---|
protected SimpleFeatureType |
JDBCFeatureReader.featureType
schema of features |
Methods in org.geotools.jdbc that return SimpleFeatureType | |
---|---|
protected SimpleFeatureType |
JDBCFeatureStore.buildFeatureType()
|
protected SimpleFeatureType |
JDBCFeatureSource.buildFeatureType()
Builds the feature type from database metadata. |
SimpleFeatureType |
JoinPropertyName.getFeatureType()
|
SimpleFeatureType |
JDBCFeatureReader.getFeatureType()
|
SimpleFeatureType |
JDBCFeatureReader.ResultSetFeature.getFeatureType()
|
SimpleFeatureType |
JDBCClosingFeatureWriter.getFeatureType()
|
SimpleFeatureType |
JDBCJoiningFilteringFeatureReader.getFeatureType()
|
SimpleFeatureType |
JDBCClosingFeatureReader.getFeatureType()
|
protected SimpleFeatureType |
JoiningJDBCFeatureSource.getFeatureType(SimpleFeatureType origType,
JoiningQuery query)
|
SimpleFeatureType |
JoinInfo.JoinPart.getQueryFeatureType()
|
SimpleFeatureType |
JoinInfo.JoinPart.getReturnFeatureType()
|
SimpleFeatureType |
JDBCFeatureReader.ResultSetFeature.getType()
|
Methods in org.geotools.jdbc that return types with arguments of type SimpleFeatureType | |
---|---|
FeatureReader<SimpleFeatureType,SimpleFeature> |
JDBCJoiningFilteringFeatureReader.getDelegate()
|
FeatureReader<SimpleFeatureType,SimpleFeature> |
JDBCClosingFeatureReader.getDelegate()
|
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
JoiningJDBCFeatureSource.getJoiningReaderInternal(JoiningQuery query)
|
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
JoiningJDBCFeatureSource.getReaderInternal(Query query)
|
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
JDBCFeatureStore.getReaderInternal(Query query)
|
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
JDBCFeatureSource.getReaderInternal(Query query)
|
protected FeatureWriter<SimpleFeatureType,SimpleFeature> |
JDBCFeatureStore.getWriterInternal(Query query,
int flags)
|
Methods in org.geotools.jdbc with parameters of type SimpleFeatureType | ||
---|---|---|
static JoinInfo |
JoinInfo.create(Query query,
SimpleFeatureType featureType,
JDBCDataStore dataStore)
|
|
protected FilterToSQL |
JoiningJDBCFeatureSource.createFilterToSQL(SimpleFeatureType ft)
Craete the filter to sql converter |
|
protected FilterToSQL |
JDBCDataStore.createFilterToSQL(SimpleFeatureType featureType)
Creates a new instance of a filter to sql encoder. |
|
void |
SQLDialect.createIndex(Connection cx,
SimpleFeatureType schema,
String databaseSchema,
Index index)
Performs the class "create [unique] indexName on tableName(att1, att2, ..., attN)" call. |
|
protected PreparedFilterToSQL |
JDBCDataStore.createPreparedFilterToSQL(SimpleFeatureType featureType)
Creates a new instance of a filter to sql encoder to be used in a prepared statement. |
|
void |
JDBCDataStore.createSchema(SimpleFeatureType featureType)
Creates a table in the underlying database from the specified table. |
|
protected String |
JDBCDataStore.createTableSQL(SimpleFeatureType featureType,
Connection cx)
Generates a 'CREATE TABLE' sql statement. |
|
protected void |
JDBCDataStore.delete(SimpleFeatureType featureType,
Filter filter,
Connection cx)
Deletes an existing feature(s) in the database for a particular feature type / table. |
|
protected void |
JDBCDataStore.delete(SimpleFeatureType featureType,
String fid,
Connection cx)
Deletes an existing feature in the database for a particular feature type / fid. |
|
protected String |
JDBCDataStore.deleteSQL(SimpleFeatureType featureType,
Filter filter)
Generates a 'DELETE FROM' sql statement. |
|
protected PreparedStatement |
JDBCDataStore.deleteSQLPS(SimpleFeatureType featureType,
Filter filter,
Connection cx)
Generates a 'DELETE FROM' prepared statement. |
|
void |
SQLDialect.dropIndex(Connection cx,
SimpleFeatureType schema,
String databaseSchema,
String indexName)
Drop the index. |
|
protected String |
JDBCDataStore.dropTableSQL(SimpleFeatureType featureType,
Connection cx)
Generates a 'DROP TABLE' sql statement. |
|
void |
SQLDialect.encodePostSelect(SimpleFeatureType featureType,
StringBuffer sql)
Encodes anything after the SELECT clause and before the FROM clause. |
|
protected void |
JDBCDataStore.encodeTableJoin(SimpleFeatureType featureType,
JoinInfo join,
Query query,
StringBuffer sql)
Helper method to encode the join clause(s) of a query. |
|
protected List<FilterToSQL> |
JDBCDataStore.encodeWhereJoin(SimpleFeatureType featureType,
JoinInfo join,
StringBuffer sql)
|
|
protected void |
JDBCDataStore.ensureAuthorization(SimpleFeatureType featureType,
Filter filter,
Transaction tx,
Connection cx)
Ensures that that the specified transaction has access to features specified by a filter. |
|
protected String |
JDBCDataStore.findPrimaryKeyColumnName(SimpleFeatureType featureType)
|
|
protected Object |
JDBCDataStore.getAggregateValue(FeatureVisitor visitor,
SimpleFeatureType featureType,
Query query,
Connection cx)
Results the value of an aggregate function over a query. |
|
protected ReferencedEnvelope |
JDBCDataStore.getBounds(SimpleFeatureType featureType,
Query query,
Connection cx)
Returns the bounds of the features for a particular feature type / table. |
|
protected int |
JDBCDataStore.getCount(SimpleFeatureType featureType,
Query query,
Connection cx)
Returns the count of the features for a particular feature type / table. |
|
protected SimpleFeatureType |
JoiningJDBCFeatureSource.getFeatureType(SimpleFeatureType origType,
JoiningQuery query)
|
|
List<ReferencedEnvelope> |
SQLDialect.getOptimizedBounds(String schema,
SimpleFeatureType featureType,
Connection cx)
Returns the bounds of all geometry columns in the layer using any approach that proves to be faster than the plain bounds aggregation (e.g., better than the "plain select extent(geom) from table" on PostGIS), or null if none exists or the fast method has not been enabled (e.g., if the fast method is just an estimate of the bounds you probably want the user to enable it manually) |
|
protected PrimaryKey |
JDBCDataStore.getPrimaryKey(SimpleFeatureType featureType)
Returns the primary key object for a particular feature type / table, deriving it from the underlying database metadata. |
|
protected String |
JDBCDataStore.getPropertyName(SimpleFeatureType featureType,
PropertyName propertyName)
Helper method for executing a property name against a feature type. |
|
protected void |
JDBCFeatureReader.init(JDBCFeatureSource featureSource,
SimpleFeatureType featureType,
Hints hints)
|
|
protected
|
JDBCDataStore.initializeFilterToSQL(F toSQL,
SimpleFeatureType featureType)
Helper method to initialize a filter encoder instance. |
|
protected void |
JDBCDataStore.insert(Collection features,
SimpleFeatureType featureType,
Connection cx)
Inserts a collection of new features into the database for a particular feature type / table. |
|
protected void |
JDBCDataStore.insert(SimpleFeature feature,
SimpleFeatureType featureType,
Connection cx)
Inserts a new feature into the database for a particular feature type / table. |
|
protected String |
JDBCDataStore.insertSQL(SimpleFeatureType featureType,
SimpleFeature feature,
List keyValues,
Connection cx)
Generates a 'INSERT INFO' sql statement. |
|
protected PreparedStatement |
JDBCDataStore.insertSQLPS(SimpleFeatureType featureType,
SimpleFeature feature,
List keyValues,
Connection cx)
Generates a 'INSERT INFO' prepared statement. |
|
protected boolean |
JDBCDataStore.isExposePrimaryKeyColumns(SimpleFeatureType featureType)
Returns the expose primary key columns flag for the specified feature type |
|
void |
PreparedStatementSQLDialect.onDelete(PreparedStatement delete,
Connection cx,
SimpleFeatureType featureType)
Callback invoked before a DELETE statement is executed against the database. |
|
void |
BasicSQLDialect.onDelete(Statement delete,
Connection cx,
SimpleFeatureType featureType)
Callback invoked before a DELETE statement is executed against the database. |
|
void |
PreparedStatementSQLDialect.onInsert(PreparedStatement insert,
Connection cx,
SimpleFeatureType featureType)
Callback invoked before an INSERT statement is executed against the database. |
|
void |
BasicSQLDialect.onInsert(Statement insert,
Connection cx,
SimpleFeatureType featureType)
Callback invoked before an INSERT statement is executed against the database. |
|
void |
PreparedStatementSQLDialect.onSelect(PreparedStatement select,
Connection cx,
SimpleFeatureType featureType)
Callback invoked before a SELECT statement is executed against the database. |
|
void |
BasicSQLDialect.onSelect(Statement select,
Connection cx,
SimpleFeatureType featureType)
Callback invoked before a SELECT statement is executed against the database. |
|
void |
PreparedStatementSQLDialect.onUpdate(PreparedStatement update,
Connection cx,
SimpleFeatureType featureType)
Callback invoked before an UPDATE statement is executed against the database. |
|
void |
BasicSQLDialect.onUpdate(Statement update,
Connection cx,
SimpleFeatureType featureType)
Callback invoked before an UPDATE statement is executed against the database. |
|
void |
SQLDialect.postCreateFeatureType(SimpleFeatureType featureType,
DatabaseMetaData metadata,
String schemaName,
Connection cx)
Callback which executes after a feature type has been built from a database table. |
|
void |
SQLDialect.postCreateTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
Callback to execute any additional sql statements post a create table statement. |
|
void |
SQLDialect.postDropTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
Callback which executes after a table has been dropped. |
|
void |
SQLDialect.preDropTable(String schemaName,
SimpleFeatureType featureType,
Connection cx)
Callback which executes before a table is about to be dropped. |
|
protected String |
JDBCDataStore.selectAggregateSQL(String function,
AttributeDescriptor att,
SimpleFeatureType featureType,
Query query)
Generates a 'SELECT |
|
protected PreparedStatement |
JDBCDataStore.selectAggregateSQLPS(String function,
AttributeDescriptor att,
SimpleFeatureType featureType,
Query query,
Connection cx)
Generates a 'SELECT |
|
protected String |
JDBCDataStore.selectBoundsSQL(SimpleFeatureType featureType,
Query query)
Generates a 'SELECT' sql statement which selects bounds. |
|
protected PreparedStatement |
JDBCDataStore.selectBoundsSQLPS(SimpleFeatureType featureType,
Query query,
Connection cx)
Generates a 'SELECT' prepared statement which selects bounds. |
|
protected String |
JDBCDataStore.selectCountSQL(SimpleFeatureType featureType,
Query query)
Generates a 'SELECT count(*) FROM' sql statement. |
|
protected PreparedStatement |
JDBCDataStore.selectCountSQLPS(SimpleFeatureType featureType,
Query query,
Connection cx)
Generates a 'SELECT count(*) FROM' prepared statement. |
|
protected String |
JDBCDataStore.selectJoinSQL(SimpleFeatureType featureType,
JoinInfo join,
Query query)
|
|
protected PreparedStatement |
JDBCDataStore.selectJoinSQLPS(SimpleFeatureType featureType,
JoinInfo join,
Query query,
Connection cx)
|
|
protected String |
JoiningJDBCFeatureSource.selectSQL(SimpleFeatureType featureType,
JoiningQuery query,
AtomicReference<PreparedFilterToSQL> toSQLref)
Generates a 'SELECT p1, p2, ... |
|
protected String |
JDBCDataStore.selectSQL(SimpleFeatureType featureType,
Query query)
Generates a 'SELECT p1, p2, ... |
|
protected PreparedStatement |
JoiningJDBCFeatureSource.selectSQLPS(SimpleFeatureType featureType,
JoiningQuery query,
Connection cx)
Generates a 'SELECT p1, p2, ... |
|
protected PreparedStatement |
JDBCDataStore.selectSQLPS(SimpleFeatureType featureType,
Query query,
Connection cx)
Generates a 'SELECT p1, p2, ... |
|
void |
JoinInfo.JoinPart.setQueryFeatureType(SimpleFeatureType queryFeatureType)
|
|
void |
JoinInfo.JoinPart.setReturnFeatureType(SimpleFeatureType returnFeatureType)
|
|
protected void |
JDBCDataStore.update(SimpleFeatureType featureType,
AttributeDescriptor[] attributes,
Object[] values,
Filter filter,
Connection cx)
Updates an existing feature(s) in the database for a particular feature type / table. |
|
protected void |
JDBCDataStore.update(SimpleFeatureType featureType,
List<AttributeDescriptor> attributes,
List<Object> values,
Filter filter,
Connection cx)
Updates an existing feature(s) in the database for a particular feature type / table. |
|
protected String |
JDBCDataStore.updateSQL(SimpleFeatureType featureType,
AttributeDescriptor[] attributes,
Object[] values,
Filter filter)
Generates an 'UPDATE' sql statement. |
|
protected PreparedStatement |
JDBCDataStore.updateSQLPS(SimpleFeatureType featureType,
AttributeDescriptor[] attributes,
Object[] values,
Filter filter,
Connection cx)
Generates an 'UPDATE' prepared statement. |
Constructors in org.geotools.jdbc with parameters of type SimpleFeatureType | |
---|---|
JDBCFeatureReader(PreparedStatement st,
Connection cx,
JDBCFeatureSource featureSource,
SimpleFeatureType featureType,
Hints hints)
|
|
JDBCFeatureReader(ResultSet rs,
Connection cx,
int offset,
JDBCFeatureSource featureSource,
SimpleFeatureType featureType,
Hints hints)
|
|
JDBCFeatureReader(String sql,
Connection cx,
JDBCFeatureSource featureSource,
SimpleFeatureType featureType,
Hints hints)
|
|
JDBCJoiningFeatureReader(PreparedStatement st,
Connection cx,
JDBCFeatureSource featureSource,
SimpleFeatureType featureType,
JoinInfo join,
Hints hints)
|
|
JDBCJoiningFeatureReader(String sql,
Connection cx,
JDBCFeatureSource featureSource,
SimpleFeatureType featureType,
JoinInfo join,
Hints hints)
|
|
JoinPropertyName(SimpleFeatureType featureType,
String alias,
String name)
|
Uses of SimpleFeatureType in org.geotools.kml.bindings |
---|
Fields in org.geotools.kml.bindings declared as SimpleFeatureType | |
---|---|
protected static SimpleFeatureType |
FeatureTypeBinding.FeatureType
base feature type for kml features, used when no Schema element is specified |
static SimpleFeatureType |
FolderTypeBinding.FeatureType
|
static SimpleFeatureType |
DocumentTypeBinding.FeatureType
|
Uses of SimpleFeatureType in org.geotools.kml.v22 |
---|
Methods in org.geotools.kml.v22 that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
SchemaRegistry.get(SimpleFeatureType featureType)
|
SimpleFeatureType |
SchemaRegistry.get(String featureTypeName)
|
Methods in org.geotools.kml.v22 with parameters of type SimpleFeatureType | |
---|---|
void |
SchemaRegistry.add(String featureTypeName,
SimpleFeatureType featureType)
|
SimpleFeatureType |
SchemaRegistry.get(SimpleFeatureType featureType)
|
Uses of SimpleFeatureType in org.geotools.legend |
---|
Methods in org.geotools.legend that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
Drawer.schema(String name,
String spec)
Create a SimpleFeatureType schema using a type short hand. |
Methods in org.geotools.legend with parameters of type SimpleFeatureType | |
---|---|
static BufferedImage |
Glyph.icon(SimpleFeatureType ft)
|
Icon |
GlyphFactory.icon(SimpleFeatureType schema)
Make a basic representation of the provided FeatureType. |
Icon |
DefaultGlyphFactory.icon(SimpleFeatureType schema)
|
Uses of SimpleFeatureType in org.geotools.process.feature |
---|
Methods in org.geotools.process.feature that return SimpleFeatureType | |
---|---|
protected SimpleFeatureType |
FeatureToFeatureProcess.getTargetSchema(SimpleFeatureType sourceSchema,
Map<String,Object> input)
Subclasses should override if the target schema is different that then original schema (mind, if the number of attributes changes it's better to roll your own class instead of using this one) |
Methods in org.geotools.process.feature with parameters of type SimpleFeatureType | |
---|---|
protected SimpleFeatureType |
FeatureToFeatureProcess.getTargetSchema(SimpleFeatureType sourceSchema,
Map<String,Object> input)
Subclasses should override if the target schema is different that then original schema (mind, if the number of attributes changes it's better to roll your own class instead of using this one) |
Uses of SimpleFeatureType in org.geotools.renderer.lite |
---|
Methods in org.geotools.renderer.lite that return types with arguments of type SimpleFeatureType | |
---|---|
FeatureReader<SimpleFeatureType,SimpleFeature> |
IndexedFeatureResults.reader()
|
FeatureReader<SimpleFeatureType,SimpleFeature> |
IndexedFeatureResults.reader(Envelope envelope)
|
Uses of SimpleFeatureType in org.geotools.styling |
---|
Fields in org.geotools.styling declared as SimpleFeatureType | |
---|---|
SimpleFeatureType |
SLDInlineFeatureParser.featureType
|
Methods in org.geotools.styling that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
UserLayerImpl.getInlineFeatureType()
|
SimpleFeatureType |
UserLayer.getInlineFeatureType()
|
Methods in org.geotools.styling with parameters of type SimpleFeatureType | |
---|---|
Style |
StyleBuilder.buildClassifiedStyle(SimpleFeatureCollection fc,
String name,
String[] colors,
SimpleFeatureType schema)
given a feature collection and an array of colours build a style with the given number of classes on the named column |
static FeatureTypeStyle |
SLD.featureTypeStyle(StyledLayerDescriptor sld,
SimpleFeatureType type)
Retrieve the first FeatureTypeStyle defined in the given StyledLayerDescriptor object that matches the specified feature type |
static FeatureTypeStyle |
SLD.featureTypeStyle(Style style,
SimpleFeatureType type)
Returns the feature type style in the style which matched a particular name. |
static Style |
SLD.matchingStyle(Style[] styles,
SimpleFeatureType schema)
Returns the first style object which matches a given schema. |
void |
UserLayerImpl.setInlineFeatureType(SimpleFeatureType ft)
|
void |
UserLayer.setInlineFeatureType(SimpleFeatureType ft)
|
Uses of SimpleFeatureType in org.geotools.styling.builder |
---|
Methods in org.geotools.styling.builder with parameters of type SimpleFeatureType | |
---|---|
UserLayerBuilder |
UserLayerBuilder.inlineData(DataStore store,
SimpleFeatureType sft)
|
Uses of SimpleFeatureType in org.geotools.swing.styling |
---|
Methods in org.geotools.swing.styling with parameters of type SimpleFeatureType | |
---|---|
static Style |
JSimpleStyleDialog.showDialog(Component parent,
SimpleFeatureType featureType)
Static convenience method: displays a JSimpleStyleDialog to prompt
the user for style preferences to use with the given feature type. |
static Style |
JSimpleStyleDialog.showDialog(Component parent,
SimpleFeatureType featureType,
Style initialStyle)
Static convenience method: displays a JSimpleStyleDialog to prompt
the user for style preferences to use with the given feature type. |
Constructors in org.geotools.swing.styling with parameters of type SimpleFeatureType | |
---|---|
JSimpleStyleDialog(Dialog owner,
SimpleFeatureType schema,
Style initialStyle)
Constructor. |
|
JSimpleStyleDialog(Frame owner,
SimpleFeatureType schema,
Style initialStyle)
Constructor. |
Uses of SimpleFeatureType in org.geotools.swt.styling |
---|
Methods in org.geotools.swt.styling with parameters of type SimpleFeatureType | |
---|---|
Mode |
SimpleStyleConfigurator.determineMode(SimpleFeatureType schema,
boolean askUser)
|
Uses of SimpleFeatureType in org.geotools.swt.styling.simple |
---|
Methods in org.geotools.swt.styling.simple with parameters of type SimpleFeatureType | |
---|---|
static boolean |
SLDs.isLine(SimpleFeatureType featureType)
|
static boolean |
SLDs.isPoint(SimpleFeatureType featureType)
|
static boolean |
SLDs.isPolygon(SimpleFeatureType featureType)
|
void |
LabelViewer.set(SimpleFeatureType schema,
TextSymbolizer sym,
Mode mode)
Start editing the provided symbolizer. |
Uses of SimpleFeatureType in org.geotools.validation |
---|
Methods in org.geotools.validation with parameters of type SimpleFeatureType | |
---|---|
boolean |
FeatureValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
Used to check features against this validation rule. |
boolean |
DefaultFeatureValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
Validation test for feature. |
Uses of SimpleFeatureType in org.geotools.validation.attributes |
---|
Methods in org.geotools.validation.attributes with parameters of type SimpleFeatureType | |
---|---|
boolean |
SingleValueValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
SingleValueValidation test for feature. |
boolean |
NullZeroValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
Implement validate. |
boolean |
GazetteerNameValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
Implementation of validate. |
boolean |
EqualityValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
Validation test for feature. |
boolean |
SQLValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
SQL Validation |
boolean |
AttributeValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
Completes the specified comparison. |
boolean |
DomainValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
Validation test for feature. |
boolean |
RangeValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
Override validate. |
Uses of SimpleFeatureType in org.geotools.validation.relate |
---|
Fields in org.geotools.validation.relate declared as SimpleFeatureType | |
---|---|
protected SimpleFeatureType |
SpatialTestCase.lineType
|
Methods in org.geotools.validation.relate with parameters of type SimpleFeatureType | |
---|---|
static Filter |
OverlapsIntegrity.filterBBox(Envelope bBox,
SimpleFeatureType ft)
Try and Filter by the provided bbox, will default to Filter.EXCLUDE if null |
Uses of SimpleFeatureType in org.geotools.validation.spatial |
---|
Methods in org.geotools.validation.spatial with parameters of type SimpleFeatureType | |
---|---|
boolean |
IsValidGeometryValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
Tests to see if a geometry is valid by calling Geometry.isValid(). |
boolean |
PolygonNoGapsValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
Ensure Polygon does not have gaps. |
boolean |
LineNoSelfIntersectValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
Override validate. |
boolean |
LineNoSelfOverlappingValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
Tests to see if a LineString overlaps itself. |
boolean |
LineMustBeASinglePartValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
Override validate. |
Uses of SimpleFeatureType in org.geotools.wfs |
---|
Methods in org.geotools.wfs that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
CompositeFeatureCollection.getSchema()
|
Uses of SimpleFeatureType in org.geotools.xml.gml |
---|
Fields in org.geotools.xml.gml declared as SimpleFeatureType | |
---|---|
protected SimpleFeatureType |
FCBuffer.ft
|
Methods in org.geotools.xml.gml that return SimpleFeatureType | |
---|---|
static SimpleFeatureType |
GMLComplexTypes.createFeatureType(ComplexType element)
|
static SimpleFeatureType |
GMLComplexTypes.createFeatureType(Element element)
|
SimpleFeatureType |
FCBuffer.getFeatureType()
DOCUMENT ME! |
Methods in org.geotools.xml.gml that return types with arguments of type SimpleFeatureType | |
---|---|
static FeatureReader<SimpleFeatureType,SimpleFeature> |
FCBuffer.getFeatureReader(URI document,
int capacity)
The prefered method of using this class, this will return the Feature Reader for the document specified, using the specified buffer capacity. |
static FeatureReader<SimpleFeatureType,SimpleFeature> |
FCBuffer.getFeatureReader(URI document,
int capacity,
int timeout)
|
static FeatureReader<SimpleFeatureType,SimpleFeature> |
FCBuffer.getFeatureReader(URI document,
int capacity,
int timeout,
SimpleFeatureType ft)
|
static FeatureReader<SimpleFeatureType,SimpleFeature> |
FCBuffer.getFeatureReader(URI document,
int capacity,
SimpleFeatureType ft)
|
Methods in org.geotools.xml.gml with parameters of type SimpleFeatureType | |
---|---|
SimpleFeature |
GMLComplexTypes.AbstractFeatureType.getFeature(Element element,
ElementValue[] value,
Attributes attrs,
Map hints,
SimpleFeatureType ft)
|
static FeatureReader<SimpleFeatureType,SimpleFeature> |
FCBuffer.getFeatureReader(URI document,
int capacity,
int timeout,
SimpleFeatureType ft)
|
static FeatureReader<SimpleFeatureType,SimpleFeature> |
FCBuffer.getFeatureReader(URI document,
int capacity,
SimpleFeatureType ft)
|
Constructors in org.geotools.xml.gml with parameters of type SimpleFeatureType | |
---|---|
FCBuffer(URI document,
int capacity,
int timeout,
SimpleFeatureType ft)
|
Uses of SimpleFeatureType in org.opengis.feature |
---|
Methods in org.opengis.feature with parameters of type SimpleFeatureType | |
---|---|
SimpleFeature |
FeatureFactory.createSimpleFeature(Object[] array,
SimpleFeatureType type,
String id)
Create a SimpleFeature from an array of objects. |
Uses of SimpleFeatureType in org.opengis.feature.simple |
---|
Methods in org.opengis.feature.simple that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
SimpleFeature.getFeatureType()
The type of the feature. |
SimpleFeatureType |
SimpleFeature.getType()
Override and type narrow to SimpleFeatureType. |
Uses of SimpleFeatureType in org.opengis.feature.type |
---|
Methods in org.opengis.feature.type that return SimpleFeatureType | |
---|---|
SimpleFeatureType |
FeatureTypeFactory.createSimpleFeatureType(Name name,
List<AttributeDescriptor> schema,
GeometryDescriptor defaultGeometry,
boolean isAbstract,
List<Filter> restrictions,
AttributeType superType,
InternationalString description)
Creates a simple feature type. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |