Modifier and Type | Method and Description |
---|---|
protected SimpleFeatureType |
JoiningJDBCFeatureSource.getFeatureType(SimpleFeatureType origType,
JoiningQuery query) |
Modifier and Type | Method and Description |
---|---|
FeatureReader<SimpleFeatureType,SimpleFeature> |
JoiningJDBCFeatureSource.getJoiningReaderInternal(JdbcMultipleValue mv,
JoiningQuery query)
Gets a feature reader for a JDBC multivalued mapping.
|
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
JoiningJDBCFeatureSource.getJoiningReaderInternal(JoiningQuery query) |
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
JoiningJDBCFeatureSource.getReaderInternal(Query query) |
Modifier and Type | Method and Description |
---|---|
protected Filter |
JoiningJDBCFeatureSource.aliasFilter(Filter filter,
SimpleFeatureType featureType,
String alias) |
protected FilterToSQL |
JoiningJDBCFeatureSource.createFilterToSQL(SimpleFeatureType ft)
Craete the filter to sql converter
|
protected SimpleFeatureType |
JoiningJDBCFeatureSource.getFeatureType(SimpleFeatureType origType,
JoiningQuery query) |
String |
JoiningJDBCFeatureSource.selectSQL(SimpleFeatureType featureType,
JoiningQuery query,
AtomicReference<PreparedFilterToSQL> toSQLref)
Generates a 'SELECT p1, p2, ...
|
protected PreparedStatement |
JoiningJDBCFeatureSource.selectSQLPS(SimpleFeatureType featureType,
JoiningQuery query,
Connection cx)
Generates a 'SELECT p1, p2, ...
|
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
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() |
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
List<FeatureId> |
ArcSdeFeatureStore.addFeatures(FeatureCollection<SimpleFeatureType,SimpleFeature> collection) |
void |
ArcSdeFeatureStore.setFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader) |
Constructor and Description |
---|
ArcSdeFeatureCollection(ArcSdeFeatureSource featureSource,
SimpleFeatureType queryType,
Query namedQuery) |
Constructor and Description |
---|
ArcSdeSimplifyingFilterVisitor(SimpleFeatureType schema) |
FilterToSQLSDE(String layerQName,
String layerFidColName,
SimpleFeatureType ft,
PlainSelect definitionQuery,
ISession session) |
GeometryEncoderSDE(SeLayer layer,
SimpleFeatureType featureType) |
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
UserLayerBuilder |
UserLayerBuilder.inlineData(DataStore store,
SimpleFeatureType sft) |
Modifier and Type | Field and Description |
---|---|
protected SimpleFeatureType |
RenamingGranuleSource.schema |
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
GranuleSource.getSchema()
Retrieves the schema (feature type) that will apply to granules retrieved from this
GranuleSource . |
SimpleFeatureType |
RenamingGranuleSource.getSchema() |
Modifier and Type | Method and Description |
---|---|
void |
StructuredGridCoverage2DReader.createCoverage(String coverageName,
SimpleFeatureType schema)
Creates a granule store for a new coverage with the given feature type
|
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
CoverageSlicesCatalogSource.getSchema() |
SimpleFeatureType |
CoverageSlicesCatalog.getSchema(String typeName) |
Modifier and Type | Method and Description |
---|---|
void |
CoverageSlicesCatalog.createType(SimpleFeatureType featureType) |
Modifier and Type | Method and Description |
---|---|
void |
NetCDFReader.createCoverage(String coverageName,
SimpleFeatureType schema) |
Modifier and Type | Method and Description |
---|---|
static boolean |
FeatureUtilities.isWrappedCoverage(SimpleFeatureType featureType)
Checks if the feature type specified is a GridCoverage wrapper
|
static boolean |
FeatureUtilities.isWrappedCoverageReader(SimpleFeatureType featureType)
Checks if the feature type specified is a GridCoverage2DReader wrapper
|
Modifier and Type | Field and Description |
---|---|
protected SimpleFeatureType |
DataTestCase.buildingType |
protected SimpleFeatureType |
DataTestCase.invalidGeomType |
protected SimpleFeatureType |
DataTestCase.lakeType |
protected SimpleFeatureType |
DataTestCase.riverType |
protected SimpleFeatureType |
DataTestCase.roadType |
protected SimpleFeatureType |
DataTestCase.subRiverType |
protected SimpleFeatureType |
DataTestCase.subRoadType |
Modifier and Type | Field and Description |
---|---|
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
DiffFeatureWriter.reader |
Modifier and Type | Method and Description |
---|---|
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)
Create a derived FeatureType
|
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 |
FilteringFeatureWriter.getFeatureType() |
SimpleFeatureType |
ReTypeFeatureReader.getFeatureType() |
SimpleFeatureType |
DiffFeatureWriter.getFeatureType()
Supplys FeatureTypeFrom reader
|
SimpleFeatureType |
DefaultFeatureReader.getFeatureType() |
SimpleFeatureType |
FIDFeatureReader.getFeatureType() |
SimpleFeatureType |
CollectionFeatureReader.getFeatureType() |
SimpleFeatureType |
EmptyFeatureWriter.getFeatureType() |
SimpleFeatureType |
DefaultFeatureResults.getSchema()
FeatureSchema for provided query.
|
SimpleFeatureType |
CachingFeatureSource.getSchema()
Deprecated.
|
SimpleFeatureType |
FileDataStore.getSchema()
FeatureType for the file being read.
|
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.
|
Modifier and Type | Method and Description |
---|---|
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.
|
FeatureReader<SimpleFeatureType,SimpleFeature> |
FileDataStore.getFeatureReader() |
FeatureReader<SimpleFeatureType,SimpleFeature> |
DataStore.getFeatureReader(Query query,
Transaction transaction)
Gets a
FeatureReader for features selected by the given Query . |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
FileDataStore.getFeatureWriter(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> |
DataStore.getFeatureWriter(String typeName,
Transaction transaction)
Gets a
FeatureWriter to modify features in this DataStore . |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
FileDataStore.getFeatureWriter(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> |
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
|
Modifier and Type | Method and Description |
---|---|
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.
|
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)
Create a derived FeatureType
|
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 |
DataUtilities.reType(SimpleFeatureType featureType,
SimpleFeature feature)
Creates duplicate of feature adjusted to the provided featureType.
|
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,
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 |
FileDataStore.updateSchema(SimpleFeatureType featureType) |
void |
DataStore.updateSchema(String typeName,
SimpleFeatureType featureType)
Applies a new schema to the given feature type.
|
Modifier and Type | Method and Description |
---|---|
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 ).
|
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.
|
Constructor and Description |
---|
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 and Description |
---|
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.
|
Modifier and Type | Field and Description |
---|---|
protected SimpleFeatureType |
TreeSetFeatureCollection.schema
FeatureType of contents.
|
protected SimpleFeatureType |
SpatialIndexFeatureCollection.schema |
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
CollectionFeatureSource.getSchema() |
SimpleFeatureType |
TreeSetFeatureCollection.getSchema() |
SimpleFeatureType |
SpatialIndexFeatureCollection.getSchema() |
SimpleFeatureType |
SpatialIndexFeatureSource.getSchema() |
Modifier and Type | Method and Description |
---|---|
DataAccess<SimpleFeatureType,SimpleFeature> |
CollectionFeatureSource.getDataStore() |
FeatureReader<SimpleFeatureType,SimpleFeature> |
TreeSetFeatureCollection.reader() |
Modifier and Type | Method and Description |
---|---|
boolean |
SpatialIndexFeatureCollection.addAll(FeatureCollection<? extends SimpleFeatureType,? extends SimpleFeature> collection) |
Constructor and Description |
---|
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.
|
ListFeatureCollection(SimpleFeatureType schema,
SimpleFeature[] array)
Create a ListFeatureCollection around the provided array.
|
SpatialIndexFeatureCollection(SimpleFeatureType schema) |
TreeSetFeatureCollection(String id,
SimpleFeatureType memberType)
This constructor should not be used by client code.
|
Constructor and Description |
---|
TreeSetFeatureCollection(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
This constructor should not be used by client code.
|
Modifier and Type | Method and Description |
---|---|
FeatureSource<SimpleFeatureType,SimpleFeature> |
FeatureTypeMapping.getIndexSource() |
Modifier and Type | Method and Description |
---|---|
void |
FeatureTypeMapping.setIndexSource(FeatureSource<SimpleFeatureType,SimpleFeature> indexSource) |
Constructor and Description |
---|
FeatureTypeMapping(FeatureSource<? extends FeatureType,? extends Feature> source,
FeatureSource<SimpleFeatureType,SimpleFeature> indexSource,
AttributeDescriptor target,
String defaultGeometryXPath,
List<AttributeMapping> mappings,
NamespaceSupport namespaces,
boolean isDenormalised) |
IndexUniqueVisitorIterator(FeatureCollection<SimpleFeatureType,SimpleFeature> fc,
Query idQuery,
String idFieldName) |
Modifier and Type | Field and Description |
---|---|
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
ForceCoordinateSystemFeatureReader.reader |
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
ForceCoordinateSystemFeatureReader.getFeatureType() |
SimpleFeatureType |
ReprojectFeatureReader.getFeatureType()
Implement getFeatureType.
|
SimpleFeatureType |
ForceCoordinateSystemIterator.getFeatureType() |
SimpleFeatureType |
ReprojectFeatureIterator.getFeatureType()
Implement getFeatureType.
|
Modifier and Type | Method and Description |
---|---|
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
|
Constructor and Description |
---|
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).
|
Modifier and Type | Method and Description |
---|---|
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) |
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
DirectoryFeatureSource.getSchema() |
SimpleFeatureType |
DirectoryDataStore.getSchema(Name name) |
SimpleFeatureType |
DirectoryDataStore.getSchema(String typeName) |
Modifier and Type | Method and Description |
---|---|
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) |
Modifier and Type | Method and Description |
---|---|
void |
DirectoryDataStore.createSchema(SimpleFeatureType featureType) |
void |
DirectoryDataStore.updateSchema(Name typeName,
SimpleFeatureType featureType) |
void |
DirectoryDataStore.updateSchema(String typeName,
SimpleFeatureType featureType) |
Modifier and Type | Method and Description |
---|---|
void |
DirectoryFeatureStore.setFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader) |
Modifier and Type | Field and Description |
---|---|
protected SimpleFeatureType |
PreGeneralizedFeatureReader.featureTyp |
protected SimpleFeatureType |
PreGeneralizedFeatureIterator.featureTyp |
protected SimpleFeatureType |
PreGeneralizedFeatureCollection.featureType |
Modifier and Type | Field and Description |
---|---|
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
PreGeneralizedFeatureReader.backendReader |
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
PreGeneralizedFeatureReader.getFeatureType() |
SimpleFeatureType |
PreGeneralizedSimpleFeature.getFeatureType() |
SimpleFeatureType |
PreGeneralizedFeatureCollection.getSchema() |
SimpleFeatureType |
PreGeneralizedFeatureSource.getSchema() |
SimpleFeatureType |
PreGeneralizedDataStore.getSchema(Name name) |
SimpleFeatureType |
PreGeneralizedDataStore.getSchema(String typeName) |
SimpleFeatureType |
PreGeneralizedSimpleFeature.getType() |
Modifier and Type | Method and Description |
---|---|
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) |
Modifier and Type | Method and Description |
---|---|
void |
PreGeneralizedDataStore.createSchema(SimpleFeatureType featureType) |
void |
PreGeneralizedDataStore.updateSchema(Name typeName,
SimpleFeatureType featureType) |
void |
PreGeneralizedDataStore.updateSchema(String typeName,
SimpleFeatureType featureType) |
Constructor and Description |
---|
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 and Description |
---|
PreGeneralizedFeatureReader(SimpleFeatureType featureTyp,
int[] indexMapping,
FeatureReader<SimpleFeatureType,SimpleFeature> backendReader,
String geomPropertyName,
String backendGeomPropertyName) |
Modifier and Type | Method and Description |
---|---|
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) |
Modifier and Type | Field and Description |
---|---|
protected SimpleFeatureType |
FilterToSQL.featureType
the schmema the encoder will be used to be encode sql for
|
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
FilterToSQL.getFeatureType()
Returns the feature type set in this encoder, if any
|
Modifier and Type | Method and Description |
---|---|
void |
FilterToSQL.setFeatureType(SimpleFeatureType featureType)
Sets the featuretype the encoder is encoding sql for.
|
Modifier and Type | Method and Description |
---|---|
protected SimpleFeatureType |
MemoryFeatureStore.buildFeatureType() |
protected SimpleFeatureType |
MemoryFeatureSource.buildFeatureType() |
SimpleFeatureType |
MemoryFeatureWriter.getFeatureType() |
SimpleFeatureType |
MemoryFeatureReader.getFeatureType() |
Modifier and Type | Method and Description |
---|---|
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
MemoryFeatureStore.getReaderInternal(Query query) |
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
MemoryFeatureSource.getReaderInternal(Query query) |
protected FeatureWriter<SimpleFeatureType,SimpleFeature> |
MemoryFeatureStore.getWriterInternal(Query query,
int flags) |
Modifier and Type | Method and Description |
---|---|
void |
MemoryDataStore.createSchema(SimpleFeatureType featureType)
Adds support for a new featureType to MemoryDataStore.
|
protected MemoryEntry |
MemoryDataStore.entry(SimpleFeatureType schema)
Access to entry to store content of the provided schema, will create new entry if needed.
|
Modifier and Type | Method and Description |
---|---|
void |
MemoryDataStore.addFeatures(FeatureCollection<SimpleFeatureType,SimpleFeature> collection) |
void |
MemoryDataStore.addFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
Configures MemoryDataStore with FeatureReader.
|
Constructor and Description |
---|
MemoryDataStore(SimpleFeatureType featureType)
Construct an MemoryDataStore around an empty collection of the provided SimpleFeatureType
|
MemoryFeatureCollection(SimpleFeatureType schema) |
Constructor and Description |
---|
MemoryDataStore(FeatureCollection<SimpleFeatureType,SimpleFeature> collection) |
MemoryDataStore(FeatureReader<SimpleFeatureType,SimpleFeature> reader) |
Modifier and Type | Method and Description |
---|---|
protected SimpleFeatureType |
MongoFeatureStore.buildFeatureType() |
protected SimpleFeatureType |
MongoFeatureSource.buildFeatureType() |
SimpleFeatureType |
MongoSchemaMapper.buildFeatureType(Name name,
DBCollection collection) |
SimpleFeatureType |
CollectionMapper.buildFeatureType(Name name,
DBCollection collection) |
SimpleFeatureType |
MongoInferredMapper.buildFeatureType(Name name,
DBCollection collection) |
SimpleFeatureType |
GeoJSONMapper.buildFeatureType(Name name,
DBCollection collection) |
static SimpleFeatureType |
FeatureTypeDBObject.convert(DBObject ftDBO) |
static SimpleFeatureType |
FeatureTypeDBObject.convert(DBObject ftDBO,
Name name) |
SimpleFeatureType |
MongoFeatureReader.getFeatureType() |
SimpleFeatureType |
MongoFeatureWriter.getFeatureType() |
SimpleFeatureType |
MongoDBObjectFeature.getFeatureType() |
SimpleFeatureType |
MongoDBObjectFeature.getType() |
SimpleFeatureType |
MongoSchemaStore.retrieveSchema(Name name) |
SimpleFeatureType |
MongoSchemaFileStore.retrieveSchema(Name name) |
SimpleFeatureType |
MongoSchemaDBStore.retrieveSchema(Name name) |
Modifier and Type | Method and Description |
---|---|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
MongoDataStore.getFeatureWriter(String typeName,
Filter filter,
Transaction tx) |
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
MongoFeatureStore.getReaderInternal(Query query) |
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
MongoFeatureSource.getReaderInternal(Query query) |
protected FeatureWriter<SimpleFeatureType,SimpleFeature> |
MongoFeatureStore.getWriterInternal(Query query,
int flags) |
Modifier and Type | Method and Description |
---|---|
SimpleFeature |
AbstractCollectionMapper.buildFeature(DBObject rootDBO,
SimpleFeatureType featureType) |
SimpleFeature |
CollectionMapper.buildFeature(DBObject obj,
SimpleFeatureType featureType) |
static DBObject |
FeatureTypeDBObject.convert(SimpleFeatureType ft) |
void |
MongoDataStore.createSchema(SimpleFeatureType incoming) |
void |
FilterToMongo.setFeatureType(SimpleFeatureType featureType)
Sets the feature type the encoder is encoding a filter for.
|
void |
MongoSchemaStore.storeSchema(SimpleFeatureType schema) |
void |
MongoSchemaFileStore.storeSchema(SimpleFeatureType schema) |
void |
MongoSchemaDBStore.storeSchema(SimpleFeatureType schema) |
Constructor and Description |
---|
MongoDBObjectFeature(DBObject dbo,
SimpleFeatureType featureType,
CollectionMapper mapper) |
MongoFeature(DBObject mongoObject,
Object[] values,
SimpleFeatureType featureType,
String id) |
MongoFeature(Object[] values,
SimpleFeatureType featureType,
String id) |
MongoFeatureWriter(DBCollection collection,
SimpleFeatureType featureType,
MongoFeatureStore featureStore) |
MongoSchemaMapper(SimpleFeatureType schema) |
Modifier and Type | Method and Description |
---|---|
void |
MySQLDialectPrepared.dropIndex(Connection cx,
SimpleFeatureType schema,
String databaseSchema,
String indexName) |
void |
MySQLDialect.dropIndex(Connection cx,
SimpleFeatureType schema,
String databaseSchema,
String indexName) |
void |
MySQLDialectBasic.dropIndex(Connection cx,
SimpleFeatureType schema,
String databaseSchema,
String indexName) |
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) |
Modifier and Type | Method and Description |
---|---|
List<ReferencedEnvelope> |
OracleDialect.getOptimizedBounds(String schema,
SimpleFeatureType featureType,
Connection cx) |
List<ReferencedEnvelope> |
OracleDialect.getOptimizedBoundsSDO_TUNE(String schema,
SimpleFeatureType featureType,
Connection cx) |
void |
OracleDialect.postCreateTable(String schemaName,
SimpleFeatureType featureType,
Connection cx) |
void |
OracleDialect.postDropTable(String schemaName,
SimpleFeatureType featureType,
Connection cx) |
Modifier and Type | Method and Description |
---|---|
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) |
Modifier and Type | Method and Description |
---|---|
protected SimpleFeatureType |
PropertyFeatureSource.buildFeatureType() |
protected SimpleFeatureType |
PropertyFeatureStore.buildFeatureType() |
SimpleFeatureType |
PropertyFeatureReader.getFeatureType() |
SimpleFeatureType |
PropertyFeatureWriter.getFeatureType() |
Modifier and Type | Method and Description |
---|---|
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
PropertyFeatureSource.getReaderInternal(Query query) |
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
PropertyFeatureStore.getReaderInternal(Query query) |
protected FeatureWriter<SimpleFeatureType,SimpleFeature> |
PropertyFeatureStore.getWriterInternal(Query query,
int flags) |
Modifier and Type | Method and Description |
---|---|
void |
PropertyDataStore.createSchema(SimpleFeatureType featureType) |
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
ShapefileDataStore.getSchema() |
Modifier and Type | Method and Description |
---|---|
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) |
Modifier and Type | Method and Description |
---|---|
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.
|
protected String |
ShapefileDumper.getShapeName(SimpleFeatureType schema,
String geometryType)
Returns the shapefile name from the given schema and geometry type.
|
protected void |
ShapefileDumper.shapefileDumped(String fileName,
SimpleFeatureType remappedSchema)
Allows subsclasses to perform extra actions against a shapefile that was completely written
|
void |
ShapefileDataStore.updateSchema(SimpleFeatureType featureType) |
Constructor and Description |
---|
DelegateSimpleFeatureReader(SimpleFeatureType featureType,
SimpleFeatureIterator features) |
EmptySimpleFeatureReader(SimpleFeatureType featureType) |
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
SortedFeatureReader.getFeatureType() |
Modifier and Type | Method and Description |
---|---|
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.
|
Constructor and Description |
---|
SimpleFeatureIO(File file,
SimpleFeatureType schema) |
SortedFeatureIterator(SimpleFeatureIterator iterator,
SimpleFeatureType schema,
SortBy[] sortBy,
int maxFeatures)
Builds a new sorting feature iterator
|
Modifier and Type | Method and Description |
---|---|
void |
SQLServerDialect.dropIndex(Connection cx,
SimpleFeatureType schema,
String databaseSchema,
String indexName)
Drop the index.
|
void |
SQLServerDialect.handleSelectHints(StringBuffer sql,
SimpleFeatureType featureType,
Query query) |
void |
SQLServerDialect.postCreateFeatureType(SimpleFeatureType featureType,
DatabaseMetaData md,
String databaseSchema,
Connection cx) |
void |
SQLServerDialect.postCreateTable(String schemaName,
SimpleFeatureType featureType,
Connection cx) |
Modifier and Type | Field and Description |
---|---|
protected SimpleFeatureType |
ContentState.featureType
cached feature type
|
protected SimpleFeatureType |
ContentFeatureCollection.featureType
feature (possibly retyped from feautre source original) type
|
protected SimpleFeatureType |
DataFeatureCollection.schema |
protected SimpleFeatureType |
ContentFeatureSource.schema
Cached feature type (only set if this instance is a view)
|
Modifier and Type | Field and Description |
---|---|
protected FeatureReader<SimpleFeatureType,SimpleFeature> |
DiffContentFeatureWriter.reader |
Modifier and Type | Method and Description |
---|---|
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 |
ContentState.getFeatureType()
The cached feature type.
|
SimpleFeatureType |
EventContentFeatureWriter.getFeatureType()
Supplys FeatureTypeFrom reader
|
SimpleFeatureType |
DiffContentFeatureWriter.getFeatureType()
Supplys FeatureTypeFrom reader
|
SimpleFeatureType |
DataFeatureCollection.getSchema() |
SimpleFeatureType |
ReTypingFeatureCollection.getSchema() |
SimpleFeatureType |
ContentFeatureCollection.getSchema() |
SimpleFeatureType |
ContentFeatureSource.getSchema()
Returns the feature type or the schema of the feature source.
|
SimpleFeatureType |
ReprojectingFeatureCollection.getSchema() |
SimpleFeatureType |
ContentDataStore.getSchema(Name name)
Delegates to
ContentDataStore.getSchema(String) with name.getLocalPart() |
SimpleFeatureType |
DecoratingDataStore.getSchema(Name name) |
SimpleFeatureType |
ContentDataStore.getSchema(String typeName)
Returns the feature type or schema matching the specified name.
|
SimpleFeatureType |
DecoratingDataStore.getSchema(String typeName) |
Modifier and Type | Method and Description |
---|---|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
DiffTransactionState.diffWriter(ContentFeatureStore contentFeatureStore,
FeatureReader<SimpleFeatureType,SimpleFeature> reader)
Provides a wrapper on the provided reader which gives a diff writer.
|
FeatureReader<SimpleFeatureType,SimpleFeature> |
ContentDataStore.getFeatureReader(Query query,
Transaction tx)
Returns a feature reader for the specified query and transaction.
|
FeatureReader<SimpleFeatureType,SimpleFeature> |
DecoratingDataStore.getFeatureReader(Query query,
Transaction transaction) |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
ContentDataStore.getFeatureWriter(String typeName,
Filter filter,
Transaction tx)
Returns a feature writer for the specified query and transaction.
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
DecoratingDataStore.getFeatureWriter(String typeName,
Filter filter,
Transaction transaction) |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
ContentDataStore.getFeatureWriter(String typeName,
Transaction tx)
Returns a feature writer for the specified type name and transaction.
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
DecoratingDataStore.getFeatureWriter(String typeName,
Transaction transaction) |
FeatureWriter<SimpleFeatureType,SimpleFeature> |
ContentDataStore.getFeatureWriterAppend(String typeName,
Transaction tx)
Returns an appending feature writer for the specified type name and transaction.
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
DecoratingDataStore.getFeatureWriterAppend(String typeName,
Transaction 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> |
DataFeatureCollection.reader() |
FeatureReader<SimpleFeatureType,SimpleFeature> |
ReTypingFeatureCollection.reader() |
FeatureReader<SimpleFeatureType,SimpleFeature> |
ReprojectingFeatureCollection.reader() |
protected FeatureWriter<SimpleFeatureType,SimpleFeature> |
DataFeatureCollection.writer()
Subclass may provide an implementation of this method to indicate that read/write support is
provided.
|
Modifier and Type | Method and Description |
---|---|
void |
ContentDataStore.createSchema(SimpleFeatureType featureType)
Creates a new schema in the datastore.
|
void |
DecoratingDataStore.createSchema(SimpleFeatureType featureType) |
static boolean |
ReprojectingFeatureCollection.isGeometryless(FeatureVisitor visitor,
SimpleFeatureType schema)
Returns true if the visitor is geometryless, that is, it's not accessing a geometry field in
the target schema
|
static boolean |
ReTypingFeatureCollection.isTypeCompatible(FeatureVisitor visitor,
SimpleFeatureType featureType)
Checks if the visitor is accessing only properties available in the specified feature type,
or as a special case, if it's a count visitor accessing no properties at all
|
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 |
DecoratingDataStore.updateSchema(Name typeName,
SimpleFeatureType featureType) |
void |
ContentDataStore.updateSchema(String typeName,
SimpleFeatureType featureType) |
void |
DecoratingDataStore.updateSchema(String typeName,
SimpleFeatureType featureType) |
Modifier and Type | Method and Description |
---|---|
List<FeatureId> |
ContentFeatureStore.addFeatures(FeatureCollection<SimpleFeatureType,SimpleFeature> featureCollection)
Adds a collection of features to the store.
|
FeatureWriter<SimpleFeatureType,SimpleFeature> |
DiffTransactionState.diffWriter(ContentFeatureStore contentFeatureStore,
FeatureReader<SimpleFeatureType,SimpleFeature> reader)
Provides a wrapper on the provided reader which gives a diff writer.
|
void |
ContentFeatureStore.setFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
Sets the feature of the source.
|
Modifier and Type | Method and Description |
---|---|
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) |
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
TransformFeatureSource.getSchema() |
SimpleFeatureType |
SingleFeatureSourceDataStore.getSchema(Name name) |
SimpleFeatureType |
SingleFeatureSourceDataStore.getSchema(String typeName) |
Modifier and Type | Method and Description |
---|---|
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) |
Modifier and Type | Method and Description |
---|---|
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) |
Modifier and Type | Method and Description |
---|---|
List<FeatureId> |
TransformFeatureStore.addFeatures(FeatureCollection<SimpleFeatureType,SimpleFeature> collection) |
void |
TransformFeatureStore.setFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader) |
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
DefaultView.getSchema()
Implement getSchema.
|
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
WFSDataStore.getRemoteSimpleFeatureType(QName remoteTypeName) |
SimpleFeatureType |
WFSDataStore.getStoredQuerySchema(String storedQueryId) |
Modifier and Type | Method and Description |
---|---|
ReferencedEnvelope |
WFSDiff.batchModify(Name[] properties,
Object[] values,
Filter filter,
FeatureReader<SimpleFeatureType,SimpleFeature> oldFeatures,
ContentState contentState) |
Constructor and Description |
---|
WFSFeatureWriter(WFSFeatureStore store,
WFSLocalTransactionState localSate,
FeatureReader<SimpleFeatureType,SimpleFeature> reader,
boolean autoCommit) |
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
WFSResponse.getQueryType() |
Modifier and Type | Method and Description |
---|---|
void |
WFSResponse.setQueryType(SimpleFeatureType queryType) |
Modifier and Type | Method and Description |
---|---|
static SimpleFeatureType |
EmfAppSchemaParser.parse(Configuration wfsConfiguration,
QName featureName,
URL schemaLocation,
CoordinateReferenceSystem crs,
Map<QName,Class<?>> mappedBindings)
Parses the FeatureType pointed out by the
schemaLocation URL and returns it. |
static SimpleFeatureType |
EmfAppSchemaParser.parseSimpleFeatureType(Configuration configuration,
QName featureTypeName,
URL schemaLocation,
CoordinateReferenceSystem crs) |
static SimpleFeatureType |
EmfAppSchemaParser.parseSimpleFeatureType(Configuration wfsConfiguration,
QName featureName,
URL schemaLocation,
CoordinateReferenceSystem crs,
Map<QName,Class<?>> mappedBindings)
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<QName,Class<?>> mappedBindings) |
static SimpleFeatureType |
EmfAppSchemaParser.toSimpleFeatureType(FeatureType realType)
Go through FeatureType description and convert to a SimpleFeatureType.
|
Constructor and Description |
---|
XmlSimpleFeatureParser(InputStream getFeatureResponseStream,
SimpleFeatureType targetType,
QName featureDescriptorName,
String axisOrder) |
Modifier and Type | Field and Description |
---|---|
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 |
Modifier and Type | Method and Description |
---|---|
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).
|
Modifier and Type | Method and Description |
---|---|
FeatureReader<SimpleFeatureType,SimpleFeature> |
DefaultFeatureCollection.reader() |
Modifier and Type | Method and Description |
---|---|
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 );
|
Constructor and Description |
---|
DefaultFeatureCollection(String id,
SimpleFeatureType memberType)
Used to create a feature collection to stage content in memory.
|
Constructor and Description |
---|
DefaultFeatureCollection(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
Used to stage content in memory.
|
Modifier and Type | Field and Description |
---|---|
protected SimpleFeatureType |
AbstractFeatureCollection.schema |
protected SimpleFeatureType |
AdaptorFeatureCollection.schema |
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
AbstractFeatureCollection.getSchema() |
SimpleFeatureType |
DecoratingSimpleFeatureCollection.getSchema() |
SimpleFeatureType |
AdaptorFeatureCollection.getSchema() |
Modifier and Type | Method and Description |
---|---|
FeatureReader<SimpleFeatureType,SimpleFeature> |
FilteringSimpleFeatureCollection.reader() |
Constructor and Description |
---|
AbstractFeatureCollection(SimpleFeatureType memberType) |
AdaptorFeatureCollection(String id,
SimpleFeatureType memberType) |
BaseSimpleFeatureCollection(SimpleFeatureType schema) |
Constructor and Description |
---|
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) |
Modifier and Type | Class and Description |
---|---|
class |
SimpleFeatureTypeImpl
Implementation fo SimpleFeatureType, subtypes must be atomic and are stored in a list.
|
Modifier and Type | Field and Description |
---|---|
protected SimpleFeatureType |
SimpleFeatureImpl.featureType |
protected SimpleFeatureType |
SimpleFeatureTypeBuilder.superType
the parent type.
|
Modifier and Type | Method and Description |
---|---|
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 origional,
Query query)
Configure expected
|
static SimpleFeatureType |
SimpleFeatureTypeBuilder.retype(SimpleFeatureType original,
String[] types)
Create a SimpleFeatureType containing just the descriptors indicated.
|
Modifier and Type | Method and Description |
---|---|
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 origional,
Query query)
Configure expected
|
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
|
Constructor and Description |
---|
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.
|
Modifier and Type | Field and Description |
---|---|
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
|
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
FeatureTypeFactoryImpl.createSimpleFeatureType(Name name,
List<AttributeDescriptor> schema,
GeometryDescriptor defaultGeometry,
boolean isAbstract,
List<Filter> restrictions,
AttributeType superType,
InternationalString description) |
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
GroupByVisitorBuilder |
GroupByVisitorBuilder.withAggregateAttribute(int attributeTypeIndex,
SimpleFeatureType type) |
GroupByVisitorBuilder |
GroupByVisitorBuilder.withAggregateAttribute(String attributeName,
SimpleFeatureType type) |
GroupByVisitorBuilder |
GroupByVisitorBuilder.withGroupByAttribute(int attributeTypeIndex,
SimpleFeatureType type) |
GroupByVisitorBuilder |
GroupByVisitorBuilder.withGroupByAttribute(String attributeName,
SimpleFeatureType type) |
GroupByVisitorBuilder |
GroupByVisitorBuilder.withGroupByAttributes(Collection<String> attributesNames,
SimpleFeatureType type) |
Constructor and Description |
---|
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) |
SumAreaVisitor(int attributeTypeIndex,
SimpleFeatureType type) |
SumAreaVisitor(String attrName,
SimpleFeatureType type) |
SumVisitor(int attributeTypeIndex,
SimpleFeatureType type) |
SumVisitor(String attrName,
SimpleFeatureType type) |
UniqueVisitor(int attributeTypeIndex,
SimpleFeatureType type) |
UniqueVisitor(String attrName,
SimpleFeatureType type) |
Modifier and Type | Field and Description |
---|---|
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
|
Modifier and Type | Method and Description |
---|---|
static String[] |
Filters.attributeNames(Filter filter,
SimpleFeatureType featureType)
Traverses the filter and returns any encountered property names.
|
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.
|
Constructor and Description |
---|
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,
FilterFactory2 factory)
Constructor injection
|
FilterAttributeExtractor(SimpleFeatureType featureType)
Use the provided feature type as a sanity check when extracting property names.
|
Constructor and Description |
---|
PostPreProcessFilterSplittingVisitor(FilterCapabilities fcs,
SimpleFeatureType parent,
ClientTransactionAccessor transactionAccessor)
Deprecated.
Create a new instance.
|
PropertyNameResolvingVisitor(SimpleFeatureType featureType) |
Modifier and Type | Method and Description |
---|---|
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 |
static boolean |
Utils.isValidMosaicSchema(SimpleFeatureType schema,
String locationAttributeName)
Returns true if the type is usable as a mosaic index
|
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
GranuleCatalogSource.getSchema() |
abstract SimpleFeatureType |
GranuleCatalog.getType(String typeName) |
Modifier and Type | Method and Description |
---|---|
abstract void |
GranuleCatalog.createType(SimpleFeatureType featureType) |
Modifier and Type | Method and Description |
---|---|
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
|
Modifier and Type | Method and Description |
---|---|
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) |
Modifier and Type | Method and Description |
---|---|
void |
DataStoreWrapper.createSchema(SimpleFeatureType featureType) |
protected FeatureTypeMapper |
OracleDatastoreWrapper.getFeatureTypeMapper(SimpleFeatureType featureType) |
protected abstract FeatureTypeMapper |
DataStoreWrapper.getFeatureTypeMapper(SimpleFeatureType featureType)
Return a specific
FeatureTypeMapper instance on top of an input featureType |
void |
DataStoreWrapper.updateSchema(Name typeName,
SimpleFeatureType featureType) |
void |
DataStoreWrapper.updateSchema(String typeName,
SimpleFeatureType featureType) |
Constructor and Description |
---|
OracleFeatureTypeMapper(SimpleFeatureType featureType)
Create a new
OracleFeatureTypeMapper on top of the original featureType provided |
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
PostgisFeatureTypeMapper.getMappedFeatureType() |
SimpleFeatureType |
PostgisFeatureTypeMapper.getWrappedFeatureType() |
Modifier and Type | Method and Description |
---|---|
DataAccess<SimpleFeatureType,SimpleFeature> |
PostgisTransformFeatureStore.getDataStore() |
Modifier and Type | Method and Description |
---|---|
protected FeatureTypeMapper |
PostgisDatastoreWrapper.getFeatureTypeMapper(SimpleFeatureType featureType) |
Constructor and Description |
---|
PostgisFeatureTypeMapper(SimpleFeatureType featureType)
Create a new
PostgisFeatureTypeMapper on top of the original featureType provided |
Modifier and Type | Method and Description |
---|---|
void |
DefaultGranuleHandler.handleGranule(Object source,
GridCoverage2DReader inputReader,
SimpleFeature targetFeature,
SimpleFeatureType targetFeatureType,
SimpleFeature feature,
SimpleFeatureType inputFeatureType,
MosaicConfigurationBean mosaicConfiguration) |
void |
ReprojectingGranuleHandler.handleGranule(Object source,
GridCoverage2DReader inputReader,
SimpleFeature targetFeature,
SimpleFeatureType targetFeatureType,
SimpleFeature inputFeature,
SimpleFeatureType inputFeatureType,
MosaicConfigurationBean mosaicConfiguration) |
void |
GranuleHandler.handleGranule(Object source,
GridCoverage2DReader inputReader,
SimpleFeature targetFeature,
SimpleFeatureType targetFeatureType,
SimpleFeature inputFeature,
SimpleFeatureType inputFeatureType,
MosaicConfigurationBean mosaicConfiguration)
Handle the case of a grid coverage being added to the mosaic.
|
default void |
GranuleHandler.handleStructuredGranule(Object source,
GridCoverage2DReader inputReader,
SimpleFeature targetFeature,
SimpleFeatureType targetFeatureType,
SimpleFeature inputFeature,
SimpleFeatureType inputFeatureType,
MosaicConfigurationBean mosaicConfiguration) |
Modifier and Type | Method and Description |
---|---|
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. |
Modifier and Type | Method and Description |
---|---|
void |
FeatureJSON.setFeatureType(SimpleFeatureType featureType)
Sets the target feature type for parsing.
|
Constructor and Description |
---|
FeatureCollectionHandler(SimpleFeatureType featureType,
AttributeIO attio) |
FeatureTypeAttributeIO(SimpleFeatureType featureType) |
Modifier and Type | Method and Description |
---|---|
void |
GeoPackage.create(FeatureEntry entry,
SimpleFeatureType schema)
Creates a new feature entry in the geopackage.
|
void |
GeoPkgDialect.postCreateTable(String schemaName,
SimpleFeatureType featureType,
Connection cx) |
void |
GeoPkgDialect.postDropTable(String schemaName,
SimpleFeatureType featureType,
Connection cx) |
Filter[] |
GeoPkgDialect.splitFilter(Filter filter,
SimpleFeatureType schema) |
Modifier and Type | Method and Description |
---|---|
protected void |
FeatureTypeTransformer.FeatureTypeTranslator.encode(SimpleFeatureType type)
Encode the supplied feature type.
|
Modifier and Type | Method and Description |
---|---|
void |
FeatureTransformer.FeatureTranslator.handleFeatureReader(FeatureReader<SimpleFeatureType,SimpleFeature> reader) |
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
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) |
Modifier and Type | Method and Description |
---|---|
static SimpleFeatureType |
GML3ParsingUtils.featureType(XSDElementDeclaration element,
BindingWalkerFactory bwFactory)
Turns a xml type definition into a geotools feature type.
|
Modifier and Type | Method and Description |
---|---|
static SimpleFeatureType |
GML3ParsingUtils.featureType(XSDElementDeclaration element,
BindingWalkerFactory bwFactory)
Turns a xml type definition into a geotools feature type.
|
Modifier and Type | Method and Description |
---|---|
protected static SimpleFeatureType |
DefaultGridFeatureBuilder.createType(String typeName,
CoordinateReferenceSystem crs)
Creates the feature TYPE
|
SimpleFeatureType |
GridFeatureBuilder.getType()
Gets the feature type.
|
Constructor and Description |
---|
GridFeatureBuilder(SimpleFeatureType type)
Creates a
GridFeatureBuilder to work with the given feature type. |
Modifier and Type | Method and Description |
---|---|
protected static SimpleFeatureType |
OrthoLineFeatureBuilder.createType(String typeName,
CoordinateReferenceSystem crs)
Creates the feature TYPE
|
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
NetCDFImageReader.getIndexSchema(Name coverageName,
CoordinateSystem cs) |
SimpleFeatureType |
NetCDFImageReader.getIndexSchema(Name coverageName,
CoordinateSystem coordinateSystem,
boolean isShared) |
Modifier and Type | Method and Description |
---|---|
void |
VariableAdapter.updateMapping(SimpleFeatureType indexSchema,
List<DimensionDescriptor> descriptors)
Update the dimensionDescriptor attributes mapping by checking the actual attribute names from
the schema
|
Modifier and Type | Method and Description |
---|---|
static SimpleFeatureType |
NetCDFUtilities.createFeatureType(String schemaName,
String schemaDef,
CoordinateReferenceSystem crs) |
Modifier and Type | Field and Description |
---|---|
protected SimpleFeatureType |
JDBCFeatureReader.featureType
schema of features
|
Modifier and Type | Method and Description |
---|---|
protected SimpleFeatureType |
JDBCFeatureStore.buildFeatureType() |
protected SimpleFeatureType |
JDBCFeatureSource.buildFeatureType()
Builds the feature type from database metadata.
|
SimpleFeatureType |
JDBCJoiningFilteringFeatureReader.getFeatureType() |
SimpleFeatureType |
JDBCFeatureReader.getFeatureType() |
SimpleFeatureType |
JDBCFeatureReader.ResultSetFeature.getFeatureType() |
SimpleFeatureType |
JDBCClosingFeatureReader.getFeatureType() |
SimpleFeatureType |
JoinPropertyName.getFeatureType() |
SimpleFeatureType |
JDBCClosingFeatureWriter.getFeatureType() |
SimpleFeatureType |
JoinInfo.JoinPart.getQueryFeatureType() |
SimpleFeatureType |
JoinInfo.JoinPart.getReturnFeatureType() |
SimpleFeatureType |
JDBCFeatureReader.ResultSetFeature.getType() |
Modifier and Type | Method and Description |
---|---|
FeatureReader<SimpleFeatureType,SimpleFeature> |
JDBCJoiningFilteringFeatureReader.getDelegate() |
FeatureReader<SimpleFeatureType,SimpleFeature> |
JDBCClosingFeatureReader.getDelegate() |
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) |
Modifier and Type | Method and Description |
---|---|
static JoinInfo |
JoinInfo.create(Query query,
SimpleFeatureType featureType,
JDBCDataStore dataStore) |
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.
|
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.
|
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)
|
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.
|
void |
SQLDialect.handleSelectHints(StringBuffer sql,
SimpleFeatureType featureType,
Query query)
Used to apply search hints on the fully generated SQL (complete of select, from, where, sort,
limit/offset)
|
protected void |
JDBCFeatureReader.init(JDBCFeatureSource featureSource,
SimpleFeatureType featureType,
Query query) |
protected <F extends FilterToSQL> |
JDBCDataStore.initializeFilterToSQL(F toSQL,
SimpleFeatureType featureType)
Helper method to initialize a filter encoder instance.
|
protected void |
JDBCDataStore.insert(Collection<? extends SimpleFeature> 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,
KeysFetcher keysFetcher,
Connection cx)
Generates a 'INSERT INFO' sql 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,
Expression att,
List<Expression> groupByExpressions,
SimpleFeatureType featureType,
Query query,
LimitingVisitor visitor) |
protected PreparedStatement |
JDBCDataStore.selectAggregateSQLPS(String function,
Expression att,
List<Expression> groupByExpressions,
SimpleFeatureType featureType,
Query query,
LimitingVisitor visitor,
Connection cx) |
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.selectJoinSQL(SimpleFeatureType featureType,
JoinInfo join,
Query query) |
protected PreparedStatement |
JDBCDataStore.selectJoinSQLPS(SimpleFeatureType featureType,
JoinInfo join,
Query query,
Connection cx) |
protected String |
JDBCDataStore.selectSQL(SimpleFeatureType featureType,
Query query)
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) |
Filter[] |
SQLDialect.splitFilter(Filter filter,
SimpleFeatureType schema)
Splits the filter into two parts, an encodable one, and a non encodable one.
|
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,
Set<String> pkColumnNames)
Generates an 'UPDATE' sql statement.
|
protected PreparedStatement |
JDBCDataStore.updateSQLPS(SimpleFeatureType featureType,
AttributeDescriptor[] attributes,
Object[] values,
Filter filter,
Set<String> pkColumnNames,
Connection cx)
Generates an 'UPDATE' prepared statement.
|
Modifier and Type | Field and Description |
---|---|
static SimpleFeatureType |
DocumentTypeBinding.FeatureType |
protected static SimpleFeatureType |
FeatureTypeBinding.FeatureType
base feature type for kml features, used when no Schema element is specified
|
static SimpleFeatureType |
FolderTypeBinding.FeatureType |
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
SchemaRegistry.get(SimpleFeatureType featureType) |
SimpleFeatureType |
SchemaRegistry.get(String featureTypeName) |
Modifier and Type | Method and Description |
---|---|
void |
SchemaRegistry.add(String featureTypeName,
SimpleFeatureType featureType) |
SimpleFeatureType |
SchemaRegistry.get(SimpleFeatureType featureType) |
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
Drawer.schema(String name,
String spec)
Create a SimpleFeatureType schema using a type short hand.
|
Modifier and Type | Method and Description |
---|---|
Icon |
DefaultGlyphFactory.icon(SimpleFeatureType schema) |
Icon |
GlyphFactory.icon(SimpleFeatureType schema)
Make a basic representation of the provided FeatureType.
|
static BufferedImage |
Glyph.icon(SimpleFeatureType ft) |
Modifier and Type | Method and Description |
---|---|
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)
|
Modifier and Type | Method and Description |
---|---|
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)
|
Modifier and Type | Method and Description |
---|---|
static SimpleFeatureType |
CoverageUtilities.createFeatureType(GridCoverage2D gc2d,
Class<? extends Geometry> geometryClass)
Creates a
SimpleFeatureType that exposes a coverage as a collections of feature
points, mapping the centre of each pixel as a point plus all the bands as attributes. |
Modifier and Type | Method and Description |
---|---|
static SimpleFeatureType |
TransformProcess.toReShapeFeatureType(SimpleFeatureCollection delegate,
List<TransformProcess.Definition> definitionList) |
Modifier and Type | Method and Description |
---|---|
FeatureReader<SimpleFeatureType,SimpleFeature> |
IndexedFeatureResults.reader() |
FeatureReader<SimpleFeatureType,SimpleFeature> |
IndexedFeatureResults.reader(Envelope envelope) |
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
UserLayerImpl.getInlineFeatureType() |
SimpleFeatureType |
UserLayer.getInlineFeatureType() |
Modifier and Type | Method and Description |
---|---|
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) |
Modifier and Type | Method and Description |
---|---|
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. |
Constructor and Description |
---|
JSimpleStyleDialog(Dialog owner,
SimpleFeatureType schema,
Style initialStyle)
Constructor.
|
JSimpleStyleDialog(Frame owner,
SimpleFeatureType schema,
Style initialStyle)
Constructor.
|
Modifier and Type | Method and Description |
---|---|
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.
|
Modifier and Type | Method and Description |
---|---|
boolean |
SingleValueValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
SingleValueValidation test for feature.
|
boolean |
AttributeValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
Completes the specified comparison.
|
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 |
DomainValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
Validation test for feature.
|
boolean |
RangeValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
Override validate.
|
boolean |
NullZeroValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
Implement validate.
|
boolean |
SQLValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
SQL Validation
|
Modifier and Type | Field and Description |
---|---|
protected SimpleFeatureType |
SpatialTestCase.lineType |
Modifier and Type | Method and Description |
---|---|
static Filter |
OverlapsIntegrity.filterBBox(Envelope bBox,
SimpleFeatureType ft)
Try and Filter by the provided bbox, will default to Filter.EXCLUDE if null
|
Modifier and Type | Method and Description |
---|---|
boolean |
LineMustBeASinglePartValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
Override validate.
|
boolean |
IsValidGeometryValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
Tests to see if a geometry is valid by calling Geometry.isValid().
|
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 |
PolygonNoGapsValidation.validate(SimpleFeature feature,
SimpleFeatureType type,
ValidationResults results)
Ensure Polygon does not have gaps.
|
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
GML.decodeSimpleFeatureType(URL schemaLocation,
Name typeName)
Decode a typeName from the provided schemaLocation.
|
SimpleFeatureType |
CompositeFeatureCollection.getSchema() |
protected SimpleFeatureType |
GML.simpleType(Object obj) |
Modifier and Type | Method and Description |
---|---|
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) |
Constructor and Description |
---|
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.
|
Modifier and Type | Field and Description |
---|---|
protected SimpleFeatureType |
FCBuffer.ft |
Modifier and Type | Method and Description |
---|---|
static SimpleFeatureType |
GMLComplexTypes.createFeatureType(ComplexType element) |
static SimpleFeatureType |
GMLComplexTypes.createFeatureType(Element element) |
SimpleFeatureType |
FCBuffer.getFeatureType()
DOCUMENT ME!
|
Modifier and Type | Method and Description |
---|---|
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) |
Modifier and Type | Method and Description |
---|---|
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) |
Constructor and Description |
---|
FCBuffer(URI document,
int capacity,
int timeout,
SimpleFeatureType ft) |
Modifier and Type | Field and Description |
---|---|
SimpleFeatureType |
SLDInlineFeatureParser.featureType |
Modifier and Type | Method and Description |
---|---|
SimpleFeature |
FeatureFactory.createSimpleFeature(Object[] array,
SimpleFeatureType type,
String id)
Create a SimpleFeature from an array of objects.
|
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
SimpleFeature.getFeatureType()
The type of the feature.
|
SimpleFeatureType |
SimpleFeature.getType()
Override and type narrow to SimpleFeatureType.
|
Modifier and Type | Method and Description |
---|---|
SimpleFeatureType |
FeatureTypeFactory.createSimpleFeatureType(Name name,
List<AttributeDescriptor> schema,
GeometryDescriptor defaultGeometry,
boolean isAbstract,
List<Filter> restrictions,
AttributeType superType,
InternationalString description)
Creates a simple feature type.
|
Copyright © 1996–2019 Geotools. All rights reserved.