Package org.geotools.data.transform

Class SingleFeatureSourceDataStore

  • All Implemented Interfaces:
    DataAccess<SimpleFeatureType,​SimpleFeature>, DataStore
    public class SingleFeatureSourceDataStore
extends Object
implements DataStore
    A data store wrapped around a SimpleFeatureSource object. The store per se cannot do any kind of reads and writes, as the methods of the store are dealing with transactions per call, while the SimpleFeatureSource/SimpleFeatureStore implementations are dealing with them using a field, so in a stateful way, which means the Transaction provided in the parameters cannot be honored in a multi-threaded context. As a result the store won't do any attempt do to reads and writes, please use the source itself to do such operations, and treat transactions accordingly.

    • Constructor Detail

      • SingleFeatureSourceDataStore

        public SingleFeatureSourceDataStore​(SimpleFeatureSource fs)

    • Method Detail

      • getInfo

        public ServiceInfo getInfo()
        Description copied from interface: DataAccess
        Information about this service.

        This method offers access to a summary of header or metadata information describing the service. Subclasses may return a specific ServiceInfo instance that has additional information (such as FilterCapabilities).

        Specified by:
        getInfo in interface DataAccess<SimpleFeatureType,​SimpleFeature>
        Returns:
        SeviceInfo

      • getSchema

        public SimpleFeatureType getSchema​(Name name)
                            throws IOException
        Description copied from interface: DataAccess
        Description of the named resource.

        The FeatureType returned describes the contents being published. For additional metadata please review getInfo( Name ).

        Specified by:
        getSchema in interface DataAccess<SimpleFeatureType,​SimpleFeature>
        Parameters:
        name - Type name a the resource from getNames()
        Returns:
        Description of the FeatureType being made avaialble
        Throws:
        IOException

      • dispose

        public void dispose()
        Description copied from interface: DataAccess
        Disposes of this data store and releases any resource that it is using.

        A DataStore cannot be used after dispose has been called, neither can any data access object it helped create, such as FeatureReader, FeatureSource or FeatureCollection.

        This operation can be called more than once without side effects.

        There is no thread safety assurance associated with this method. For example, client code will have to make sure this method is not called while retrieving/saving data from/to the storage, or be prepared for the consequences.

        Specified by:
        dispose in interface DataAccess<SimpleFeatureType,​SimpleFeature>

      • updateSchema

        public void updateSchema​(String typeName,
                         SimpleFeatureType featureType)
                  throws IOException
        Description copied from interface: DataStore
        Applies a new schema to the given feature type. This can be used to add or remove properties. The resulting update will be persistent.
        Specified by:
        updateSchema in interface DataStore
        Parameters:
        typeName - name of the feature type to update
        featureType - the new schema to apply
        Throws:
        IOException - on error

      • removeSchema

        public void removeSchema​(Name typeName)
                  throws IOException
        Description copied from interface: DataAccess
        Used to permanently remove a schema from the underlying storage

        This functionality is similar to an "drop table" statement in SQL. Implementation is optional; it may not be supported by all servers or files.

        Specified by:
        removeSchema in interface DataAccess<SimpleFeatureType,​SimpleFeature>
        Throws:
        IOException - if the operation failed

      • removeSchema

        public void removeSchema​(String typeName)
                  throws IOException
        Description copied from interface: DataStore
        Used to permanently remove a schema from the underlying storage

        This functionality is similar to an "drop table" statement in SQL. Implementation is optional; it may not be supported by all servers or files.

        Specified by:
        removeSchema in interface DataStore
        Throws:
        IOException - if the operation failed

      • getTypeNames

        public String[] getTypeNames()
                      throws IOException
        Description copied from interface: DataStore
        Gets the names of feature types available in this DataStore. Please note that this is not guaranteed to return a list of unique names since the same unqualified name may be present in separate namespaces within the DataStore.
        Specified by:
        getTypeNames in interface DataStore
        Returns:
        names of feature types available in this DataStore
        Throws:
        IOException - if data access errors occur

      • getSchema

        public SimpleFeatureType getSchema​(String typeName)
                            throws IOException
        Description copied from interface: DataStore
        Gets the type information (schema) for the specified feature type.
        Specified by:
        getSchema in interface DataStore
        Parameters:
        typeName - the feature type name
        Returns:
        the requested feature type
        Throws:
        IOException - if typeName is not available

      • getFeatureSource

        public SimpleFeatureSource getFeatureSource​(String typeName)
                                     throws IOException
        Description copied from interface: DataStore
        Gets a SimpleFeatureSource for features of the specified type. SimpleFeatureSource provides a high-level API for feature operations.

        The resulting SimpleFeatureSource may implment more functionality as in this example: 

        

 SimpleFeatureSource fsource = dataStore.getFeatureSource("roads");
 if (fsource instanceof SimpleFeatureStore) {
     // we have write access to the feature data
     SimpleFeatureStore fstore = (SimpleFeatureStore) fs;
 }
 else {
     // System.out.println("We do not have write access to roads");
 }
        Specified by:
        getFeatureSource in interface DataStore
        Parameters:
        typeName - the feature type
        Returns:
        a SimpleFeatureSource (or possibly a subclass) providing operations for features of the specified type
        Throws:
        IOException - if data access errors occur
        See Also:
        SimpleFeatureSource, SimpleFeatureStore

      • getFeatureReader

        public FeatureReader<SimpleFeatureType,​SimpleFeature> getFeatureReader​(Query query,
                                                                             Transaction transaction)
                                                                      throws IOException
        Description copied from interface: DataStore
        Gets a FeatureReader for features selected by the given Query. FeatureReader provies an iterator-style API to feature data.

        The Query provides the schema for the form of the returned features as well as a Filter to constrain the features available via the reader.

        The Transaction can be used to externalize the state of the DataStore. Examples of this include a JDBCDataStore sharing a connection for use across several FeatureReader requests; and a ShapefileDataStore redirecting requests to an alternate file during the course of a Transaction.

        Specified by:
        getFeatureReader in interface DataStore
        Parameters:
        query - a query providing the schema and constraints for features that the reader will return
        transaction - a transaction that this reader will operate against
        Returns:
        an instance of FeatureReader
        Throws:
        IOException - if data access errors occur

      • getFeatureWriterAppend

        public FeatureWriter<SimpleFeatureType,​SimpleFeature> getFeatureWriterAppend​(String typeName,
                                                                                   Transaction transaction)
                                                                            throws IOException
        Description copied from interface: DataStore
        Gets a FeatureWriter that can add new features to the DataStore.

        The FeatureWriter will return false when its hasNext() method is called, but next() can be used to acquire new features.

        Specified by:
        getFeatureWriterAppend in interface DataStore
        Parameters:
        typeName - name of the feature type for which features will be added
        transaction - the transaction to operate against
        Returns:
        an instance of FeatureWriter that can only be used to append new features
        Throws:
        IOException - if data access errors occur

      • getLockingManager

        public LockingManager getLockingManager()
        Description copied from interface: DataStore
        Retrieve a per featureID based locking service from this DataStore.
        Specified by:
        getLockingManager in interface DataStore
        Returns:
        an instance of LockingManager; or null if locking is handled by the DataStore in a different fashion