Uses of Interface
org.opengis.feature.simple.SimpleFeatureType

Packages that use SimpleFeatureType
org.geotools   
org.geotools.arcsde.data DataStore implementation for the ArcSDE 8.x and 9.x spatial gateway. 
org.geotools.arcsde.filter   
org.geotools.brewer.color   
org.geotools.coverage.grid.io   
org.geotools.data Defines the DataStoreAPI via which all data is imported or exported. 
org.geotools.data.collection Implementations of FeatureCollection for different purposes. 
org.geotools.data.crs Provides support for the OGC Catalog Specification. 
org.geotools.data.db2   
org.geotools.data.directory   
org.geotools.data.gen   
org.geotools.data.h2   
org.geotools.data.jdbc   
org.geotools.data.memory   
org.geotools.data.mysql   
org.geotools.data.oracle   
org.geotools.data.postgis   
org.geotools.data.property   
org.geotools.data.shapefile   
org.geotools.data.simple   
org.geotools.data.sort   
org.geotools.data.spatialite   
org.geotools.data.sqlserver   
org.geotools.data.store   
org.geotools.data.teradata   
org.geotools.data.transform   
org.geotools.data.view   
org.geotools.data.wfs.feature   
org.geotools.data.wfs.protocol.wfs   
org.geotools.data.wfs.v1_0_0   
org.geotools.data.wfs.v1_0_0.gml   
org.geotools.data.wfs.v1_1_0   
org.geotools.data.wfs.v1_1_0.parsers   
org.geotools.feature   
org.geotools.feature.collection Helper classes for implementing FeatureCollections. 
org.geotools.feature.simple   
org.geotools.feature.type   
org.geotools.feature.visitor   
org.geotools.filter   
org.geotools.filter.visitor   
org.geotools.gce.imagemosaic   
org.geotools.gce.imagemosaic.catalog   
org.geotools.gce.imagemosaic.catalog.oracle   
org.geotools.geojson.feature   
org.geotools.geopkg   
org.geotools.gml.producer   
org.geotools.gml2.bindings   
org.geotools.gml3.bindings   
org.geotools.gml4wcs.bindings   
org.geotools.grid   
org.geotools.grid.ortholine   
org.geotools.jdbc   
org.geotools.kml.bindings   
org.geotools.kml.v22   
org.geotools.legend   
org.geotools.process.feature   
org.geotools.renderer.lite A simple renderer implementation. 
org.geotools.styling Allows for symbolization of geospatial data. 
org.geotools.styling.builder   
org.geotools.swing.styling Dialogs to create basic rendering styles. 
org.geotools.swt.styling Dialogs to create basic rendering styles. 
org.geotools.swt.styling.simple   
org.geotools.validation Defines the Validation Processor and Support classes. 
org.geotools.validation.attributes Simple Attribute based Validation implementations. 
org.geotools.validation.relate   
org.geotools.validation.spatial Geometry based Validation implementations. 
org.geotools.wfs   
org.geotools.xml.gml   
org.opengis.feature Representation a features on a map. 
org.opengis.feature.simple Profile of the general ISO 19107 feature model built around the idea of a simple feature composed of a list of values. 
org.opengis.feature.type Feature model ISO 19109 with allowances for usability. 
 

Uses of SimpleFeatureType in org.geotools
 

Methods in org.geotools that return SimpleFeatureType
 SimpleFeatureType GML.decodeSimpleFeatureType(URL schemaLocation, Name typeName)
          Decode a typeName from the provided schemaLocation.
protected  SimpleFeatureType GML.simpleType(Object obj)
           
 

Methods in org.geotools with parameters of type SimpleFeatureType
 void GML.encode(OutputStream out, SimpleFeatureType simpleFeatureType)
          Encode the provided SimpleFeatureType into an XSD file, using a target namespace When encoding the simpleFeatureType: target prefix/namespace can be provided by prefix and namespace parameters.
protected  SimpleFeature GML.simpleFeature(Object obj, SimpleFeatureType schema)
          Morph provided obj to a SimpleFeature if possible.
protected  XSDSchema GML.xsd(SimpleFeatureType simpleFeatureType)
           
 

Uses of SimpleFeatureType in org.geotools.arcsde.data
 

Methods in org.geotools.arcsde.data that return SimpleFeatureType
 SimpleFeatureType ArcSDEDataStore.getQueryType(Query query)
           
 SimpleFeatureType ArcSdeFeatureCollection.getSchema()
           
 SimpleFeatureType ArcSdeFeatureSource.getSchema()
           
 SimpleFeatureType ArcSDEDataStore.getSchema(Name name)
          Delegates to ArcSDEDataStore.getSchema(String) with name.getLocalPart()
 SimpleFeatureType ArcSDEDataStore.getSchema(String typeName)
          Obtains the schema for the given featuretype name.
 

Methods in org.geotools.arcsde.data that return types with arguments of type SimpleFeatureType
 FeatureReader<SimpleFeatureType,SimpleFeature> ArcSDEDataStore.getFeatureReader(Query query, Transaction transaction)
          Returns an ArcSDEFeatureReader Preconditions: query !
 FeatureReader<SimpleFeatureType,SimpleFeature> ArcSDEDataStore.getFeatureReader(Query query, Transaction transaction, SimpleFeatureType featureType)
           
 FeatureReader<SimpleFeatureType,SimpleFeature> ArcSdeFeatureSource.getfeatureReader(SimpleFeatureType targetSchema, Query query)
           
 FeatureReader<SimpleFeatureType,SimpleFeature> ArcSdeFeatureCollection.reader()
           
 

Methods in org.geotools.arcsde.data with parameters of type SimpleFeatureType
 void ArcSDEDataStore.createSchema(SimpleFeatureType featureType)
          Creates a new ArcSDE FeatureClass if featureType has at least one geometry attribute, or an ObjectClass (aka, non spatial registered table) if this data store instance allows non spatial tables and there's no geometry attribute in featureType.
 void ArcSDEDataStore.createSchema(SimpleFeatureType featureType, Map<String,String> hints)
          Creates a given FeatureType on the ArcSDE instance this DataStore is running over.
static void ArcSDEAdapter.createSchema(SimpleFeatureType featureType, Map<String,String> hints, ISession session)
          Creates the given featuretype in the underlying ArcSDE database.
 FeatureReader<SimpleFeatureType,SimpleFeature> ArcSDEDataStore.getFeatureReader(Query query, Transaction transaction, SimpleFeatureType featureType)
           
 FeatureReader<SimpleFeatureType,SimpleFeature> ArcSdeFeatureSource.getfeatureReader(SimpleFeatureType targetSchema, Query query)
           
 String[] FIDReader.getPropertiesToFetch(SimpleFeatureType schema)
          Returns the attribute names of the FeatureType passed to the constructor.
 String[] FIDReader.ShapeFidReader.getPropertiesToFetch(SimpleFeatureType schema)
          Overrides to include the geometry column whether it is required by the schema or not, since we need to get the fid from the geometry id.
 void ArcSDEDataStore.updateSchema(Name typeName, SimpleFeatureType featureType)
          Delegates to ArcSDEDataStore.updateSchema(String, SimpleFeatureType) with name.getLocalPart()
 void ArcSDEDataStore.updateSchema(String typeName, SimpleFeatureType featureType)
          This operation is not supported at this version of the GeoTools ArcSDE plugin.
 

Method parameters in org.geotools.arcsde.data with type arguments of type SimpleFeatureType
 List<FeatureId> ArcSdeFeatureStore.addFeatures(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
           
 void ArcSdeFeatureStore.setFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
           
 

Constructors in org.geotools.arcsde.data with parameters of type SimpleFeatureType
ArcSdeFeatureCollection(ArcSdeFeatureSource featureSource, SimpleFeatureType queryType, Query namedQuery)
           
 

Uses of SimpleFeatureType in org.geotools.arcsde.filter
 

Constructors in org.geotools.arcsde.filter with parameters of type SimpleFeatureType
ArcSdeSimplifyingFilterVisitor(SimpleFeatureType schema)
           
FilterToSQLSDE(String layerQName, String layerFidColName, SimpleFeatureType ft, PlainSelect definitionQuery, ISession session)
           
GeometryEncoderSDE(SeLayer layer, SimpleFeatureType featureType)
           
 

Uses of SimpleFeatureType in org.geotools.brewer.color
 

Methods in org.geotools.brewer.color with parameters of type SimpleFeatureType
static Filter StyleGenerator.toExplicitFilter(String styleExpression, SimpleFeatureType featureType, String attributeTypeName)
           Creates a filter with each value explicitly defined.
static Filter[] StyleGenerator.toFilter(String[] styleExpression, SimpleFeatureType[] featureType, String[] attributeTypeName)
           Converts an array of styleExpressions and attributes into Filters styleExpression[0] = "1..5";
styleExpression[1] = "5..10";
styleExpression[2] = "11, -13";
--->
filter[0] = [[1 <= attr] AND [attr < 5]]
filter[1] = [[6 <= attr] AND [attr <= 10]]
filter[2] = [[attr = 11] OR [attr = -13]]
static Filter StyleGenerator.toRangedFilter(String styleExpression, SimpleFeatureType featureType, String attributeTypeName, boolean upperBoundClosed)
           Creates a filter for a range of values.
 

Uses of SimpleFeatureType in org.geotools.coverage.grid.io
 

Methods in org.geotools.coverage.grid.io that return SimpleFeatureType
 SimpleFeatureType GranuleSource.getSchema()
          Retrieves the schema (feature type) that will apply to granules retrieved from this GranuleSource.
 

Methods in org.geotools.coverage.grid.io with parameters of type SimpleFeatureType
 void StructuredGridCoverage2DReader.createCoverage(String coverageName, SimpleFeatureType schema)
          Creates a granule store for a new coverage with the given feature type
 

Uses of SimpleFeatureType in org.geotools.data
 

Fields in org.geotools.data declared as SimpleFeatureType
protected  SimpleFeatureType DataTestCase.lakeType
           
protected  SimpleFeatureType DataTestCase.riverType
           
protected  SimpleFeatureType DataTestCase.roadType
           
protected  SimpleFeatureType DataTestCase.subRiverType
           
protected  SimpleFeatureType DataTestCase.subRoadType
           
 

Fields in org.geotools.data with type parameters of type SimpleFeatureType
protected  FeatureReader<SimpleFeatureType,SimpleFeature> DiffFeatureWriter.reader
           
 

Methods in org.geotools.data that return SimpleFeatureType
protected  SimpleFeatureType DefaultFeatureReader.createSchema()
           
protected  SimpleFeatureType FIDFeatureReader.createSchema()
           
static SimpleFeatureType DataUtilities.createSubType(SimpleFeatureType featureType, String[] properties)
          Create a type limited to the named properties provided.
static SimpleFeatureType DataUtilities.createSubType(SimpleFeatureType featureType, String[] properties, CoordinateReferenceSystem override)
          Create a derived FeatureType
static SimpleFeatureType DataUtilities.createSubType(SimpleFeatureType featureType, String[] properties, CoordinateReferenceSystem override, String typeName, URI namespace)
           
static SimpleFeatureType DataUtilities.createType(String typeName, String typeSpec)
          Utility method for FeatureType construction.
static SimpleFeatureType DataUtilities.createType(String namespace, String name, String typeSpec)
          Utility method for FeatureType construction.
 SimpleFeatureType DefaultFeatureReader.getFeatureType()
           
 SimpleFeatureType EmptyFeatureWriter.getFeatureType()
           
 SimpleFeatureType FilteringFeatureWriter.getFeatureType()
           
 SimpleFeatureType DiffFeatureWriter.getFeatureType()
          Supplys FeatureTypeFrom reader
 SimpleFeatureType ReTypeFeatureReader.getFeatureType()
           
 SimpleFeatureType FIDFeatureReader.getFeatureType()
           
 SimpleFeatureType CollectionFeatureReader.getFeatureType()
           
 SimpleFeatureType CachingFeatureSource.getSchema()
          Deprecated.  
 SimpleFeatureType AbstractFileDataStore.getSchema()
          Singular version, returns the FeatureType for the url being read.
 SimpleFeatureType DefaultFeatureResults.getSchema()
          FeatureSchema for provided query.
 SimpleFeatureType FileDataStore.getSchema()
          FeatureType for the file being read.
 SimpleFeatureType AbstractDataStore.getSchema(Name name)
          Delegates to AbstractDataStore.getSchema(String) with name.getLocalPart()
abstract  SimpleFeatureType AbstractDataStore.getSchema(String typeName)
          Retrive schema information for typeName
 SimpleFeatureType DataStore.getSchema(String typeName)
          Gets the type information (schema) for the specified feature type.
static SimpleFeatureType DataUtilities.simple(FeatureType featureType)
          Go through FeatureType description and convert to a SimpleFeatureType.
 

Methods in org.geotools.data that return types with arguments of type SimpleFeatureType
protected  FeatureReader<SimpleFeatureType,SimpleFeature> DefaultFeatureResults.boundsReader()
          Retrieve a FeatureReader for the geometry attributes only, designed for bounds computation
 FeatureWriter<SimpleFeatureType,SimpleFeature> InProcessLockingManager.checkedWriter(FeatureWriter<SimpleFeatureType,SimpleFeature> writer, Transaction transaction)
          Provides a wrapper on the provided writer that checks locks.
protected  FeatureWriter<SimpleFeatureType,SimpleFeature> AbstractDataStore.createFeatureWriter(String typeName, Transaction transaction)
          Subclass should implement this to provide writing support.
 FeatureReader<SimpleFeatureType,SimpleFeature> AbstractFileDataStore.getFeatureReader()
          Singular version, which must be implemented to represent a Reader for the url being read.
 FeatureReader<SimpleFeatureType,SimpleFeature> FileDataStore.getFeatureReader()
           
 FeatureReader<SimpleFeatureType,SimpleFeature> AbstractDataStore.getFeatureReader(Query query, Transaction transaction)
           
 FeatureReader<SimpleFeatureType,SimpleFeature> DataStore.getFeatureReader(Query query, Transaction transaction)
          Gets a FeatureReader for features selected by the given Query.
protected abstract  FeatureReader<SimpleFeatureType,SimpleFeature> AbstractDataStore.getFeatureReader(String typeName)
          Subclass must implement.
protected  FeatureReader<SimpleFeatureType,SimpleFeature> AbstractDataStore.getFeatureReader(String typeName, Query query)
          GR: this method is called from inside getFeatureReader(Query ,Transaction ) to allow subclasses return an optimized FeatureReader wich supports the filter and attributes truncation specified in query A subclass that supports the creation of such an optimized FeatureReader shold override this method.
 FeatureWriter<SimpleFeatureType,SimpleFeature> AbstractFileDataStore.getFeatureWriter(Filter filter, Transaction transaction)
          Singular version, calls parent with getSchema().getTypeName()
 FeatureWriter<SimpleFeatureType,SimpleFeature> FileDataStore.getFeatureWriter(Filter filter, Transaction transaction)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> AbstractDataStore.getFeatureWriter(String typeName, Filter filter, Transaction transaction)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> DataStore.getFeatureWriter(String typeName, Filter filter, Transaction transaction)
          Gets a FeatureWriter to modify features in this DataStore.
 FeatureWriter<SimpleFeatureType,SimpleFeature> AbstractDataStore.getFeatureWriter(String typeName, Transaction transaction)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> DataStore.getFeatureWriter(String typeName, Transaction transaction)
          Gets a FeatureWriter to modify features in this DataStore.
 FeatureWriter<SimpleFeatureType,SimpleFeature> AbstractFileDataStore.getFeatureWriter(Transaction transaction)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> FileDataStore.getFeatureWriter(Transaction transaction)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> AbstractDataStore.getFeatureWriterAppend(String typeName, Transaction transaction)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> DataStore.getFeatureWriterAppend(String typeName, Transaction transaction)
          Gets a FeatureWriter that can add new features to the DataStore.
 FeatureWriter<SimpleFeatureType,SimpleFeature> AbstractFileDataStore.getFeatureWriterAppend(Transaction transaction)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> FileDataStore.getFeatureWriterAppend(Transaction transaction)
           
 FeatureReader<SimpleFeatureType,SimpleFeature> DefaultFeatureResults.reader()
          Retrieve a FeatureReader for this Query
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 for testing.
 FeatureReader<SimpleFeatureType,SimpleFeature> TransactionStateDiff.reader(String typeName)
          Convience Method for a Transaction based FeatureReader.
 FeatureWriter<SimpleFeatureType,SimpleFeature> TransactionStateDiff.writer(String typeName, Filter filter)
          Convience Method for a Transaction based FeatureWriter Constructs a DiffFeatureWriter that works against this Transaction.
 

Methods in org.geotools.data with parameters of type SimpleFeatureType
static List<PropertyName> DataUtilities.addMandatoryProperties(SimpleFeatureType type, List<PropertyName> oldProps)
          Returns a list of properties of a simple feature type, including all properties from a given list, and all mandatory (minoccurs > 0) added.
static String[] DataUtilities.attributeNames(Expression expression, SimpleFeatureType featureType)
          Traverses the expression and returns any encountered property names.
static String[] DataUtilities.attributeNames(Filter filter, SimpleFeatureType featureType)
          Traverses the filter and returns any encountered property names.
static String[] DataUtilities.attributeNames(SimpleFeatureType featureType)
          Retrieve the attributeNames defined by the featureType
static int DataUtilities.compare(SimpleFeatureType typeA, SimpleFeatureType typeB)
          Compare attribute coverage between two feature types (allowing the identification of subTypes).
static SimpleFeature DataUtilities.createFeature(SimpleFeatureType featureType, String line)
          Reads in SimpleFeature that has been encoded into a line of text.
 void AbstractDataStore.createSchema(SimpleFeatureType featureType)
          Subclass should implement to provide writing support.
static SimpleFeatureType DataUtilities.createSubType(SimpleFeatureType featureType, String[] properties)
          Create a type limited to the named properties provided.
static SimpleFeatureType DataUtilities.createSubType(SimpleFeatureType featureType, String[] properties, CoordinateReferenceSystem override)
          Create a derived FeatureType
static SimpleFeatureType DataUtilities.createSubType(SimpleFeatureType featureType, String[] properties, CoordinateReferenceSystem override, String typeName, URI namespace)
           
static Object[] DataUtilities.defaultValues(SimpleFeatureType featureType)
          Produce a set of default values for the provided FeatureType
static Object[] DataUtilities.defaultValues(SimpleFeatureType featureType, Object[] values)
          Create default values matching the provided feature type.
static String DataUtilities.encodeType(SimpleFeatureType featureType)
          Encode the provided featureType as a String suitable for use with DataUtilities.createType(java.lang.String, java.lang.String).
static SimpleFeature DataUtilities.parse(SimpleFeatureType type, String fid, String[] text)
          Uses Converters to parse the provided text into the correct values to create a feature.
static Set<PropertyName> DataUtilities.propertyNames(Expression expression, SimpleFeatureType featureType)
          Traverses the expression and returns any encountered property names.
static Set<PropertyName> DataUtilities.propertyNames(Filter filter, SimpleFeatureType featureType)
          Traverses the filter and returns any encountered property names.
static Filter DataUtilities.resolvePropertyNames(Filter filter, SimpleFeatureType schema)
          Transform provided filter; resolving property names
static Query DataUtilities.resolvePropertyNames(Query query, SimpleFeatureType schema)
          This method changes the query object so that all propertyName references are resolved to simple attribute names against the schema of the feature source.
static SimpleFeature CachingFeatureSource.reType(SimpleFeatureType featureType, SimpleFeature feature)
          Deprecated. Same as DataUtilities.reType, but without the cloning that uselessly wastes CPU cycles...
static SimpleFeature DataUtilities.reType(SimpleFeatureType featureType, SimpleFeature feature)
          Creates duplicate of feature adjusted to the provided featureType.
static SimpleFeature DataUtilities.reType(SimpleFeatureType featureType, SimpleFeature feature, boolean duplicate)
          Retypes the feature to match the provided featureType.
static SimpleFeature DataUtilities.template(SimpleFeatureType featureType)
          Constructs an empty feature to use as a Template for new content.
static SimpleFeature DataUtilities.template(SimpleFeatureType featureType, Object[] providedValues)
          Create a new feature from the provided values, using appropriate default values for any nulls provided.
static SimpleFeature DataUtilities.template(SimpleFeatureType featureType, String featureID)
          Use the provided featureType to create an empty feature.
static SimpleFeature DataUtilities.template(SimpleFeatureType featureType, String featureID, Object[] providedValues)
          Create a new feature from the provided values, using appropriate default values for any nulls provided.
protected  AttributeDescriptor[] ReTypeFeatureReader.typeAttributes(SimpleFeatureType target, SimpleFeatureType origional)
          Supplies mapping from original to target FeatureType.
 void AbstractDataStore.updateSchema(Name typeName, SimpleFeatureType featureType)
          Delegates to AbstractDataStore.updateSchema(String, SimpleFeatureType) with name.getLocalPart()
 void AbstractFileDataStore.updateSchema(SimpleFeatureType featureType)
          Singular version, calls parent with getSchema().getTypeName()
 void FileDataStore.updateSchema(SimpleFeatureType featureType)
           
 void AbstractDataStore.updateSchema(String typeName, SimpleFeatureType featureType)
           
 void DataStore.updateSchema(String typeName, SimpleFeatureType featureType)
          Applies a new schema to the given feature type.
 

Method parameters in org.geotools.data with type arguments of type SimpleFeatureType
 List<FeatureId> AbstractFeatureStore.addFeatures(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
           
 Set<String> AbstractFeatureStore.addFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
          Add Features from reader to this FeatureStore.
 FeatureWriter<SimpleFeatureType,SimpleFeature> InProcessLockingManager.checkedWriter(FeatureWriter<SimpleFeatureType,SimpleFeature> writer, Transaction transaction)
          Provides a wrapper on the provided writer that checks locks.
static DefaultFeatureCollection DataUtilities.collection(FeatureCollection<SimpleFeatureType,SimpleFeature> featureCollection)
          Copies the provided features into a FeatureCollection.
static SimpleFeatureCollection DataUtilities.collection(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
          Copies the provided reader into a FeatureCollection, reader will be closed.
protected  int DataTestCase.count(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
          Counts the number of Features returned by the specified reader.
protected  int DataTestCase.count(FeatureWriter<SimpleFeatureType,SimpleFeature> writer)
          Counts the number of Features in the specified writer.
static FeatureReader<SimpleFeatureType,SimpleFeature> DataUtilities.reader(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
          Adapt a collection to a reader for use with FeatureStore.setFeatures( reader ).
 void AbstractFeatureStore.setFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
          Replace with contents of reader.
static SimpleFeatureCollection DataUtilities.simple(FeatureCollection<SimpleFeatureType,SimpleFeature> featureCollection)
          A safe cast to SimpleFeatureCollection; that will introduce a wrapper if it has to.
static SimpleFeatureReader DataUtilities.simple(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
           
static SimpleFeatureSource DataUtilities.source(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
          Wraps up the provided feature collection in as a SimpleFeatureSource.
 

Constructors in org.geotools.data with parameters of type SimpleFeatureType
CollectionFeatureReader(Collection<SimpleFeature> featuresArg, SimpleFeatureType typeArg)
          Create a new instance.
CollectionFeatureReader(SimpleFeatureCollection featuresArg, SimpleFeatureType typeArg)
          Create a new instance.
DefaultFeatureReader(AttributeReader attributeReader, SimpleFeatureType schema)
          Creates a new instance of AbstractFeatureReader
DefaultFIDReader(SimpleFeatureType featureType)
           
EmptyFeatureWriter(SimpleFeatureType featureType)
          An Empty FeatureWriter of the provided featureType.
FIDFeatureReader(AttributeReader attributeReader, FIDReader fidReader, SimpleFeatureType schema)
          Creates a new instance of AbstractFeatureReader
ReTypeFeatureReader(FeatureReader<SimpleFeatureType,SimpleFeature> reader, SimpleFeatureType featureType)
          Constructs a FetureReader that will ReType streaming content.
ReTypeFeatureReader(FeatureReader<SimpleFeatureType,SimpleFeature> reader, SimpleFeatureType featureType, boolean clone)
          Constructs a FetureReader that will ReType streaming content.
 

Constructor parameters in org.geotools.data with type arguments of type SimpleFeatureType
DiffFeatureWriter(FeatureReader<SimpleFeatureType,SimpleFeature> reader, Diff diff)
          DiffFeatureWriter construction.
DiffFeatureWriter(FeatureReader<SimpleFeatureType,SimpleFeature> reader, Diff diff, Filter filter)
          DiffFeatureWriter construction.
FilteringFeatureWriter(FeatureWriter<SimpleFeatureType,SimpleFeature> writer, Filter filter)
           
ReTypeFeatureReader(FeatureReader<SimpleFeatureType,SimpleFeature> reader, SimpleFeatureType featureType)
          Constructs a FetureReader that will ReType streaming content.
ReTypeFeatureReader(FeatureReader<SimpleFeatureType,SimpleFeature> reader, SimpleFeatureType featureType, boolean clone)
          Constructs a FetureReader that will ReType streaming content.
 

Uses of SimpleFeatureType in org.geotools.data.collection
 

Fields in org.geotools.data.collection declared as SimpleFeatureType
protected  SimpleFeatureType SpatialIndexFeatureCollection.schema
           
protected  SimpleFeatureType TreeSetFeatureCollection.schema
          FeatureType of contents.
 

Methods in org.geotools.data.collection that return SimpleFeatureType
 SimpleFeatureType CollectionFeatureSource.getSchema()
           
 SimpleFeatureType SpatialIndexFeatureCollection.getSchema()
           
 SimpleFeatureType TreeSetFeatureCollection.getSchema()
           
 SimpleFeatureType SpatialIndexFeatureSource.getSchema()
           
 SimpleFeatureType CollectionDataStore.getSchema(String typeName)
           
 

Methods in org.geotools.data.collection that return types with arguments of type SimpleFeatureType
 FeatureCollection<SimpleFeatureType,SimpleFeature> CollectionDataStore.getCollection()
          Returns the feature collection held by this data store
 DataAccess<SimpleFeatureType,SimpleFeature> CollectionFeatureSource.getDataStore()
           
 FeatureReader<SimpleFeatureType,SimpleFeature> CollectionDataStore.getFeatureReader(String typeName)
          Provides FeatureReader over the entire contents of typeName.
 FeatureReader<SimpleFeatureType,SimpleFeature> TreeSetFeatureCollection.reader()
           
 

Method parameters in org.geotools.data.collection with type arguments of type SimpleFeatureType
 boolean SpatialIndexFeatureCollection.addAll(FeatureCollection<? extends SimpleFeatureType,? extends SimpleFeature> collection)
           
 

Constructors in org.geotools.data.collection with parameters of type SimpleFeatureType
CollectionDataStore(SimpleFeatureType schema)
          Builds a data store wrapper around an empty collection.
ListFeatureCollection(SimpleFeatureType schema)
          Create a ListFeatureCollection for the provided schema An ArrayList is used internally.
ListFeatureCollection(SimpleFeatureType schema, List<SimpleFeature> list)
          Create a ListFeatureCollection around the provided list.
SpatialIndexFeatureCollection(SimpleFeatureType schema)
           
TreeSetFeatureCollection(String id, SimpleFeatureType memberType)
          This constructor should not be used by client code.
 

Constructor parameters in org.geotools.data.collection with type arguments of type SimpleFeatureType
CollectionDataStore(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
          Builds a data store wrapper on top of a feature collection
TreeSetFeatureCollection(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
          This constructor should not be used by client code.
 

Uses of SimpleFeatureType in org.geotools.data.crs
 

Fields in org.geotools.data.crs with type parameters of type SimpleFeatureType
protected  FeatureReader<SimpleFeatureType,SimpleFeature> ForceCoordinateSystemFeatureReader.reader
           
 

Methods in org.geotools.data.crs that return SimpleFeatureType
 SimpleFeatureType ReprojectFeatureReader.getFeatureType()
          Implement getFeatureType.
 SimpleFeatureType ForceCoordinateSystemFeatureReader.getFeatureType()
           
 SimpleFeatureType ReprojectFeatureIterator.getFeatureType()
          Implement getFeatureType.
 SimpleFeatureType ForceCoordinateSystemIterator.getFeatureType()
           
 

Methods in org.geotools.data.crs that return types with arguments of type SimpleFeatureType
 FeatureReader<SimpleFeatureType,SimpleFeature> ReprojectFeatureReader.getDelegate()
           
 FeatureCollection<SimpleFeatureType,SimpleFeature> ForceCoordinateSystemFeatureResults.getOrigin()
          Returns the feature results wrapped by this ForceCoordinateSystemFeatureResults
 FeatureCollection<SimpleFeatureType,SimpleFeature> ReprojectFeatureResults.getOrigin()
          Returns the feature results wrapped by this reprojecting feature results
 

Constructors in org.geotools.data.crs with parameters of type SimpleFeatureType
ForceCoordinateSystemIterator(FeatureIterator<SimpleFeature> reader, SimpleFeatureType type, CoordinateReferenceSystem cs)
          Builds a new ForceCoordinateSystemFeatureReader
ReprojectFeatureIterator(FeatureIterator<SimpleFeature> reader, SimpleFeatureType schema, MathTransform transform)
           
ReprojectFeatureReader(FeatureReader<SimpleFeatureType,SimpleFeature> reader, SimpleFeatureType schema, MathTransform transform)
          Direct constructor reprojecting the provided reader into the schema indicated (using the supplied math transformation).
 

Constructor parameters in org.geotools.data.crs with type arguments of type SimpleFeatureType
ForceCoordinateSystemFeatureReader(FeatureReader<SimpleFeatureType,SimpleFeature> reader, CoordinateReferenceSystem cs)
          Builds a new ForceCoordinateSystemFeatureReader
ForceCoordinateSystemFeatureReader(FeatureReader<SimpleFeatureType,SimpleFeature> reader, CoordinateReferenceSystem cs, boolean forceOnlyMissing)
          Builds a new ForceCoordinateSystemFeatureReader
ForceCoordinateSystemFeatureResults(FeatureCollection<SimpleFeatureType,SimpleFeature> results, CoordinateReferenceSystem forcedCS)
           
ForceCoordinateSystemFeatureResults(FeatureCollection<SimpleFeatureType,SimpleFeature> results, CoordinateReferenceSystem forcedCS, boolean forceOnlyMissing)
           
ReprojectFeatureReader(FeatureReader<SimpleFeatureType,SimpleFeature> reader, CoordinateReferenceSystem cs)
          Constructor that will generate schema and mathTransform for the results.
ReprojectFeatureReader(FeatureReader<SimpleFeatureType,SimpleFeature> reader, SimpleFeatureType schema, MathTransform transform)
          Direct constructor reprojecting the provided reader into the schema indicated (using the supplied math transformation).
ReprojectFeatureResults(FeatureCollection<SimpleFeatureType,SimpleFeature> results, CoordinateReferenceSystem destinationCS)
          Creates a new reprojecting feature results
 

Uses of SimpleFeatureType in org.geotools.data.db2
 

Methods in org.geotools.data.db2 with parameters of type SimpleFeatureType
 List<ReferencedEnvelope> DB2SQLDialect.getOptimizedBounds(String schema, SimpleFeatureType featureType, Connection cx)
          Since DB2 V10.
 List<ReferencedEnvelope> DB2SQLDialectPrepared.getOptimizedBounds(String schema, SimpleFeatureType featureType, Connection cx)
           
 List<ReferencedEnvelope> DB2SQLDialectBasic.getOptimizedBounds(String schema, SimpleFeatureType featureType, Connection cx)
           
 void DB2SQLDialect.postCreateTable(String schemaName, SimpleFeatureType featureType, Connection cx)
           
 void DB2SQLDialectPrepared.postCreateTable(String schemaName, SimpleFeatureType featureType, Connection cx)
           
 void DB2SQLDialectBasic.postCreateTable(String schemaName, SimpleFeatureType featureType, Connection cx)
           
 

Uses of SimpleFeatureType in org.geotools.data.directory
 

Methods in org.geotools.data.directory that return SimpleFeatureType
 SimpleFeatureType DirectoryFeatureSource.getSchema()
           
 SimpleFeatureType DirectoryDataStore.getSchema(Name name)
           
 SimpleFeatureType DirectoryDataStore.getSchema(String typeName)
           
 

Methods in org.geotools.data.directory that return types with arguments of type SimpleFeatureType
 DataAccess<SimpleFeatureType,SimpleFeature> DirectoryFeatureSource.getDataStore()
           
 FeatureReader<SimpleFeatureType,SimpleFeature> DirectoryDataStore.getFeatureReader(Query query, Transaction transaction)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> DirectoryDataStore.getFeatureWriter(String typeName, Filter filter, Transaction transaction)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> DirectoryDataStore.getFeatureWriter(String typeName, Transaction transaction)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> DirectoryDataStore.getFeatureWriterAppend(String typeName, Transaction transaction)
           
 

Methods in org.geotools.data.directory with parameters of type SimpleFeatureType
 void DirectoryDataStore.createSchema(SimpleFeatureType featureType)
           
 void DirectoryDataStore.updateSchema(Name typeName, SimpleFeatureType featureType)
           
 void DirectoryDataStore.updateSchema(String typeName, SimpleFeatureType featureType)
           
 

Method parameters in org.geotools.data.directory with type arguments of type SimpleFeatureType
 void DirectoryFeatureStore.setFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
           
 

Uses of SimpleFeatureType in org.geotools.data.gen
 

Fields in org.geotools.data.gen declared as SimpleFeatureType
protected  SimpleFeatureType PreGeneralizedFeatureIterator.featureTyp
           
protected  SimpleFeatureType PreGeneralizedFeatureReader.featureTyp
           
protected  SimpleFeatureType PreGeneralizedFeatureCollection.featureType
           
 

Fields in org.geotools.data.gen with type parameters of type SimpleFeatureType
protected  FeatureReader<SimpleFeatureType,SimpleFeature> PreGeneralizedFeatureReader.backendReader
           
 

Methods in org.geotools.data.gen that return SimpleFeatureType
 SimpleFeatureType PreGeneralizedSimpleFeature.getFeatureType()
           
 SimpleFeatureType PreGeneralizedFeatureReader.getFeatureType()
           
 SimpleFeatureType PreGeneralizedFeatureSource.getSchema()
           
 SimpleFeatureType PreGeneralizedFeatureCollection.getSchema()
           
 SimpleFeatureType PreGeneralizedDataStore.getSchema(Name name)
           
 SimpleFeatureType PreGeneralizedDataStore.getSchema(String typeName)
           
 SimpleFeatureType PreGeneralizedSimpleFeature.getType()
           
 

Methods in org.geotools.data.gen that return types with arguments of type SimpleFeatureType
 DataAccess<SimpleFeatureType,SimpleFeature> PreGeneralizedFeatureSource.getDataStore()
           
 FeatureReader<SimpleFeatureType,SimpleFeature> PreGeneralizedDataStore.getFeatureReader(Query query, Transaction transaction)
           
 FeatureReader<SimpleFeatureType,SimpleFeature> PreGeneralizedFeatureSource.getFeatureReader(Query query, Transaction transaction)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> PreGeneralizedDataStore.getFeatureWriter(String typeName, Filter filter, Transaction transaction)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> PreGeneralizedDataStore.getFeatureWriter(String typeName, Transaction transaction)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> PreGeneralizedDataStore.getFeatureWriterAppend(String typeName, Transaction transaction)
           
 

Methods in org.geotools.data.gen with parameters of type SimpleFeatureType
 void PreGeneralizedDataStore.createSchema(SimpleFeatureType featureType)
           
 void PreGeneralizedDataStore.updateSchema(Name typeName, SimpleFeatureType featureType)
           
 void PreGeneralizedDataStore.updateSchema(String typeName, SimpleFeatureType featureType)
           
 

Constructors in org.geotools.data.gen with parameters of type SimpleFeatureType
PreGeneralizedFeatureCollection(SimpleFeatureCollection backendCollection, SimpleFeatureType featureType, int[] indexMapping, String geomPropertyName, String backendGeomPropertyName)
           
PreGeneralizedFeatureIterator(SimpleFeatureIterator backendIterator, SimpleFeatureType featureTyp, int[] indexMapping, String geomPropertyName, String backendGeomPropertyName)
           
PreGeneralizedFeatureReader(SimpleFeatureType featureTyp, int[] indexMapping, FeatureReader<SimpleFeatureType,SimpleFeature> backendReader, String geomPropertyName, String backendGeomPropertyName)
           
PreGeneralizedSimpleFeature(SimpleFeatureType featureTyp, int[] indexMapping, SimpleFeature feature, String geomPropertyName, String backendGeomPropertyName)
           
 

Constructor parameters in org.geotools.data.gen with type arguments of type SimpleFeatureType
PreGeneralizedFeatureReader(SimpleFeatureType featureTyp, int[] indexMapping, FeatureReader<SimpleFeatureType,SimpleFeature> backendReader, String geomPropertyName, String backendGeomPropertyName)
           
 

Uses of SimpleFeatureType in org.geotools.data.h2
 

Methods in org.geotools.data.h2 with parameters of type SimpleFeatureType
 void H2DialectBasic.postCreateFeatureType(SimpleFeatureType featureType, DatabaseMetaData metadata, String schemaName, Connection cx)
           
 void H2Dialect.postCreateFeatureType(SimpleFeatureType featureType, DatabaseMetaData metadata, String schemaName, Connection cx)
           
 void H2DialectPrepared.postCreateFeatureType(SimpleFeatureType featureType, DatabaseMetaData metadata, String schemaName, Connection cx)
           
 void H2DialectBasic.postCreateTable(String schemaName, SimpleFeatureType featureType, Connection cx)
           
 void H2Dialect.postCreateTable(String schemaName, SimpleFeatureType featureType, Connection cx)
           
 void H2DialectPrepared.postCreateTable(String schemaName, SimpleFeatureType featureType, Connection cx)
           
 

Uses of SimpleFeatureType in org.geotools.data.jdbc
 

Fields in org.geotools.data.jdbc declared as SimpleFeatureType
protected  SimpleFeatureType FilterToSQL.featureType
          the schmema the encoder will be used to be encode sql for
 

Methods in org.geotools.data.jdbc with parameters of type SimpleFeatureType
 void FilterToSQL.setFeatureType(SimpleFeatureType featureType)
          Sets the featuretype the encoder is encoding sql for.
 

Uses of SimpleFeatureType in org.geotools.data.memory
 

Fields in org.geotools.data.memory with type parameters of type SimpleFeatureType
protected  Map<String,SimpleFeatureType> MemoryDataStore.schema
          Schema holds FeatureType by typeName
 

Methods in org.geotools.data.memory that return SimpleFeatureType
 SimpleFeatureType MemoryDataStore.getSchema(String typeName)
          SimpleFeatureType access by typeName.
 

Methods in org.geotools.data.memory that return types with arguments of type SimpleFeatureType
 FeatureWriter<SimpleFeatureType,SimpleFeature> MemoryDataStore.createFeatureWriter(String typeName, Transaction transaction)
          Provides FeatureWriter over the entire contents of typeName.
 FeatureReader<SimpleFeatureType,SimpleFeature> MemoryDataStore.getFeatureReader(String typeName)
          Provides FeatureReader over the entire contents of typeName.
 

Methods in org.geotools.data.memory with parameters of type SimpleFeatureType
 void MemoryDataStore.createSchema(SimpleFeatureType featureType)
          Adds support for a new featureType to MemoryDataStore.
 

Method parameters in org.geotools.data.memory with type arguments of type SimpleFeatureType
 void MemoryDataStore.addFeatures(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
           
 void MemoryDataStore.addFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
          Configures MemoryDataStore with FeatureReader.
 

Constructors in org.geotools.data.memory with parameters of type SimpleFeatureType
MemoryDataStore(SimpleFeatureType featureType)
          Construct an MemoryDataStore around an empty collection of the provided SimpleFeatureType
MemoryFeatureCollection(SimpleFeatureType schema)
           
 

Constructor parameters in org.geotools.data.memory with type arguments of type SimpleFeatureType
MemoryDataStore(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
           
MemoryDataStore(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
           
 

Uses of SimpleFeatureType in org.geotools.data.mysql
 

Methods in org.geotools.data.mysql with parameters of type SimpleFeatureType
 void MySQLDialectPrepared.postCreateTable(String schemaName, SimpleFeatureType featureType, Connection cx)
           
 void MySQLDialect.postCreateTable(String schemaName, SimpleFeatureType featureType, Connection cx)
           
 void MySQLDialectBasic.postCreateTable(String schemaName, SimpleFeatureType featureType, Connection cx)
           
 

Uses of SimpleFeatureType in org.geotools.data.oracle
 

Methods in org.geotools.data.oracle with parameters of type SimpleFeatureType
 List<ReferencedEnvelope> OracleDialect.getOptimizedBounds(String schema, SimpleFeatureType featureType, Connection cx)
           
 void OracleDialect.postCreateTable(String schemaName, SimpleFeatureType featureType, Connection cx)
           
 

Uses of SimpleFeatureType in org.geotools.data.postgis
 

Methods in org.geotools.data.postgis with parameters of type SimpleFeatureType
 List<ReferencedEnvelope> PostGISDialect.getOptimizedBounds(String schema, SimpleFeatureType featureType, Connection cx)
           
 void PostGISDialect.postCreateTable(String schemaName, SimpleFeatureType featureType, Connection cx)
          Creates GEOMETRY_COLUMN registrations and spatial indexes for all geometry columns
 void PostGISPSDialect.postCreateTable(String schemaName, SimpleFeatureType featureType, Connection cx)
           
 

Uses of SimpleFeatureType in org.geotools.data.property
 

Methods in org.geotools.data.property that return SimpleFeatureType
 SimpleFeatureType PropertyFeatureWriter.getFeatureType()
           
 SimpleFeatureType PropertyFeatureReader.getFeatureType()
          DOCUMENT ME!
 SimpleFeatureType PropertyFeatureSource.getSchema()
           
 SimpleFeatureType PropertyFeatureStore.getSchema()
           
 SimpleFeatureType PropertyDataStore.getSchema(String typeName)
           
 

Methods in org.geotools.data.property that return types with arguments of type SimpleFeatureType
protected  FeatureWriter<SimpleFeatureType,SimpleFeature> PropertyDataStore.createFeatureWriter(String typeName, Transaction transaction)
           
protected  FeatureReader<SimpleFeatureType,SimpleFeature> PropertyDataStore.getFeatureReader(String typeName)
           
 

Methods in org.geotools.data.property with parameters of type SimpleFeatureType
 void PropertyDataStore.createSchema(SimpleFeatureType featureType)
           
 

Constructors in org.geotools.data.property with parameters of type SimpleFeatureType
PropertyAttributeWriter(File file, SimpleFeatureType featureType)
           
 

Uses of SimpleFeatureType in org.geotools.data.shapefile
 

Methods in org.geotools.data.shapefile that return SimpleFeatureType
 SimpleFeatureType ShapefileDataStore.getSchema()
           
 

Methods in org.geotools.data.shapefile that return types with arguments of type SimpleFeatureType
 FeatureReader<SimpleFeatureType,SimpleFeature> ShapefileDataStore.getFeatureReader()
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> ShapefileDataStore.getFeatureWriter(Filter filter, Transaction transaction)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> ShapefileDataStore.getFeatureWriter(Transaction transaction)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> ShapefileDataStore.getFeatureWriterAppend(Transaction transaction)
           
 

Methods in org.geotools.data.shapefile with parameters of type SimpleFeatureType
protected static DbaseFileHeader ShapefileDataStore.createDbaseHeader(SimpleFeatureType featureType)
          Attempt to create a DbaseFileHeader for the FeatureType.
 void ShapefileDataStore.createSchema(SimpleFeatureType featureType)
          Set the FeatureType of this DataStore.
 void ShapefileDataStore.updateSchema(SimpleFeatureType featureType)
           
 

Uses of SimpleFeatureType in org.geotools.data.simple
 

Constructors in org.geotools.data.simple with parameters of type SimpleFeatureType
DelegateSimpleFeatureReader(SimpleFeatureType featureType, SimpleFeatureIterator features)
           
EmptySimpleFeatureReader(SimpleFeatureType featureType)
           
 

Uses of SimpleFeatureType in org.geotools.data.sort
 

Methods in org.geotools.data.sort that return SimpleFeatureType
 SimpleFeatureType SortedFeatureReader.getFeatureType()
           
 

Methods in org.geotools.data.sort with parameters of type SimpleFeatureType
static boolean SortedFeatureIterator.canSort(SimpleFeatureType schema, SortBy[] sortBy)
          Checks if the schema and the sortBy are suitable for merge/sort.
static boolean SortedFeatureReader.canSort(SimpleFeatureType schema, SortBy[] sortBy)
          Checks if the schema and the sortBy are suitable for merge/sort.
 

Constructors in org.geotools.data.sort with parameters of type SimpleFeatureType
SortedFeatureIterator(SimpleFeatureIterator iterator, SimpleFeatureType schema, SortBy[] sortBy, int maxFeatures)
          Builds a new sorting feature iterator
 

Uses of SimpleFeatureType in org.geotools.data.spatialite
 

Methods in org.geotools.data.spatialite with parameters of type SimpleFeatureType
 void SpatiaLiteDialect.postCreateFeatureType(SimpleFeatureType featureType, DatabaseMetaData metadata, String schemaName, Connection cx)
           
 void SpatiaLiteDialect.postCreateTable(String schemaName, SimpleFeatureType featureType, Connection cx)
           
 

Uses of SimpleFeatureType in org.geotools.data.sqlserver
 

Methods in org.geotools.data.sqlserver with parameters of type SimpleFeatureType
 void SQLServerDialect.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)
           
 

Uses of SimpleFeatureType in org.geotools.data.store
 

Fields in org.geotools.data.store declared as SimpleFeatureType
protected  SimpleFeatureType ContentState.featureType
          cached feature type
protected  SimpleFeatureType ContentFeatureCollection.featureType
          feature (possibly retyped from feautre source original) type
protected  SimpleFeatureType ContentFeatureSource.schema
          cached feature type (only set if this instance is a view)
protected  SimpleFeatureType DataFeatureCollection.schema
           
 

Fields in org.geotools.data.store with type parameters of type SimpleFeatureType
protected  FeatureReader<SimpleFeatureType,SimpleFeature> DiffContentFeatureWriter.reader
           
 

Methods in org.geotools.data.store that return SimpleFeatureType
protected abstract  SimpleFeatureType ContentFeatureSource.buildFeatureType()
          Creates the feature type or schema for the feature source.
protected  SimpleFeatureType ContentFeatureSource.getAbsoluteSchema()
          Helper method for returning the underlying schema of the feature source.
 SimpleFeatureType EventContentFeatureWriter.getFeatureType()
          Supplys FeatureTypeFrom reader
 SimpleFeatureType ContentState.getFeatureType()
          The cached feature type.
 SimpleFeatureType DiffContentFeatureWriter.getFeatureType()
          Supplys FeatureTypeFrom reader
 SimpleFeatureType ContentFeatureCollection.getSchema()
           
 SimpleFeatureType ContentFeatureSource.getSchema()
          Returns the feature type or the schema of the feature source.
 SimpleFeatureType ReTypingFeatureCollection.getSchema()
           
 SimpleFeatureType ReprojectingFeatureCollection.getSchema()
           
 SimpleFeatureType DataFeatureCollection.getSchema()
           
 SimpleFeatureType ContentDataStore.getSchema(Name name)
          Delegates to ContentDataStore.getSchema(String) with name.getLocalPart()
 SimpleFeatureType ContentDataStore.getSchema(String typeName)
          Returns the feature type or schema matching the specified name.
 SimpleFeatureType ArrayDataStore.getSchema(String typeName)
           
 

Methods in org.geotools.data.store that return types with arguments of type SimpleFeatureType
 FeatureReader<SimpleFeatureType,SimpleFeature> ContentDataStore.getFeatureReader(Query query, Transaction tx)
          Returns a feature reader for the specified query and transaction.
protected  FeatureReader<SimpleFeatureType,SimpleFeature> ArrayDataStore.getFeatureReader(String typeName)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> ContentDataStore.getFeatureWriter(String typeName, Filter filter, Transaction tx)
          Returns a feature writer for the specified query and transaction.
 FeatureWriter<SimpleFeatureType,SimpleFeature> ContentDataStore.getFeatureWriter(String typeName, Transaction tx)
          Returns a feature writer for the specified type name and transaction.
 FeatureWriter<SimpleFeatureType,SimpleFeature> ContentDataStore.getFeatureWriterAppend(String typeName, Transaction tx)
          Returns an appending feature writer for the specified type name and transaction.
 FeatureReader<SimpleFeatureType,SimpleFeature> ContentFeatureSource.getReader()
          Returns a feature reader for all features.
 FeatureReader<SimpleFeatureType,SimpleFeature> ContentFeatureSource.getReader(Filter filter)
          Returns a reader for features specified by a particular filter.
 FeatureReader<SimpleFeatureType,SimpleFeature> ContentFeatureSource.getReader(Query query)
          Returns a reader for the features specified by a query.
protected abstract  FeatureReader<SimpleFeatureType,SimpleFeature> ContentFeatureSource.getReaderInternal(Query query)
          Subclass method for returning a native reader from the datastore.
 FeatureWriter<SimpleFeatureType,SimpleFeature> ContentFeatureStore.getWriter(Filter filter)
          Returns a writer over features specified by a filter.
 FeatureWriter<SimpleFeatureType,SimpleFeature> ContentFeatureStore.getWriter(Filter filter, int flags)
          Returns a writer over features specified by a filter.
 FeatureWriter<SimpleFeatureType,SimpleFeature> ContentFeatureStore.getWriter(Query query)
          Returns a writer over features specified by a query.
 FeatureWriter<SimpleFeatureType,SimpleFeature> ContentFeatureStore.getWriter(Query query, int flags)
          Returns a writer over features specified by a query.
protected abstract  FeatureWriter<SimpleFeatureType,SimpleFeature> ContentFeatureStore.getWriterInternal(Query query, int flags)
          Subclass method for returning a native writer from the datastore.
 FeatureReader<SimpleFeatureType,SimpleFeature> ReTypingFeatureCollection.reader()
           
 FeatureReader<SimpleFeatureType,SimpleFeature> ReprojectingFeatureCollection.reader()
           
 FeatureReader<SimpleFeatureType,SimpleFeature> DataFeatureCollection.reader()
           
protected  FeatureWriter<SimpleFeatureType,SimpleFeature> DataFeatureCollection.writer()
          Subclass may provide an implementation of this method to indicate that read/write support is provided.
 

Methods in org.geotools.data.store with parameters of type SimpleFeatureType
 void ContentDataStore.createSchema(SimpleFeatureType featureType)
          Creates a new schema in the datastore.
 void ContentState.setFeatureType(SimpleFeatureType featureType)
          Sets the cached feature type.
protected  AttributeDescriptor[] ReTypingFeatureIterator.typeAttributes(SimpleFeatureType original, SimpleFeatureType target)
          Supplies mapping from origional to target FeatureType.
protected  AttributeDescriptor[] ReTypingIterator.typeAttributes(SimpleFeatureType original, SimpleFeatureType target)
          Deprecated. Supplies mapping from origional to target FeatureType.
 void ContentDataStore.updateSchema(Name typeName, SimpleFeatureType featureType)
          Delegates to ContentDataStore.updateSchema(String, SimpleFeatureType) with name.getLocalPart()
 void ContentDataStore.updateSchema(String typeName, SimpleFeatureType featureType)
           
 

Method parameters in org.geotools.data.store with type arguments of type SimpleFeatureType
 List<FeatureId> ContentFeatureStore.addFeatures(FeatureCollection<SimpleFeatureType,SimpleFeature> featureCollection)
          Adds a collection of features to the store.
 void ContentFeatureStore.setFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
          Sets the feature of the source.
 

Constructors in org.geotools.data.store with parameters of type SimpleFeatureType
DataFeatureCollection(String id, SimpleFeatureType memberType)
          Subclass must think about what consitructors it needs.
EmptyFeatureCollection(SimpleFeatureType schema)
           
ReprojectingFeatureIterator(SimpleFeatureIterator delegate, CoordinateReferenceSystem source, CoordinateReferenceSystem target, SimpleFeatureType schema, GeometryCoordinateSequenceTransformer transformer)
           
ReprojectingFeatureIterator(SimpleFeatureIterator delegate, MathTransform transform, SimpleFeatureType schema, GeometryCoordinateSequenceTransformer transformer)
           
ReprojectingIterator(Iterator<SimpleFeature> delegate, CoordinateReferenceSystem source, CoordinateReferenceSystem target, SimpleFeatureType schema, GeometryCoordinateSequenceTransformer transformer)
           
ReprojectingIterator(Iterator<SimpleFeature> delegate, MathTransform transform, SimpleFeatureType schema, GeometryCoordinateSequenceTransformer transformer)
           
ReTypingFeatureCollection(FeatureCollection<SimpleFeatureType,SimpleFeature> delegate, SimpleFeatureType featureType)
           
ReTypingFeatureCollection(SimpleFeatureCollection delegate, SimpleFeatureType featureType)
           
ReTypingFeatureIterator(SimpleFeatureIterator delegate, SimpleFeatureType source, SimpleFeatureType target)
           
ReTypingIterator(Iterator<SimpleFeature> delegate, SimpleFeatureType source, SimpleFeatureType target)
          Deprecated.  
 

Constructor parameters in org.geotools.data.store with type arguments of type SimpleFeatureType
ContentFeatureCollection.WrappingFeatureIterator(FeatureReader<SimpleFeatureType,SimpleFeature> delegate)
           
DiffContentFeatureWriter(ContentFeatureStore store, Diff diff, FeatureReader<SimpleFeatureType,SimpleFeature> reader)
          DiffFeatureWriter construction.
EventContentFeatureWriter(ContentFeatureStore store, FeatureWriter<SimpleFeatureType,SimpleFeature> writer)
          EventContentFeatureWriter construction.
ReprojectingFeatureCollection(FeatureCollection<SimpleFeatureType,SimpleFeature> delegate, CoordinateReferenceSystem target)
           
ReprojectingFeatureCollection(FeatureCollection<SimpleFeatureType,SimpleFeature> delegate, CoordinateReferenceSystem source, CoordinateReferenceSystem target)
           
ReTypingFeatureCollection(FeatureCollection<SimpleFeatureType,SimpleFeature> delegate, SimpleFeatureType featureType)
           
 

Uses of SimpleFeatureType in org.geotools.data.teradata
 

Methods in org.geotools.data.teradata with parameters of type SimpleFeatureType
 void TeradataDialect.encodePostSelect(SimpleFeatureType featureType, StringBuffer sql)
           
 List<ReferencedEnvelope> TeradataDialect.getOptimizedBounds(String schema, SimpleFeatureType featureType, Connection cx)
           
 void TeradataDialect.onDelete(PreparedStatement delete, Connection cx, SimpleFeatureType featureType)
           
 void TeradataDialect.onInsert(PreparedStatement insert, Connection cx, SimpleFeatureType featureType)
           
 void TeradataDialect.onSelect(PreparedStatement select, Connection cx, SimpleFeatureType featureType)
           
 void TeradataDialect.onUpdate(PreparedStatement update, Connection cx, SimpleFeatureType featureType)
           
 void TeradataDialect.postCreateTable(String schemaName, SimpleFeatureType featureType, Connection cx)
           
 

Uses of SimpleFeatureType in org.geotools.data.transform
 

Methods in org.geotools.data.transform that return SimpleFeatureType
 SimpleFeatureType TransformFeatureSource.getSchema()
           
 SimpleFeatureType SingleFeatureSourceDataStore.getSchema(Name name)
           
 SimpleFeatureType SingleFeatureSourceDataStore.getSchema(String typeName)
           
 

Methods in org.geotools.data.transform that return types with arguments of type SimpleFeatureType
 DataAccess<SimpleFeatureType,SimpleFeature> TransformFeatureSource.getDataStore()
           
 FeatureReader<SimpleFeatureType,SimpleFeature> SingleFeatureSourceDataStore.getFeatureReader(Query query, Transaction transaction)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> SingleFeatureSourceDataStore.getFeatureWriter(String typeName, Filter filter, Transaction transaction)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> SingleFeatureSourceDataStore.getFeatureWriter(String typeName, Transaction transaction)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> SingleFeatureSourceDataStore.getFeatureWriterAppend(String typeName, Transaction transaction)
           
 

Methods in org.geotools.data.transform with parameters of type SimpleFeatureType
 void SingleFeatureSourceDataStore.createSchema(SimpleFeatureType featureType)
           
 AttributeDescriptor Definition.getAttributeDescriptor(SimpleFeatureType originalSchema)
          Computes the output attribute descriptor for this Definition given only the original feature type.
 void SingleFeatureSourceDataStore.updateSchema(Name typeName, SimpleFeatureType featureType)
           
 void SingleFeatureSourceDataStore.updateSchema(String typeName, SimpleFeatureType featureType)
           
 

Method parameters in org.geotools.data.transform with type arguments of type SimpleFeatureType
 List<FeatureId> TransformFeatureStore.addFeatures(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
           
 void TransformFeatureStore.setFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
           
 

Uses of SimpleFeatureType in org.geotools.data.view
 

Methods in org.geotools.data.view that return SimpleFeatureType
 SimpleFeatureType DefaultView.getSchema()
          Implement getSchema.
 

Uses of SimpleFeatureType in org.geotools.data.wfs.feature
 

Methods in org.geotools.data.wfs.feature with parameters of type SimpleFeatureType
static SimpleFeature LenientBuilder.build(SimpleFeatureType ft, Object[] atts, String fid)
           
 SimpleFeature LenientFeatureFactory.createSimpleFeature(List<Attribute> properties, SimpleFeatureType type, String id)
           
 

Constructors in org.geotools.data.wfs.feature with parameters of type SimpleFeatureType
LenientBuilder(SimpleFeatureType schmea)
           
LenientFeature(List<Attribute> attributes, SimpleFeatureType schema, String featureID)
          Creates a new instance of flat feature, which must take a flat feature type schema and all attributes as arguments.
 

Uses of SimpleFeatureType in org.geotools.data.wfs.protocol.wfs
 

Methods in org.geotools.data.wfs.protocol.wfs that return SimpleFeatureType
 SimpleFeatureType WFSProtocol.issueDescribeFeatureTypeGET(String prefixedTypeName, CoordinateReferenceSystem crs)
           
 

Uses of SimpleFeatureType in org.geotools.data.wfs.v1_0_0
 

Methods in org.geotools.data.wfs.v1_0_0 that return SimpleFeatureType
 SimpleFeatureType WFSFeatureSource.getSchema()
           
 SimpleFeatureType WFSFeatureSource.WFSFeatureResults.getSchema()
           
 SimpleFeatureType WFS_1_0_0_DataStore.getSchema(Name name)
           
 SimpleFeatureType WFS_1_0_0_DataStore.getSchema(String typeName)
          DOCUMENT ME!
protected  SimpleFeatureType WFS_1_0_0_DataStore.getSchemaGet(String typeName)
           
protected  SimpleFeatureType WFS_1_0_0_DataStore.getSchemaPost(String typeName)
           
 

Methods in org.geotools.data.wfs.v1_0_0 that return types with arguments of type SimpleFeatureType
protected  FeatureReader<SimpleFeatureType,SimpleFeature> MapServerWFSStrategy.createFeatureReader(Transaction transaction, Query query)
           
 FeatureReader<SimpleFeatureType,SimpleFeature> WFS_1_0_0_DataStore.getFeatureReader(Query query, Transaction transaction)
           
protected  FeatureReader<SimpleFeatureType,SimpleFeature> WFS_1_0_0_DataStore.getFeatureReader(String typeName)
           
protected  FeatureReader<SimpleFeatureType,SimpleFeature> WFS_1_0_0_DataStore.getFeatureReader(String typeName, Query query)
           
static FeatureReader<SimpleFeatureType,SimpleFeature> WFSFeatureReader.getFeatureReader(URI document, int capacity, int timeout, WFSTransactionState transaction, SimpleFeatureType ft)
           
protected  FeatureReader<SimpleFeatureType,SimpleFeature> WFS_1_0_0_DataStore.getFeatureReaderGet(Query request, Transaction transaction)
           
protected  FeatureReader<SimpleFeatureType,SimpleFeature> WFS_1_0_0_DataStore.getFeatureReaderPost(Query query, Transaction transaction)
           
 FeatureReader<SimpleFeatureType,SimpleFeature> WFSFeatureSource.WFSFeatureResults.reader()
           
 

Methods in org.geotools.data.wfs.v1_0_0 with parameters of type SimpleFeatureType
static WFSFeatureReader WFSFeatureReader.getFeatureReader(InputStream is, int capacity, int timeout, WFSTransactionState transaction, SimpleFeatureType ft)
           
static FeatureReader<SimpleFeatureType,SimpleFeature> WFSFeatureReader.getFeatureReader(URI document, int capacity, int timeout, WFSTransactionState transaction, SimpleFeatureType ft)
           
 void WFS_1_0_0_DataStore.updateSchema(Name typeName, SimpleFeatureType featureType)
           
 

Method parameters in org.geotools.data.wfs.v1_0_0 with type arguments of type SimpleFeatureType
 List<FeatureId> WFSFeatureStore.addFeatures(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
           
 List<FeatureId> WFSFeatureStore.addFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
           
 void WFSFeatureStore.setFeatures(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
           
 

Uses of SimpleFeatureType in org.geotools.data.wfs.v1_0_0.gml
 

Methods in org.geotools.data.wfs.v1_0_0.gml that return SimpleFeatureType
static SimpleFeatureType WFSFeatureTypeTransformer.transform(SimpleFeatureType schema, CoordinateReferenceSystem crs)
           
 

Methods in org.geotools.data.wfs.v1_0_0.gml with parameters of type SimpleFeatureType
static SimpleFeatureType WFSFeatureTypeTransformer.transform(SimpleFeatureType schema, CoordinateReferenceSystem crs)
           
 

Uses of SimpleFeatureType in org.geotools.data.wfs.v1_1_0
 

Methods in org.geotools.data.wfs.v1_1_0 that return SimpleFeatureType
 SimpleFeatureType WFSFeatureSource.getSchema()
           
 SimpleFeatureType WFS_1_1_0_DataStore.getSchema(Name name)
           
 SimpleFeatureType WFS_1_1_0_DataStore.getSchema(String prefixedTypeName)
          Makes a DescribeFeatureType request for typeName feature type, parses the server response into a SimpleFeatureType and returns it.
 SimpleFeatureType WFS_1_1_0_Protocol.issueDescribeFeatureTypeGET(String prefixedTypeName, CoordinateReferenceSystem crs)
           
 

Methods in org.geotools.data.wfs.v1_1_0 that return types with arguments of type SimpleFeatureType
 FeatureReader<SimpleFeatureType,SimpleFeature> WFS_1_1_0_DataStore.getFeatureReader(Query query, Transaction transaction)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> WFS_1_1_0_DataStore.getFeatureWriter(String typeName, Filter filter, Transaction transaction)
          Not supported.
 FeatureWriter<SimpleFeatureType,SimpleFeature> WFS_1_1_0_DataStore.getFeatureWriter(String typeName, Transaction transaction)
          Not supported.
 FeatureWriter<SimpleFeatureType,SimpleFeature> WFS_1_1_0_DataStore.getFeatureWriterAppend(String typeName, Transaction transaction)
          Not supported.
 

Methods in org.geotools.data.wfs.v1_1_0 with parameters of type SimpleFeatureType
 void WFS_1_1_0_DataStore.createSchema(SimpleFeatureType featureType)
           
 void WFS_1_1_0_DataStore.updateSchema(Name typeName, SimpleFeatureType featureType)
           
 void WFS_1_1_0_DataStore.updateSchema(String typeName, SimpleFeatureType featureType)
           
 

Uses of SimpleFeatureType in org.geotools.data.wfs.v1_1_0.parsers
 

Methods in org.geotools.data.wfs.v1_1_0.parsers that return SimpleFeatureType
static SimpleFeatureType EmfAppSchemaParser.parse(Configuration wfsConfiguration, QName featureName, URL schemaLocation, CoordinateReferenceSystem crs, Map<String,String> mappedURIs, Map<QName,Class<?>> mappedBindings, boolean ignoreMissingElementDeclaration)
          Parses the FeatureType pointed out by the schemaLocation URL and returns it.
static SimpleFeatureType EmfAppSchemaParser.parseSimpleFeatureType(Configuration wfsConfiguration, QName featureName, URL schemaLocation, CoordinateReferenceSystem crs, Map<String,String> mappedURIs, Map<QName,Class<?>> mappedBindings, boolean ignoreMissingElementDeclaration)
          Parses the FeatureType pointed out by the schemaLocation URL and returns a subset consisting only of the simple attributes found on the original schema.
static SimpleFeatureType EmfAppSchemaParser.parseSimpleFeatureType(QName featureName, URL schemaLocation, CoordinateReferenceSystem crs, Configuration wfsConfiguration, Map<String,String> mappedURIs, Map<QName,Class<?>> mappedBindings, boolean ignoreMissingElementDeclaration)
           
static SimpleFeatureType EmfAppSchemaParser.toSimpleFeatureType(FeatureType realType)
          Go through FeatureType description and convert to a SimpleFeatureType.
 

Constructors in org.geotools.data.wfs.v1_1_0.parsers with parameters of type SimpleFeatureType
XmlSimpleFeatureParser(InputStream getFeatureResponseStream, SimpleFeatureType targetType, QName featureDescriptorName, String axisOrder, Map<String,String> mappedURIs)
           
 

Uses of SimpleFeatureType in org.geotools.feature
 

Fields in org.geotools.feature declared as SimpleFeatureType
static SimpleFeatureType FeatureTypes.ABSTRACT_FEATURE_TYPE
          abstract base type for all feature types
static SimpleFeatureType FeatureTypes.EMPTY
          An feature type with no attributes
protected  SimpleFeatureType DefaultFeatureCollection.schema
           
 

Methods in org.geotools.feature that return SimpleFeatureType
 SimpleFeatureType DecoratingFeature.getFeatureType()
           
 SimpleFeatureType DefaultFeatureCollection.getSchema()
           
 SimpleFeatureType DecoratingFeature.getType()
           
static SimpleFeatureType FeatureTypes.newFeatureType(AttributeDescriptor[] types, String name)
          Create a new FeatureType with the given AttributeTypes.
static SimpleFeatureType FeatureTypes.newFeatureType(AttributeDescriptor[] types, String name, URI ns)
          Create a new FeatureType with the given AttributeTypes.
static SimpleFeatureType FeatureTypes.newFeatureType(AttributeDescriptor[] types, String name, URI ns, boolean isAbstract)
          Create a new FeatureType with the given AttributeTypes.
static SimpleFeatureType FeatureTypes.newFeatureType(AttributeDescriptor[] types, String name, URI ns, boolean isAbstract, SimpleFeatureType[] superTypes)
          The most specific way to create a new FeatureType.
static SimpleFeatureType FeatureTypes.newFeatureType(AttributeDescriptor[] types, String name, URI ns, boolean isAbstract, SimpleFeatureType[] superTypes, AttributeDescriptor defaultGeometry)
          The most specific way to create a new FeatureType.
static SimpleFeatureType FeatureTypes.newFeatureType(AttributeDescriptor[] types, String name, URI ns, boolean isAbstract, SimpleFeatureType[] superTypes, GeometryDescriptor defaultGeometry)
          The most specific way to create a new FeatureType.
static SimpleFeatureType FeatureTypes.transform(SimpleFeatureType schema, CoordinateReferenceSystem crs)
          Forces the specified CRS on all geometry attributes
static SimpleFeatureType FeatureTypes.transform(SimpleFeatureType schema, CoordinateReferenceSystem crs, boolean forceOnlyMissing)
          Forces the specified CRS on geometry attributes (all or some, depends on the parameters).
 

Methods in org.geotools.feature that return types with arguments of type SimpleFeatureType
 FeatureReader<SimpleFeatureType,SimpleFeature> DefaultFeatureCollection.reader()
           
 

Methods in org.geotools.feature with parameters of type SimpleFeatureType
static Set FeatureTypes.ancestors(SimpleFeatureType featureType)
           
static AttributeDescriptor Schema.attribute(SimpleFeatureType type, int index)
          Deprecated. use getAttribute( type, index )
static AttributeDescriptor Schema.attribute(SimpleFeatureType type, String name)
          Deprecated. use getAttribute( type, name )
static int Schema.attributeCount(SimpleFeatureType featureType)
          Deprecated. Walk the provided FeatureType and produce a count of distinct attribtues.
static List Schema.attributes(SimpleFeatureType featureType)
          Deprecated. use getAttributes( featureType )
static List Schema.attributes(SimpleFeatureType featureType, List list)
          Deprecated. use getAttributes( featureType, list )
protected  SimpleFeatureCollection DefaultFeatureCollections.createCollection(String id, SimpleFeatureType ft)
           
 SimpleFeature AbstractFeatureFactoryImpl.createSimpleFeature(Object[] array, SimpleFeatureType type, String id)
           
static boolean FeatureTypes.equals(SimpleFeatureType typeA, SimpleFeatureType typeB)
          Exact equality based on typeNames, namespace, attributes and ancestors
static boolean FeatureTypes.equalsAncestors(SimpleFeatureType typeA, SimpleFeatureType typeB)
          This method depends on the correct implementation of FeatureType equals We may need to write an implementation that can detect cycles,
static boolean FeatureTypes.equalsExact(SimpleFeatureType typeA, SimpleFeatureType typeB)
          Exact equality based on typeNames, namespace, attributes and ancestors, including the user maps contents
static boolean FeatureTypes.equalsId(SimpleFeatureType typeA, SimpleFeatureType typeB)
          Quick check of namespace and typename
static int Schema.find(SimpleFeatureType type, String name)
          Deprecated. please use getIndexOf( type, name )
 AttributeDescriptor Schema.getAttribute(SimpleFeatureType type, int index)
          Deprecated. Look up based on name in the provided position.
 AttributeDescriptor Schema.getAttribute(SimpleFeatureType type, String name)
          Deprecated.  
 int Schema.getAttributeCount(SimpleFeatureType featureType)
          Deprecated. Walk the provided FeatureType and produce a count of distinct attribtues.
 List Schema.getAttributes(SimpleFeatureType featureType)
          Deprecated.  
 List Schema.getAttributes(SimpleFeatureType featureType, List list)
          Deprecated. This order is to be respected, based on Ancestors and so on.
 int Schema.getIndexOf(SimpleFeatureType type, String name)
          Deprecated. Lookup can only really be by name.
 List Schema.getNames(SimpleFeatureType featureType)
          Deprecated. Does a quick walk to detect only a list of attribute names.
 List Schema.getNames(SimpleFeatureType featureType, List names)
          Deprecated. This order is to be respected, based on Ancestors and so on.
 Filter Schema.getRestrictions(SimpleFeatureType featureType, String name)
          Deprecated. Query featureType information the complete restrictions for the indicated name.
 AttributeDescriptor Schema.getXPath(SimpleFeatureType type, String xpath)
          Deprecated. Look up based on name in the provided position.
static List Schema.names(SimpleFeatureType featureType)
          Deprecated. use getNames( featureType )
static List Schema.names(SimpleFeatureType featureType, List names)
          Deprecated. use getNames( featureType, List )
static SimpleFeatureType FeatureTypes.newFeatureType(AttributeDescriptor[] types, String name, URI ns, boolean isAbstract, SimpleFeatureType[] superTypes)
          The most specific way to create a new FeatureType.
static SimpleFeatureType FeatureTypes.newFeatureType(AttributeDescriptor[] types, String name, URI ns, boolean isAbstract, SimpleFeatureType[] superTypes, AttributeDescriptor defaultGeometry)
          The most specific way to create a new FeatureType.
static SimpleFeatureType FeatureTypes.newFeatureType(AttributeDescriptor[] types, String name, URI ns, boolean isAbstract, SimpleFeatureType[] superTypes, GeometryDescriptor defaultGeometry)
          The most specific way to create a new FeatureType.
static Filter Schema.restriction(SimpleFeatureType featureType, String name)
          Deprecated. please use getRestriction( featureType, name )
static SimpleFeature FeatureTypes.transform(SimpleFeature feature, SimpleFeatureType schema, MathTransform transform)
          Applies transform to all geometry attribute.
static SimpleFeatureType FeatureTypes.transform(SimpleFeatureType schema, CoordinateReferenceSystem crs)
          Forces the specified CRS on all geometry attributes
static SimpleFeatureType FeatureTypes.transform(SimpleFeatureType schema, CoordinateReferenceSystem crs, boolean forceOnlyMissing)
          Forces the specified CRS on geometry attributes (all or some, depends on the parameters).
static AttributeDescriptor Schema.xpath(SimpleFeatureType type, String xpath)
          Deprecated. use getXPath( type, xpath );
 

Constructors in org.geotools.feature with parameters of type SimpleFeatureType
DefaultFeatureCollection(String id, SimpleFeatureType memberType)
          Used to create a feature collection to stage content in memory.
 

Constructor parameters in org.geotools.feature with type arguments of type SimpleFeatureType
DefaultFeatureCollection(FeatureCollection<SimpleFeatureType,SimpleFeature> collection)
          Used to stage content in memory.
 

Uses of SimpleFeatureType in org.geotools.feature.collection
 

Fields in org.geotools.feature.collection declared as SimpleFeatureType
protected  SimpleFeatureType AdaptorFeatureCollection.schema
           
protected  SimpleFeatureType AbstractFeatureCollection.schema
           
 

Methods in org.geotools.feature.collection that return SimpleFeatureType
 SimpleFeatureType AdaptorFeatureCollection.getSchema()
           
 SimpleFeatureType DecoratingSimpleFeatureCollection.getSchema()
           
 SimpleFeatureType AbstractFeatureCollection.getSchema()
           
 

Methods in org.geotools.feature.collection that return types with arguments of type SimpleFeatureType
 FeatureReader<SimpleFeatureType,SimpleFeature> FilteringSimpleFeatureCollection.reader()
           
 

Constructors in org.geotools.feature.collection with parameters of type SimpleFeatureType
AbstractFeatureCollection(SimpleFeatureType memberType)
           
AdaptorFeatureCollection(String id, SimpleFeatureType memberType)
           
BaseSimpleFeatureCollection(SimpleFeatureType schema)
           
 

Constructor parameters in org.geotools.feature.collection with type arguments of type SimpleFeatureType
DecoratingSimpleFeatureCollection(FeatureCollection<SimpleFeatureType,SimpleFeature> delegate)
           
DelegateSimpleFeatureIterator(FeatureCollection<SimpleFeatureType,SimpleFeature> collection, Iterator<SimpleFeature> iterator)
          Wrap the provided iterator up as a FeatureIterator.
FilteringSimpleFeatureCollection(FeatureCollection<SimpleFeatureType,SimpleFeature> delegate, Filter filter)
           
MaxSimpleFeatureCollection(FeatureCollection<SimpleFeatureType,SimpleFeature> delegate, long max)
           
 

Uses of SimpleFeatureType in org.geotools.feature.simple
 

Classes in org.geotools.feature.simple that implement SimpleFeatureType
 class SimpleFeatureTypeImpl
          Implementation fo SimpleFeatureType, subtypes must be atomic and are stored in a list.
 

Fields in org.geotools.feature.simple declared as SimpleFeatureType
protected  SimpleFeatureType SimpleFeatureImpl.featureType
           
protected  SimpleFeatureType SimpleFeatureTypeBuilder.superType
          the parent type.
 

Methods in org.geotools.feature.simple that return SimpleFeatureType
 SimpleFeatureType SimpleFeatureTypeBuilder.buildFeatureType()
          Builds a feature type from compiled state.
static SimpleFeatureType SimpleFeatureTypeBuilder.copy(SimpleFeatureType original)
          Copys a feature type.
 SimpleFeatureType SimpleFeatureBuilder.getFeatureType()
          Returns the simple feature type used by this builder as a feature template
 SimpleFeatureType SimpleFeatureImpl.getFeatureType()
           
 SimpleFeatureType SimpleFeatureTypeBuilder.getSuperType()
          The super type of the built type.
 SimpleFeatureType SimpleFeatureImpl.getType()
           
static SimpleFeatureType SimpleFeatureTypeBuilder.retype(SimpleFeatureType original, CoordinateReferenceSystem crs)
          Create a SimpleFeatureType with the same content; just updating the geometry attribute to match the provided coordinate reference system.
static SimpleFeatureType SimpleFeatureTypeBuilder.retype(SimpleFeatureType original, List<String> types)
           
static SimpleFeatureType SimpleFeatureTypeBuilder.retype(SimpleFeatureType original, String[] types)
          Create a SimpleFeatureType containing just the descriptors indicated.
 

Methods in org.geotools.feature.simple with parameters of type SimpleFeatureType
static SimpleFeature SimpleFeatureBuilder.build(SimpleFeatureType type, List<Object> values, String id)
          * Static method to build a new feature.
static SimpleFeature SimpleFeatureBuilder.build(SimpleFeatureType type, Object[] values, String id)
          Static method to build a new feature.
static SimpleFeatureType SimpleFeatureTypeBuilder.copy(SimpleFeatureType original)
          Copys a feature type.
 void SimpleFeatureTypeBuilder.init(SimpleFeatureType type)
          Initializes the builder with state from a pre-existing feature type.
static SimpleFeature SimpleFeatureBuilder.retype(SimpleFeature feature, SimpleFeatureType featureType)
          Copies an existing feature, retyping it in the process.
static SimpleFeatureType SimpleFeatureTypeBuilder.retype(SimpleFeatureType original, CoordinateReferenceSystem crs)
          Create a SimpleFeatureType with the same content; just updating the geometry attribute to match the provided coordinate reference system.
static SimpleFeatureType SimpleFeatureTypeBuilder.retype(SimpleFeatureType original, List<String> types)
           
static SimpleFeatureType SimpleFeatureTypeBuilder.retype(SimpleFeatureType original, String[] types)
          Create a SimpleFeatureType containing just the descriptors indicated.
 void SimpleFeatureTypeBuilder.setSuperType(SimpleFeatureType superType)
          Sets the super type of the built type.
static SimpleFeature SimpleFeatureBuilder.template(SimpleFeatureType featureType, String featureId)
          Builds a new feature whose attribute values are the default ones
 

Constructors in org.geotools.feature.simple with parameters of type SimpleFeatureType
SimpleFeatureBuilder(SimpleFeatureType featureType)
           
SimpleFeatureBuilder(SimpleFeatureType featureType, FeatureFactory factory)
           
SimpleFeatureImpl(List<Object> values, SimpleFeatureType featureType, FeatureId id)
          Builds a new feature based on the provided values and feature type
SimpleFeatureImpl(Object[] values, SimpleFeatureType featureType, FeatureId id, boolean validating)
          Fast construction of a new feature.
SimpleFeatureImpl(Object[] values, SimpleFeatureType featureType, FeatureId id, boolean validating, Map<String,Integer> index)
          Fast construction of a new feature.
 

Uses of SimpleFeatureType in org.geotools.feature.type
 

Fields in org.geotools.feature.type declared as SimpleFeatureType
static SimpleFeatureType AnnotationFeatureType.ANNOTATION
          The FeatureType reference that should be used for Anotations.
static SimpleFeatureType BasicFeatureTypes.FEATURE
          The base type for all features
static SimpleFeatureType BasicFeatureTypes.LINE
          The FeatureType reference that should be used for Lines
static SimpleFeatureType BasicFeatureTypes.POINT
          The FeatureType reference that should be used for Points
static SimpleFeatureType BasicFeatureTypes.POLYGON
          The FeatureType reference that should be used for Polygons
 

Methods in org.geotools.feature.type that return SimpleFeatureType
 SimpleFeatureType FeatureTypeFactoryImpl.createSimpleFeatureType(Name name, List<AttributeDescriptor> schema, GeometryDescriptor defaultGeometry, boolean isAbstract, List<Filter> restrictions, AttributeType superType, InternationalString description)
           
 

Methods in org.geotools.feature.type with parameters of type SimpleFeatureType
static void Types.assertOrderAssignable(SimpleFeatureType expected, SimpleFeatureType actual)
          SimpleFeatureType comparison indicating that data from one FeatureType can be exchanged with another - specifically ensuring that the order / value is a reasonable match with the expected number of attributes on each side and the values correctly assignable.
 

Uses of SimpleFeatureType in org.geotools.feature.visitor
 

Constructors in org.geotools.feature.visitor with parameters of type SimpleFeatureType
AverageVisitor(int attributeTypeIndex, SimpleFeatureType type)
          Constructor class for the AverageVisitor using AttributeDescriptor ID
AverageVisitor(String attrName, SimpleFeatureType type)
          Constructor class for the AverageVisitor using AttributeDescriptor Name
MaxVisitor(int attributeTypeIndex, SimpleFeatureType type)
           
MaxVisitor(String attrName, SimpleFeatureType type)
           
MedianVisitor(int attributeTypeIndex, SimpleFeatureType type)
           
MedianVisitor(String attrName, SimpleFeatureType type)
           
MinVisitor(int attributeTypeIndex, SimpleFeatureType type)
           
MinVisitor(String attrName, SimpleFeatureType type)
           
SumVisitor(int attributeTypeIndex, SimpleFeatureType type)
           
SumVisitor(String attrName, SimpleFeatureType type)
           
UniqueVisitor(int attributeTypeIndex, SimpleFeatureType type)
           
UniqueVisitor(String attrName, SimpleFeatureType type)
           
 

Uses of SimpleFeatureType in org.geotools.filter
 

Fields in org.geotools.filter declared as SimpleFeatureType
protected  SimpleFeatureType SQLEncoder.featureType
          Deprecated. the schmema the encoder will be used to be encode sql for
protected  SimpleFeatureType FilterAttributeExtractor.featureType
          feature type to evaluate against
protected  SimpleFeatureType AttributeExpressionImpl.schema
          Used to validate attribute references to ensure they match the provided schema
 

Methods in org.geotools.filter with parameters of type SimpleFeatureType
static String[] Filters.attributeNames(Filter filter, SimpleFeatureType featureType)
          Traverses the filter and returns any encountered property names.
 AttributeExpression FilterFactoryImpl.createAttributeExpression(SimpleFeatureType schema)
          Creates a Attribute Expression with an initial schema.
 AttributeExpression FilterFactory.createAttributeExpression(SimpleFeatureType schema)
          Deprecated. use FilterFactory.createAttributeExpression(String) instead.
 AttributeExpression FilterFactoryImpl.createAttributeExpression(SimpleFeatureType schema, String path)
          Creates a Attribute Expression given a schema and attribute path.
 AttributeExpression FilterFactory.createAttributeExpression(SimpleFeatureType schema, String xpath)
          Deprecated. use createAttributeExpression( xpath ), will be removed for GeoTools 2.3
static Set<PropertyName> Filters.propertyNames(Expression expression, SimpleFeatureType featureType)
          Traverses the expression and returns any encountered property names.
static Set<PropertyName> Filters.propertyNames(Filter filter, SimpleFeatureType featureType)
          Traverses the filter and returns any encountered property names.
 void SQLEncoder.setFeatureType(SimpleFeatureType featureType)
          Deprecated. Sets the featuretype the encoder is encoding sql for.
 

Constructors in org.geotools.filter with parameters of type SimpleFeatureType
AttributeExpressionImpl(SimpleFeatureType schema)
          Constructor with the schema for this attribute.
AttributeExpressionImpl(SimpleFeatureType schema, String attPath)
          Constructor with schema and path to the attribute.
ExpressionSAXParser(SimpleFeatureType schema)
          Constructor with a schema to read the attribute againset.
ExpressionSAXParser(SimpleFeatureType schema, FilterFactory factory)
          Constructor injection
FilterAttributeExtractor(SimpleFeatureType featureType)
          Use the provided feature type as a sanity check when extracting property names.
FilterFilter(FilterHandler parent, SimpleFeatureType schema)
          Constructor with parent, which must implement GMLHandlerJTS.
FilterFilter(FilterHandler parent, SimpleFeatureType schema, boolean convertLiteralToNumber)
          Constructor with parent, which must implement GMLHandlerJTS.
 

Uses of SimpleFeatureType in org.geotools.filter.visitor
 

Constructors in org.geotools.filter.visitor with parameters of type SimpleFeatureType
PostPreProcessFilterSplittingVisitor(FilterCapabilities fcs, SimpleFeatureType parent, ClientTransactionAccessor transactionAccessor)
          Deprecated. Create a new instance.
PropertyNameResolvingVisitor(SimpleFeatureType featureType)
           
 

Uses of SimpleFeatureType in org.geotools.gce.imagemosaic
 

Methods in org.geotools.gce.imagemosaic that return SimpleFeatureType
static SimpleFeatureType CatalogManager.createSchema(CatalogBuilderConfiguration runConfiguration, String name, CoordinateReferenceSystem actualCRS)
          Create a SimpleFeatureType from the specified configuration.
 

Methods in org.geotools.gce.imagemosaic with parameters of type SimpleFeatureType
 void ImageMosaicReader.createCoverage(String coverageName, SimpleFeatureType indexSchema)
           
 void RasterManager.createStore(SimpleFeatureType indexSchema)
          Create a store for the coverage related to this RasterManager using the provided schema
 

Uses of SimpleFeatureType in org.geotools.gce.imagemosaic.catalog
 

Methods in org.geotools.gce.imagemosaic.catalog that return SimpleFeatureType
 SimpleFeatureType GranuleCatalogSource.getSchema()
           
abstract  SimpleFeatureType GranuleCatalog.getType(String typeName)
           
 

Methods in org.geotools.gce.imagemosaic.catalog with parameters of type SimpleFeatureType
abstract  void GranuleCatalog.createType(SimpleFeatureType featureType)
           
 

Uses of SimpleFeatureType in org.geotools.gce.imagemosaic.catalog.oracle
 

Methods in org.geotools.gce.imagemosaic.catalog.oracle that return SimpleFeatureType
 SimpleFeatureType OracleFeatureTypeMapper.getMappedFeatureType()
           
 SimpleFeatureType FeatureTypeMapper.getMappedFeatureType()
          Get the remapped FeatureType
 SimpleFeatureType DataStoreWrapper.getSchema(Name name)
           
 SimpleFeatureType DataStoreWrapper.getSchema(String typeName)
           
 SimpleFeatureType OracleFeatureTypeMapper.getWrappedFeatureType()
           
 SimpleFeatureType FeatureTypeMapper.getWrappedFeatureType()
          Get the original FeatureType
 

Methods in org.geotools.gce.imagemosaic.catalog.oracle that return types with arguments of type SimpleFeatureType
 DataAccess<SimpleFeatureType,SimpleFeature> OracleTransformFeatureStore.getDataStore()
           
 FeatureReader<SimpleFeatureType,SimpleFeature> DataStoreWrapper.getFeatureReader(Query query, Transaction transaction)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> DataStoreWrapper.getFeatureWriter(String typeName, Filter filter, Transaction transaction)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> DataStoreWrapper.getFeatureWriter(String typeName, Transaction transaction)
           
 FeatureWriter<SimpleFeatureType,SimpleFeature> DataStoreWrapper.getFeatureWriterAppend(String typeName, Transaction transaction)
           
 

Methods in org.geotools.gce.imagemosaic.catalog.oracle with parameters of type SimpleFeatureType
 void DataStoreWrapper.createSchema(SimpleFeatureType featureType)
           
protected abstract  FeatureTypeMapper DataStoreWrapper.getFeatureTypeMapper(SimpleFeatureType featureType)
          Return a specific FeatureTypeMapper instance on top of an input featureType
protected  FeatureTypeMapper OracleDatastoreWrapper.getFeatureTypeMapper(SimpleFeatureType featureType)
           
 void DataStoreWrapper.updateSchema(Name typeName, SimpleFeatureType featureType)
           
 void DataStoreWrapper.updateSchema(String typeName, SimpleFeatureType featureType)
           
 

Constructors in org.geotools.gce.imagemosaic.catalog.oracle with parameters of type SimpleFeatureType
OracleFeatureTypeMapper(SimpleFeatureType featureType)
          Create a new OracleFeatureTypeMapper on top of the original featureType provided
 

Uses of SimpleFeatureType in org.geotools.geojson.feature
 

Methods in org.geotools.geojson.feature that return SimpleFeatureType
 SimpleFeatureType FeatureTypeHandler.getValue()
           
 SimpleFeatureType FeatureJSON.readFeatureCollectionSchema(InputStream input, boolean nullValuesEncoded)
          Reads the SimpleFeatureType of a GeoJSON feature collection.
 SimpleFeatureType FeatureJSON.readFeatureCollectionSchema(Object input, boolean nullValuesEncoded)
          Reads the SimpleFeatureType of a GeoJSON feature collection.
 

Methods in org.geotools.geojson.feature with parameters of type SimpleFeatureType
 void FeatureJSON.setFeatureType(SimpleFeatureType featureType)
          Sets the target feature type for parsing.
 

Constructors in org.geotools.geojson.feature with parameters of type SimpleFeatureType
FeatureCollectionHandler(SimpleFeatureType featureType, AttributeIO attio)
           
FeatureTypeAttributeIO(SimpleFeatureType featureType)
           
 

Uses of SimpleFeatureType in org.geotools.geopkg
 

Methods in org.geotools.geopkg with parameters of type SimpleFeatureType
 void GeoPackage.create(FeatureEntry entry, SimpleFeatureType schema)
          Creates a new feature entry in the geopackage.
 void GeoPkgDialect.postCreateTable(String schemaName, SimpleFeatureType featureType, Connection cx)
           
 

Uses of SimpleFeatureType in org.geotools.gml.producer
 

Methods in org.geotools.gml.producer with parameters of type SimpleFeatureType
protected  void FeatureTypeTransformer.FeatureTypeTranslator.encode(SimpleFeatureType type)
          Encode the supplied feature type.
 

Method parameters in org.geotools.gml.producer with type arguments of type SimpleFeatureType
 void FeatureTransformer.FeatureTranslator.handleFeatureReader(FeatureReader<SimpleFeatureType,SimpleFeature> reader)
           
 

Uses of SimpleFeatureType in org.geotools.gml2.bindings
 

Methods in org.geotools.gml2.bindings that return SimpleFeatureType
static SimpleFeatureType GML2ParsingUtils.featureType(Node node)
          Turns a parse node instance into a geotools feature type.
static SimpleFeatureType GML2ParsingUtils.featureType(XSDElementDeclaration element, BindingWalkerFactory bwFactory)
          Turns a xml type definition into a geotools feature type.
static SimpleFeatureType GML2ParsingUtils.featureType(XSDElementDeclaration element, BindingWalkerFactory bwFactory, CoordinateReferenceSystem crs)
          Turns a xml type definition into a geotools feature type.
 

Methods in org.geotools.gml2.bindings with parameters of type SimpleFeatureType
static XSDTypeDefinition GML2EncodingUtils.createXmlTypeFromFeatureType(SimpleFeatureType featureType, SchemaIndex schemaIndex, Set<String> toFilter)
           
 XSDTypeDefinition GMLEncodingUtils.createXmlTypeFromFeatureType(SimpleFeatureType featureType, SchemaIndex schemaIndex, Set<String> toFilter)
           
static SimpleFeature GML2ParsingUtils.feature(SimpleFeatureType fType, String fid, Node node)
           
 

Uses of SimpleFeatureType in org.geotools.gml3.bindings
 

Methods in org.geotools.gml3.bindings that return SimpleFeatureType
static SimpleFeatureType GML3ParsingUtils.featureType(XSDElementDeclaration element, BindingWalkerFactory bwFactory)
          Turns a xml type definition into a geotools feature type.
 

Uses of SimpleFeatureType in org.geotools.gml4wcs.bindings
 

Methods in org.geotools.gml4wcs.bindings that return SimpleFeatureType
static SimpleFeatureType GML3ParsingUtils.featureType(XSDElementDeclaration element, BindingWalkerFactory bwFactory)
          Turns a xml type definition into a geotools feature type.
 

Uses of SimpleFeatureType in org.geotools.grid
 

Methods in org.geotools.grid that return SimpleFeatureType
protected static SimpleFeatureType DefaultGridFeatureBuilder.createType(String typeName, CoordinateReferenceSystem crs)
          Creates the feature TYPE
 SimpleFeatureType GridFeatureBuilder.getType()
          Gets the feature type.
 

Constructors in org.geotools.grid with parameters of type SimpleFeatureType
GridFeatureBuilder(SimpleFeatureType type)
          Creates a GridFeatureBuilder to work with the given feature type.
 

Uses of SimpleFeatureType in org.geotools.grid.ortholine
 

Methods in org.geotools.grid.ortholine that return SimpleFeatureType
protected static SimpleFeatureType OrthoLineFeatureBuilder.createType(String typeName, CoordinateReferenceSystem crs)
          Creates the feature TYPE
 

Uses of SimpleFeatureType in org.geotools.jdbc
 

Fields in org.geotools.jdbc declared as SimpleFeatureType
protected  SimpleFeatureType JDBCFeatureReader.featureType
          schema of features
 

Methods in org.geotools.jdbc that return SimpleFeatureType
protected  SimpleFeatureType JDBCFeatureStore.buildFeatureType()
           
protected  SimpleFeatureType JDBCFeatureSource.buildFeatureType()
          Builds the feature type from database metadata.
 SimpleFeatureType JoinPropertyName.getFeatureType()
           
 SimpleFeatureType JDBCFeatureReader.getFeatureType()
           
 SimpleFeatureType JDBCFeatureReader.ResultSetFeature.getFeatureType()
           
 SimpleFeatureType JDBCClosingFeatureWriter.getFeatureType()
           
 SimpleFeatureType JDBCJoiningFilteringFeatureReader.getFeatureType()
           
 SimpleFeatureType JDBCClosingFeatureReader.getFeatureType()
           
protected  SimpleFeatureType JoiningJDBCFeatureSource.getFeatureType(SimpleFeatureType origType, JoiningQuery query)
           
 SimpleFeatureType JoinInfo.JoinPart.getQueryFeatureType()
           
 SimpleFeatureType JoinInfo.JoinPart.getReturnFeatureType()
           
 SimpleFeatureType JDBCFeatureReader.ResultSetFeature.getType()
           
 

Methods in org.geotools.jdbc that return types with arguments of type SimpleFeatureType
 FeatureReader<SimpleFeatureType,SimpleFeature> JDBCJoiningFilteringFeatureReader.getDelegate()
           
 FeatureReader<SimpleFeatureType,SimpleFeature> JDBCClosingFeatureReader.getDelegate()
           
protected  FeatureReader<SimpleFeatureType,SimpleFeature> JoiningJDBCFeatureSource.getJoiningReaderInternal(JoiningQuery query)
           
protected  FeatureReader<SimpleFeatureType,SimpleFeature> JoiningJDBCFeatureSource.getReaderInternal(Query query)
           
protected  FeatureReader<SimpleFeatureType,SimpleFeature> JDBCFeatureStore.getReaderInternal(Query query)
           
protected  FeatureReader<SimpleFeatureType,SimpleFeature> JDBCFeatureSource.getReaderInternal(Query query)
           
protected  FeatureWriter<SimpleFeatureType,SimpleFeature> JDBCFeatureStore.getWriterInternal(Query query, int flags)
           
 

Methods in org.geotools.jdbc with parameters of type SimpleFeatureType
static JoinInfo JoinInfo.create(Query query, SimpleFeatureType featureType, JDBCDataStore dataStore)
           
protected  FilterToSQL JoiningJDBCFeatureSource.createFilterToSQL(SimpleFeatureType ft)
          Craete the filter to sql converter
protected  FilterToSQL JDBCDataStore.createFilterToSQL(SimpleFeatureType featureType)
          Creates a new instance of a filter to sql encoder.
protected  PreparedFilterToSQL JDBCDataStore.createPreparedFilterToSQL(SimpleFeatureType featureType)
          Creates a new instance of a filter to sql encoder to be used in a prepared statement.
 void JDBCDataStore.createSchema(SimpleFeatureType featureType)
          Creates a table in the underlying database from the specified table.
protected  String JDBCDataStore.createTableSQL(SimpleFeatureType featureType, Connection cx)
          Generates a 'CREATE TABLE' sql statement.
protected  void JDBCDataStore.delete(SimpleFeatureType featureType, Filter filter, Connection cx)
          Deletes an existing feature(s) in the database for a particular feature type / table.
protected  void JDBCDataStore.delete(SimpleFeatureType featureType, String fid, Connection cx)
          Deletes an existing feature in the database for a particular feature type / fid.
protected  String JDBCDataStore.deleteSQL(SimpleFeatureType featureType, Filter filter)
          Generates a 'DELETE FROM' sql statement.
protected  PreparedStatement JDBCDataStore.deleteSQLPS(SimpleFeatureType featureType, Filter filter, Connection cx)
          Generates a 'DELETE FROM' prepared statement.
 void SQLDialect.encodePostSelect(SimpleFeatureType featureType, StringBuffer sql)
          Encodes anything after the SELECT clause and before the FROM clause.
protected  void JDBCDataStore.encodeTableJoin(SimpleFeatureType featureType, JoinInfo join, Query query, StringBuffer sql)
          Helper method to encode the join clause(s) of a query.
protected  List<FilterToSQL> JDBCDataStore.encodeWhereJoin(SimpleFeatureType featureType, JoinInfo join, StringBuffer sql)
           
protected  void JDBCDataStore.ensureAuthorization(SimpleFeatureType featureType, Filter filter, Transaction tx, Connection cx)
          Ensures that that the specified transaction has access to features specified by a filter.
protected  String JDBCDataStore.findPrimaryKeyColumnName(SimpleFeatureType featureType)
           
protected  Object JDBCDataStore.getAggregateValue(FeatureVisitor visitor, SimpleFeatureType featureType, Query query, Connection cx)
          Results the value of an aggregate function over a query.
protected  ReferencedEnvelope JDBCDataStore.getBounds(SimpleFeatureType featureType, Query query, Connection cx)
          Returns the bounds of the features for a particular feature type / table.
protected  int JDBCDataStore.getCount(SimpleFeatureType featureType, Query query, Connection cx)
          Returns the count of the features for a particular feature type / table.
protected  SimpleFeatureType JoiningJDBCFeatureSource.getFeatureType(SimpleFeatureType origType, JoiningQuery query)
           
 List<ReferencedEnvelope> SQLDialect.getOptimizedBounds(String schema, SimpleFeatureType featureType, Connection cx)
          Returns the bounds of all geometry columns in the layer using any approach that proves to be faster than the plain bounds aggregation (e.g., better than the "plain select extent(geom) from table" on PostGIS), or null if none exists or the fast method has not been enabled (e.g., if the fast method is just an estimate of the bounds you probably want the user to enable it manually)
protected  PrimaryKey JDBCDataStore.getPrimaryKey(SimpleFeatureType featureType)
          Returns the primary key object for a particular feature type / table, deriving it from the underlying database metadata.
protected  String JDBCDataStore.getPropertyName(SimpleFeatureType featureType, PropertyName propertyName)
          Helper method for executing a property name against a feature type.
 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, Hints hints)
           
protected
<F extends FilterToSQL>
F
JDBCDataStore.initializeFilterToSQL(F toSQL, SimpleFeatureType featureType)
          Helper method to initialize a filter encoder instance.
protected  void JDBCDataStore.insert(Collection features, SimpleFeatureType featureType, Connection cx)
          Inserts a collection of new features into the database for a particular feature type / table.
protected  void JDBCDataStore.insert(SimpleFeature feature, SimpleFeatureType featureType, Connection cx)
          Inserts a new feature into the database for a particular feature type / table.
protected  String JDBCDataStore.insertSQL(SimpleFeatureType featureType, SimpleFeature feature, List keyValues, Connection cx)
          Generates a 'INSERT INFO' sql statement.
protected  PreparedStatement JDBCDataStore.insertSQLPS(SimpleFeatureType featureType, SimpleFeature feature, List keyValues, Connection cx)
          Generates a 'INSERT INFO' prepared statement.
protected  boolean JDBCDataStore.isExposePrimaryKeyColumns(SimpleFeatureType featureType)
          Returns the expose primary key columns flag for the specified feature type
 void PreparedStatementSQLDialect.onDelete(PreparedStatement delete, Connection cx, SimpleFeatureType featureType)
          Callback invoked before a DELETE statement is executed against the database.
 void BasicSQLDialect.onDelete(Statement delete, Connection cx, SimpleFeatureType featureType)
          Callback invoked before a DELETE statement is executed against the database.
 void PreparedStatementSQLDialect.onInsert(PreparedStatement insert, Connection cx, SimpleFeatureType featureType)
          Callback invoked before an INSERT statement is executed against the database.
 void BasicSQLDialect.onInsert(Statement insert, Connection cx, SimpleFeatureType featureType)
          Callback invoked before an INSERT statement is executed against the database.
 void PreparedStatementSQLDialect.onSelect(PreparedStatement select, Connection cx, SimpleFeatureType featureType)
          Callback invoked before a SELECT statement is executed against the database.
 void BasicSQLDialect.onSelect(Statement select, Connection cx, SimpleFeatureType featureType)
          Callback invoked before a SELECT statement is executed against the database.
 void PreparedStatementSQLDialect.onUpdate(PreparedStatement update, Connection cx, SimpleFeatureType featureType)
          Callback invoked before an UPDATE statement is executed against the database.
 void BasicSQLDialect.onUpdate(Statement update, Connection cx, SimpleFeatureType featureType)
          Callback invoked before an UPDATE statement is executed against the database.
 void SQLDialect.postCreateFeatureType(SimpleFeatureType featureType, DatabaseMetaData metadata, String schemaName, Connection cx)
          Callback which executes after a feature type has been built from a database table.
 void SQLDialect.postCreateTable(String schemaName, SimpleFeatureType featureType, Connection cx)
          Callback to execute any additional sql statements post a create table statement.
protected  String JDBCDataStore.selectAggregateSQL(String function, AttributeDescriptor att, SimpleFeatureType featureType, Query query)
          Generates a 'SELECT () FROM' statement.
protected  PreparedStatement JDBCDataStore.selectAggregateSQLPS(String function, AttributeDescriptor att, SimpleFeatureType featureType, Query query, Connection cx)
          Generates a 'SELECT () FROM' prepared statement.
protected  String JDBCDataStore.selectBoundsSQL(SimpleFeatureType featureType, Query query)
          Generates a 'SELECT' sql statement which selects bounds.
protected  PreparedStatement JDBCDataStore.selectBoundsSQLPS(SimpleFeatureType featureType, Query query, Connection cx)
          Generates a 'SELECT' prepared statement which selects bounds.
protected  String JDBCDataStore.selectCountSQL(SimpleFeatureType featureType, Query query)
          Generates a 'SELECT count(*) FROM' sql statement.
protected  PreparedStatement JDBCDataStore.selectCountSQLPS(SimpleFeatureType featureType, Query query, Connection cx)
          Generates a 'SELECT count(*) FROM' prepared statement.
protected  String JDBCDataStore.selectJoinSQL(SimpleFeatureType featureType, JoinInfo join, Query query)
           
protected  PreparedStatement JDBCDataStore.selectJoinSQLPS(SimpleFeatureType featureType, JoinInfo join, Query query, Connection cx)
           
protected  String JoiningJDBCFeatureSource.selectSQL(SimpleFeatureType featureType, JoiningQuery query, AtomicReference<PreparedFilterToSQL> toSQLref)
          Generates a 'SELECT p1, p2, ...
protected  String JDBCDataStore.selectSQL(SimpleFeatureType featureType, Query query)
          Generates a 'SELECT p1, p2, ...
protected  PreparedStatement JoiningJDBCFeatureSource.selectSQLPS(SimpleFeatureType featureType, JoiningQuery query, Connection cx)
          Generates a 'SELECT p1, p2, ...
protected  PreparedStatement JDBCDataStore.selectSQLPS(SimpleFeatureType featureType, Query query, Connection cx)
          Generates a 'SELECT p1, p2, ...
 void JoinInfo.JoinPart.setQueryFeatureType(SimpleFeatureType queryFeatureType)
           
 void JoinInfo.JoinPart.setReturnFeatureType(SimpleFeatureType returnFeatureType)
           
protected  void JDBCDataStore.update(SimpleFeatureType featureType, AttributeDescriptor[] attributes, Object[] values, Filter filter, Connection cx)
          Updates an existing feature(s) in the database for a particular feature type / table.
protected  void JDBCDataStore.update(SimpleFeatureType featureType, List<AttributeDescriptor> attributes, List<Object> values, Filter filter, Connection cx)
          Updates an existing feature(s) in the database for a particular feature type / table.
protected  String JDBCDataStore.updateSQL(SimpleFeatureType featureType, AttributeDescriptor[] attributes, Object[] values, Filter filter)
          Generates an 'UPDATE' sql statement.
protected  PreparedStatement JDBCDataStore.updateSQLPS(SimpleFeatureType featureType, AttributeDescriptor[] attributes, Object[] values, Filter filter, Connection cx)
          Generates an 'UPDATE' prepared statement.
 

Constructors in org.geotools.jdbc with parameters of type SimpleFeatureType
JDBCFeatureReader(PreparedStatement st, Connection cx, JDBCFeatureSource featureSource, SimpleFeatureType featureType, Hints hints)
           
JDBCFeatureReader(ResultSet rs, Connection cx, int offset, JDBCFeatureSource featureSource, SimpleFeatureType featureType, Hints hints)
           
JDBCFeatureReader(String sql, Connection cx, JDBCFeatureSource featureSource, SimpleFeatureType featureType, Hints hints)
           
JDBCJoiningFeatureReader(PreparedStatement st, Connection cx, JDBCFeatureSource featureSource, SimpleFeatureType featureType, JoinInfo join, Hints hints)
           
JDBCJoiningFeatureReader(String sql, Connection cx, JDBCFeatureSource featureSource, SimpleFeatureType featureType, JoinInfo join, Hints hints)
           
JoinPropertyName(SimpleFeatureType featureType, String alias, String name)
           
 

Uses of SimpleFeatureType in org.geotools.kml.bindings
 

Fields in org.geotools.kml.bindings declared as SimpleFeatureType
protected static SimpleFeatureType FeatureTypeBinding.FeatureType
          base feature type for kml features, used when no Schema element is specified
static SimpleFeatureType FolderTypeBinding.FeatureType
           
static SimpleFeatureType DocumentTypeBinding.FeatureType
           
 

Uses of SimpleFeatureType in org.geotools.kml.v22
 

Methods in org.geotools.kml.v22 that return SimpleFeatureType
 SimpleFeatureType SchemaRegistry.get(SimpleFeatureType featureType)
           
 SimpleFeatureType SchemaRegistry.get(String featureTypeName)
           
 

Methods in org.geotools.kml.v22 with parameters of type SimpleFeatureType
 void SchemaRegistry.add(String featureTypeName, SimpleFeatureType featureType)
           
 SimpleFeatureType SchemaRegistry.get(SimpleFeatureType featureType)
           
 

Uses of SimpleFeatureType in org.geotools.legend
 

Methods in org.geotools.legend that return SimpleFeatureType
 SimpleFeatureType Drawer.schema(String name, String spec)
          Create a SimpleFeatureType schema using a type short hand.
 

Methods in org.geotools.legend with parameters of type SimpleFeatureType
static BufferedImage Glyph.icon(SimpleFeatureType ft)
           
 Icon GlyphFactory.icon(SimpleFeatureType schema)
          Make a basic representation of the provided FeatureType.
 Icon DefaultGlyphFactory.icon(SimpleFeatureType schema)
           
 

Uses of SimpleFeatureType in org.geotools.process.feature
 

Methods in org.geotools.process.feature that return SimpleFeatureType
protected  SimpleFeatureType FeatureToFeatureProcess.getTargetSchema(SimpleFeatureType sourceSchema, Map<String,Object> input)
          Subclasses should override if the target schema is different that then original schema (mind, if the number of attributes changes it's better to roll your own class instead of using this one)
 

Methods in org.geotools.process.feature with parameters of type SimpleFeatureType
protected  SimpleFeatureType FeatureToFeatureProcess.getTargetSchema(SimpleFeatureType sourceSchema, Map<String,Object> input)
          Subclasses should override if the target schema is different that then original schema (mind, if the number of attributes changes it's better to roll your own class instead of using this one)
 

Uses of SimpleFeatureType in org.geotools.renderer.lite
 

Methods in org.geotools.renderer.lite that return types with arguments of type SimpleFeatureType
 FeatureReader<SimpleFeatureType,SimpleFeature> IndexedFeatureResults.reader()
           
 FeatureReader<SimpleFeatureType,SimpleFeature> IndexedFeatureResults.reader(Envelope envelope)
           
 

Uses of SimpleFeatureType in org.geotools.styling
 

Fields in org.geotools.styling declared as SimpleFeatureType
 SimpleFeatureType SLDInlineFeatureParser.featureType
           
 

Methods in org.geotools.styling that return SimpleFeatureType
 SimpleFeatureType UserLayerImpl.getInlineFeatureType()
           
 SimpleFeatureType UserLayer.getInlineFeatureType()
           
 

Methods in org.geotools.styling with parameters of type SimpleFeatureType
 Style StyleBuilder.buildClassifiedStyle(SimpleFeatureCollection fc, String name, String[] colors, SimpleFeatureType schema)
          given a feature collection and an array of colours build a style with the given number of classes on the named column
static FeatureTypeStyle SLD.featureTypeStyle(StyledLayerDescriptor sld, SimpleFeatureType type)
          Retrieve the first FeatureTypeStyle defined in the given StyledLayerDescriptor object that matches the specified feature type
static FeatureTypeStyle SLD.featureTypeStyle(Style style, SimpleFeatureType type)
          Returns the feature type style in the style which matched a particular name.
static Style SLD.matchingStyle(Style[] styles, SimpleFeatureType schema)
          Returns the first style object which matches a given schema.
 void UserLayerImpl.setInlineFeatureType(SimpleFeatureType ft)
           
 void UserLayer.setInlineFeatureType(SimpleFeatureType ft)
           
 

Uses of SimpleFeatureType in org.geotools.styling.builder
 

Methods in org.geotools.styling.builder with parameters of type SimpleFeatureType
 UserLayerBuilder UserLayerBuilder.inlineData(DataStore store, SimpleFeatureType sft)
           
 

Uses of SimpleFeatureType in org.geotools.swing.styling
 

Methods in org.geotools.swing.styling with parameters of type SimpleFeatureType
static Style JSimpleStyleDialog.showDialog(Component parent, SimpleFeatureType featureType)
          Static convenience method: displays a JSimpleStyleDialog to prompt the user for style preferences to use with the given feature type.
static Style JSimpleStyleDialog.showDialog(Component parent, SimpleFeatureType featureType, Style initialStyle)
          Static convenience method: displays a JSimpleStyleDialog to prompt the user for style preferences to use with the given feature type.
 

Constructors in org.geotools.swing.styling with parameters of type SimpleFeatureType
JSimpleStyleDialog(Dialog owner, SimpleFeatureType schema, Style initialStyle)
          Constructor.
JSimpleStyleDialog(Frame owner, SimpleFeatureType schema, Style initialStyle)
          Constructor.
 

Uses of SimpleFeatureType in org.geotools.swt.styling
 

Methods in org.geotools.swt.styling with parameters of type SimpleFeatureType
 Mode SimpleStyleConfigurator.determineMode(SimpleFeatureType schema, boolean askUser)
           
 

Uses of SimpleFeatureType in org.geotools.swt.styling.simple
 

Methods in org.geotools.swt.styling.simple with parameters of type SimpleFeatureType
static boolean SLDs.isLine(SimpleFeatureType featureType)
           
static boolean SLDs.isPoint(SimpleFeatureType featureType)
           
static boolean SLDs.isPolygon(SimpleFeatureType featureType)
           
 void LabelViewer.set(SimpleFeatureType schema, TextSymbolizer sym, Mode mode)
          Start editing the provided symbolizer.
 

Uses of SimpleFeatureType in org.geotools.validation
 

Methods in org.geotools.validation with parameters of type SimpleFeatureType
 boolean FeatureValidation.validate(SimpleFeature feature, SimpleFeatureType type, ValidationResults results)
          Used to check features against this validation rule.
 boolean DefaultFeatureValidation.validate(SimpleFeature feature, SimpleFeatureType type, ValidationResults results)
          Validation test for feature.
 

Uses of SimpleFeatureType in org.geotools.validation.attributes
 

Methods in org.geotools.validation.attributes with parameters of type SimpleFeatureType
 boolean SingleValueValidation.validate(SimpleFeature feature, SimpleFeatureType type, ValidationResults results)
          SingleValueValidation test for feature.
 boolean NullZeroValidation.validate(SimpleFeature feature, SimpleFeatureType type, ValidationResults results)
          Implement validate.
 boolean GazetteerNameValidation.validate(SimpleFeature feature, SimpleFeatureType type, ValidationResults results)
          Implementation of validate.
 boolean EqualityValidation.validate(SimpleFeature feature, SimpleFeatureType type, ValidationResults results)
          Validation test for feature.
 boolean SQLValidation.validate(SimpleFeature feature, SimpleFeatureType type, ValidationResults results)
          SQL Validation
 boolean AttributeValidation.validate(SimpleFeature feature, SimpleFeatureType type, ValidationResults results)
          Completes the specified comparison.
 boolean DomainValidation.validate(SimpleFeature feature, SimpleFeatureType type, ValidationResults results)
          Validation test for feature.
 boolean RangeValidation.validate(SimpleFeature feature, SimpleFeatureType type, ValidationResults results)
          Override validate.
 

Uses of SimpleFeatureType in org.geotools.validation.relate
 

Fields in org.geotools.validation.relate declared as SimpleFeatureType
protected  SimpleFeatureType SpatialTestCase.lineType
           
 

Methods in org.geotools.validation.relate with parameters of type SimpleFeatureType
static Filter OverlapsIntegrity.filterBBox(Envelope bBox, SimpleFeatureType ft)
          Try and Filter by the provided bbox, will default to Filter.EXCLUDE if null
 

Uses of SimpleFeatureType in org.geotools.validation.spatial
 

Methods in org.geotools.validation.spatial with parameters of type SimpleFeatureType
 boolean IsValidGeometryValidation.validate(SimpleFeature feature, SimpleFeatureType type, ValidationResults results)
          Tests to see if a geometry is valid by calling Geometry.isValid().
 boolean PolygonNoGapsValidation.validate(SimpleFeature feature, SimpleFeatureType type, ValidationResults results)
          Ensure Polygon does not have gaps.
 boolean LineNoSelfIntersectValidation.validate(SimpleFeature feature, SimpleFeatureType type, ValidationResults results)
          Override validate.
 boolean LineNoSelfOverlappingValidation.validate(SimpleFeature feature, SimpleFeatureType type, ValidationResults results)
          Tests to see if a LineString overlaps itself.
 boolean LineMustBeASinglePartValidation.validate(SimpleFeature feature, SimpleFeatureType type, ValidationResults results)
          Override validate.
 

Uses of SimpleFeatureType in org.geotools.wfs
 

Methods in org.geotools.wfs that return SimpleFeatureType
 SimpleFeatureType CompositeFeatureCollection.getSchema()
           
 

Uses of SimpleFeatureType in org.geotools.xml.gml
 

Fields in org.geotools.xml.gml declared as SimpleFeatureType
protected  SimpleFeatureType FCBuffer.ft
           
 

Methods in org.geotools.xml.gml that return SimpleFeatureType
static SimpleFeatureType GMLComplexTypes.createFeatureType(ComplexType element)
           
static SimpleFeatureType GMLComplexTypes.createFeatureType(Element element)
           
 SimpleFeatureType FCBuffer.getFeatureType()
          DOCUMENT ME!
 

Methods in org.geotools.xml.gml that return types with arguments of type SimpleFeatureType
static FeatureReader<SimpleFeatureType,SimpleFeature> FCBuffer.getFeatureReader(URI document, int capacity)
           The prefered method of using this class, this will return the Feature Reader for the document specified, using the specified buffer capacity.
static FeatureReader<SimpleFeatureType,SimpleFeature> FCBuffer.getFeatureReader(URI document, int capacity, int timeout)
           
static FeatureReader<SimpleFeatureType,SimpleFeature> FCBuffer.getFeatureReader(URI document, int capacity, int timeout, SimpleFeatureType ft)
           
static FeatureReader<SimpleFeatureType,SimpleFeature> FCBuffer.getFeatureReader(URI document, int capacity, SimpleFeatureType ft)
           
 

Methods in org.geotools.xml.gml with parameters of type SimpleFeatureType
 SimpleFeature GMLComplexTypes.AbstractFeatureType.getFeature(Element element, ElementValue[] value, Attributes attrs, Map hints, SimpleFeatureType ft)
           
static FeatureReader<SimpleFeatureType,SimpleFeature> FCBuffer.getFeatureReader(URI document, int capacity, int timeout, SimpleFeatureType ft)
           
static FeatureReader<SimpleFeatureType,SimpleFeature> FCBuffer.getFeatureReader(URI document, int capacity, SimpleFeatureType ft)
           
 

Constructors in org.geotools.xml.gml with parameters of type SimpleFeatureType
FCBuffer(URI document, int capacity, int timeout, SimpleFeatureType ft)
           
 

Uses of SimpleFeatureType in org.opengis.feature
 

Methods in org.opengis.feature with parameters of type SimpleFeatureType
 SimpleFeature FeatureFactory.createSimpleFeature(Object[] array, SimpleFeatureType type, String id)
          Create a SimpleFeature from an array of objects.
 

Uses of SimpleFeatureType in org.opengis.feature.simple
 

Methods in org.opengis.feature.simple that return SimpleFeatureType
 SimpleFeatureType SimpleFeature.getFeatureType()
          The type of the feature.
 SimpleFeatureType SimpleFeature.getType()
          Override and type narrow to SimpleFeatureType.
 

Uses of SimpleFeatureType in org.opengis.feature.type
 

Methods in org.opengis.feature.type that return SimpleFeatureType
 SimpleFeatureType FeatureTypeFactory.createSimpleFeatureType(Name name, List<AttributeDescriptor> schema, GeometryDescriptor defaultGeometry, boolean isAbstract, List<Filter> restrictions, AttributeType superType, InternationalString description)
          Creates a simple feature type.
 



Copyright © 1996-2014 Geotools. All Rights Reserved.