org.geotools.data.directory
Class DirectoryDataStore

Object
  extended by DirectoryDataStore
All Implemented Interfaces:
DataAccess<SimpleFeatureType,SimpleFeature>, DataStore

public class DirectoryDataStore
extends Object
implements DataStore


Constructor Summary
DirectoryDataStore(File directory, FileStoreFactory dialect)
           
 
Method Summary
 void createSchema(SimpleFeatureType featureType)
          Creates storage for a new featureType.
 void dispose()
          Disposes of this data store and releases any resource that it is using.
 DataStore getDataStore(String typeName)
          Returns the native store for a specified type name
 FeatureReader<SimpleFeatureType,SimpleFeature> getFeatureReader(Query query, Transaction transaction)
          Gets a FeatureReader for features selected by the given Query.
 SimpleFeatureSource getFeatureSource(Name typeName)
          Gets a SimpleFeatureSource for features of the type specified by a qualified name (namespace plus type name).
 SimpleFeatureSource getFeatureSource(String typeName)
          Gets a SimpleFeatureSource for features of the specified type.
 FeatureWriter<SimpleFeatureType,SimpleFeature> getFeatureWriter(String typeName, Filter filter, Transaction transaction)
          Gets a FeatureWriter to modify features in this DataStore.
 FeatureWriter<SimpleFeatureType,SimpleFeature> getFeatureWriter(String typeName, Transaction transaction)
          Gets a FeatureWriter to modify features in this DataStore.
 FeatureWriter<SimpleFeatureType,SimpleFeature> getFeatureWriterAppend(String typeName, Transaction transaction)
          Gets a FeatureWriter that can add new features to the DataStore.
 ServiceInfo getInfo()
          Information about this service.
 LockingManager getLockingManager()
          Retrieve a per featureID based locking service from this DataStore.
 List<Name> getNames()
          Names of the available Resources.
 SimpleFeatureType getSchema(Name name)
          Description of the named resource.
 SimpleFeatureType getSchema(String typeName)
          Gets the type information (schema) for the specified feature type.
 String[] getTypeNames()
          Gets the names of feature types available in this DataStore.
 void removeSchema(Name name)
          Used to permanently remove a schema from the underlying storage This functionality is similar to an "drop table" statement in SQL.
 void removeSchema(String name)
          Used to permanently remove a schema from the underlying storage This functionality is similar to an "drop table" statement in SQL.
 void updateSchema(Name typeName, SimpleFeatureType featureType)
          Used to update a schema in place.
 void updateSchema(String typeName, SimpleFeatureType featureType)
          Applies a new schema to the given feature type.
 
Methods inherited from class Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

DirectoryDataStore

public DirectoryDataStore(File directory,
                          FileStoreFactory dialect)
                   throws IOException
Throws:
IOException
Method Detail

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

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

getFeatureWriter

public FeatureWriter<SimpleFeatureType,SimpleFeature> getFeatureWriter(String typeName,
                                                                       Filter filter,
                                                                       Transaction transaction)
                                                                throws IOException
Description copied from interface: DataStore
Gets a FeatureWriter to modify features in this DataStore. FeatureWriter provides an iterator style API to features.

The returned writer does not allow features to be added.

Specified by:
getFeatureWriter in interface DataStore
Parameters:
typeName - the type name for features that will be accessible
filter - defines additional constraints on the features that will be accessible
transaction - the transation that the returned writer operates against
Returns:
an instance of FeatureWriter
Throws:
IOException - if data access errors occur
See Also:
DataStore.getFeatureWriterAppend(String, Transaction)

getFeatureWriter

public FeatureWriter<SimpleFeatureType,SimpleFeature> getFeatureWriter(String typeName,
                                                                       Transaction transaction)
                                                                throws IOException
Description copied from interface: DataStore
Gets a FeatureWriter to modify features in this DataStore. FeatureWriter provides an iterator style API to features.

The returned writer does not allow features to be added.

Specified by:
getFeatureWriter in interface DataStore
Parameters:
typeName - the type name for features that will be accessible
transaction - the transation that the returned writer operates against
Returns:
an instance of FeatureWriter
Throws:
IOException - if data access errors occur
See Also:
DataStore.getFeatureWriterAppend(String, Transaction)

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

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

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

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

createSchema

public void createSchema(SimpleFeatureType featureType)
                  throws IOException
Description copied from interface: DataAccess
Creates storage for a new featureType.

The provided featureType we be accessable by the typeName provided by featureType.getTypeName().

Specified by:
createSchema in interface DataAccess<SimpleFeatureType,SimpleFeature>
Parameters:
featureType - FetureType to add to DataStore
Throws:
IOException - If featureType cannot be created

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>

getFeatureSource

public SimpleFeatureSource getFeatureSource(Name typeName)
                                     throws IOException
Description copied from interface: DataStore
Gets a SimpleFeatureSource for features of the type specified by a qualified name (namespace plus type name).

Specified by:
getFeatureSource in interface DataAccess<SimpleFeatureType,SimpleFeature>
Specified by:
getFeatureSource in interface DataStore
Parameters:
typeName - the qualified name of 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:
DataStore.getFeatureSource(String), SimpleFeatureSource, SimpleFeatureStore

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

getNames

public List<Name> getNames()
                    throws IOException
Description copied from interface: DataAccess
Names of the available Resources.

For additional information please see getInfo( Name ) and getSchema( Name ).

Specified by:
getNames in interface DataAccess<SimpleFeatureType,SimpleFeature>
Returns:
Names of the available contents.
Throws:
IOException

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

updateSchema

public void updateSchema(Name typeName,
                         SimpleFeatureType featureType)
                  throws IOException
Description copied from interface: DataAccess
Used to update a schema in place.

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

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

getDataStore

public DataStore getDataStore(String typeName)
                       throws IOException
Returns the native store for a specified type name

Parameters:
typeName -
Returns:
Throws:
IOException

removeSchema

public void removeSchema(Name name)
                  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 name)
                  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


Copyright © 1996-2014 Geotools. All Rights Reserved.