|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
ObjectSingleFeatureSourceDataStore
public class SingleFeatureSourceDataStore
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 Summary | |
---|---|
SingleFeatureSourceDataStore(SimpleFeatureSource fs)
|
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. |
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 typeName)
Used to permanently remove a schema from the underlying storage This functionality is similar to an "drop table" statement in SQL. |
void |
removeSchema(String typeName)
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 |
---|
public SingleFeatureSourceDataStore(SimpleFeatureSource fs)
Method Detail |
---|
public ServiceInfo getInfo()
DataAccess
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).
getInfo
in interface DataAccess<SimpleFeatureType,SimpleFeature>
public void createSchema(SimpleFeatureType featureType) throws IOException
DataAccess
featureType
.
The provided featureType
we be accessable by the typeName
provided by featureType.getTypeName().
createSchema
in interface DataAccess<SimpleFeatureType,SimpleFeature>
featureType
- FetureType to add to DataStore
IOException
- If featureType cannot be createdpublic void updateSchema(Name typeName, SimpleFeatureType featureType) throws IOException
DataAccess
This functionality is similar to an "alter table" statement in SQL. Implementation is optional; it may not be supported by all servers or files.
updateSchema
in interface DataAccess<SimpleFeatureType,SimpleFeature>
IOException
- if the operation failedpublic List<Name> getNames() throws IOException
DataAccess
For additional information please see getInfo( Name ) and getSchema( Name ).
getNames
in interface DataAccess<SimpleFeatureType,SimpleFeature>
IOException
public SimpleFeatureType getSchema(Name name) throws IOException
DataAccess
The FeatureType returned describes the contents being published. For additional metadata please review getInfo( Name ).
getSchema
in interface DataAccess<SimpleFeatureType,SimpleFeature>
name
- Type name a the resource from getNames()
IOException
public void dispose()
DataAccess
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.
dispose
in interface DataAccess<SimpleFeatureType,SimpleFeature>
public void updateSchema(String typeName, SimpleFeatureType featureType) throws IOException
DataStore
updateSchema
in interface DataStore
typeName
- name of the feature type to updatefeatureType
- the new schema to apply
IOException
- on errorpublic void removeSchema(Name typeName) throws IOException
DataAccess
This functionality is similar to an "drop table" statement in SQL. Implementation is optional; it may not be supported by all servers or files.
removeSchema
in interface DataAccess<SimpleFeatureType,SimpleFeature>
IOException
- if the operation failedpublic void removeSchema(String typeName) throws IOException
DataStore
This functionality is similar to an "drop table" statement in SQL. Implementation is optional; it may not be supported by all servers or files.
removeSchema
in interface DataStore
IOException
- if the operation failedpublic String[] getTypeNames() throws IOException
DataStore
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
.
getTypeNames
in interface DataStore
DataStore
IOException
- if data access errors occurpublic SimpleFeatureType getSchema(String typeName) throws IOException
DataStore
getSchema
in interface DataStore
typeName
- the feature type name
IOException
- if typeName
is not availablepublic SimpleFeatureSource getFeatureSource(String typeName) throws IOException
DataStore
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");
}
getFeatureSource
in interface DataStore
typeName
- the feature type
SimpleFeatureSource
(or possibly a subclass) providing
operations for features of the specified type
IOException
- if data access errors occurSimpleFeatureSource
,
SimpleFeatureStore
public SimpleFeatureSource getFeatureSource(Name typeName) throws IOException
DataStore
SimpleFeatureSource
for features of the type
specified by a qualified name (namespace plus type name).
getFeatureSource
in interface DataAccess<SimpleFeatureType,SimpleFeature>
getFeatureSource
in interface DataStore
typeName
- the qualified name of the feature type
SimpleFeatureSource
(or possibly a subclass) providing
operations for features of the specified type
IOException
- if data access errors occurDataStore.getFeatureSource(String)
,
SimpleFeatureSource
,
SimpleFeatureStore
public FeatureReader<SimpleFeatureType,SimpleFeature> getFeatureReader(Query query, Transaction transaction) throws IOException
DataStore
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
.
getFeatureReader
in interface DataStore
query
- a query providing the schema and constraints for
features that the reader will returntransaction
- a transaction that this reader will operate against
FeatureReader
IOException
- if data access errors occurpublic FeatureWriter<SimpleFeatureType,SimpleFeature> getFeatureWriter(String typeName, Filter filter, Transaction transaction) throws IOException
DataStore
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.
getFeatureWriter
in interface DataStore
typeName
- the type name for features that will be accessiblefilter
- defines additional constraints on the features that will
be accessibletransaction
- the transation that the returned writer operates
against
FeatureWriter
IOException
- if data access errors occurDataStore.getFeatureWriterAppend(String, Transaction)
public FeatureWriter<SimpleFeatureType,SimpleFeature> getFeatureWriter(String typeName, Transaction transaction) throws IOException
DataStore
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.
getFeatureWriter
in interface DataStore
typeName
- the type name for features that will be accessibletransaction
- the transation that the returned writer operates
against
FeatureWriter
IOException
- if data access errors occurDataStore.getFeatureWriterAppend(String, Transaction)
public FeatureWriter<SimpleFeatureType,SimpleFeature> getFeatureWriterAppend(String typeName, Transaction transaction) throws IOException
DataStore
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.
getFeatureWriterAppend
in interface DataStore
typeName
- name of the feature type for which features will be addedtransaction
- the transaction to operate against
FeatureWriter
that can only be used to
append new features
IOException
- if data access errors occurpublic LockingManager getLockingManager()
DataStore
DataStore
.
getLockingManager
in interface DataStore
LockingManager
; or null
if locking
is handled by the DataStore
in a different fashion
|
||||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |