/*
* GeoTools - The Open Source Java GIS Toolkit
* http://geotools.org
*
* (C) 2004-2008, Open Source Geospatial Foundation (OSGeo)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*/
package org.geotools.data.store;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.NoSuchElementException;
import java.util.Set;
import java.util.logging.Level;
import java.util.logging.Logger;
import org.geotools.data.FeatureReader;
import org.geotools.data.FeatureWriter;
import org.geotools.data.collection.DelegateFeatureReader;
import org.geotools.data.simple.SimpleFeatureCollection;
import org.geotools.data.simple.SimpleFeatureIterator;
import org.geotools.feature.CollectionEvent;
import org.geotools.feature.CollectionListener;
import org.geotools.feature.FeatureCollection;
import org.geotools.feature.FeatureIterator;
import org.geotools.feature.FeatureReaderIterator;
import org.geotools.feature.collection.DelegateSimpleFeatureIterator;
import org.geotools.feature.collection.SubFeatureCollection;
import org.geotools.filter.SortBy2;
import org.geotools.geometry.jts.ReferencedEnvelope;
import org.geotools.util.NullProgressListener;
import org.opengis.feature.Feature;
import org.opengis.feature.IllegalAttributeException;
import org.opengis.feature.simple.SimpleFeature;
import org.opengis.feature.simple.SimpleFeatureType;
import org.opengis.filter.Filter;
import org.opengis.filter.sort.SortBy;
/**
* A starting point for implementing FeatureCollection's backed onto a FeatureReader.
* <p>
* This implementation requires you to implement the following:
* <ul>
* <li>getSchema() - this should match reader.getSchema()
* <li>reader()</br>
* features() - override one of these two method to access content
* <li>getBounds()
* <li>getCount()
* <li>collection()
* </p>
* <p>
* This class will implement the 'extra' methods required by FeatureCollection
* for you (in simple terms based on the FeatureResults API). Anything that is
* <i>often</i> customised is available to you as a constructor parameters.
* <p>
* Enjoy.
* </p>
* @author jgarnett
* @since 2.1.RC0
*
* @source $URL$
*/
public abstract class DataFeatureCollection implements SimpleFeatureCollection {
/** logger */
static Logger LOGGER = org.geotools.util.logging.Logging.getLogger( "org.geotools.data" );
static private int unique = 0;
/**
* Collection based on a generic collection
*/
protected DataFeatureCollection(){
this( "features"+(unique++) );
}
/**
* Collection based on a generic collection
*/
protected DataFeatureCollection( String id ){
this(id,null);
}
/** Subclass must think about what consitructors it needs. */
protected DataFeatureCollection( String id, SimpleFeatureType memberType ){
this.id = id == null ? "featureCollection" : id;
this.schema = memberType;
}
/**
* To let listeners know that something has changed.
*/
protected void fireChange(SimpleFeature[] features, int type) {
CollectionEvent cEvent = new CollectionEvent(this, features, type);
for (int i = 0, ii = listeners.size(); i < ii; i++) {
((CollectionListener) listeners.get(i)).collectionChanged(cEvent);
}
}
protected void fireChange(SimpleFeature feature, int type) {
fireChange(new SimpleFeature[] {feature}, type);
}
protected void fireChange(Collection coll, int type) {
SimpleFeature[] features = new SimpleFeature[coll.size()];
features = (SimpleFeature[]) coll.toArray(features);
fireChange(features, type);
}
public FeatureReader<SimpleFeatureType, SimpleFeature> reader() throws IOException {
return new DelegateFeatureReader<SimpleFeatureType, SimpleFeature>( getSchema(), features() );
}
//
// Feature Results methods
//
// To be implemented by subclass
//
public abstract ReferencedEnvelope getBounds();
public abstract int getCount() throws IOException;;
//public abstract SimpleFeatureCollection collection() throws IOException;
//
// Additional Subclass "hooks"
//
/**
* Subclass may provide an implementation of this method to indicate
* that read/write support is provided.
* <p>
* All operations that attempt to modify the "data" will
* use this method, allowing them to throw an "UnsupportedOperationException"
* in the same manner as Collections.unmodifiableCollection(Collection c), or just
* return null.
* </p>
* @throws UnsupportedOperationException To indicate that write support is not avaiable
* @return the writer, or null if write support is not available
*/
protected FeatureWriter<SimpleFeatureType, SimpleFeature> writer() throws IOException {
return null;
}
//
// SimpleFeatureCollection methods
//
// implemented in terms of feature results
//
//
// Content Access
//
/** Set of open resource iterators & featureIterators */
private final Set open = new HashSet();
/**
* listeners
*/
protected List listeners = new ArrayList();
/**
* id used when serialized to gml
*/
protected String id;
protected SimpleFeatureType schema;
/**
* SimpleFeatureIterator is entirely based on iterator().
* <p>
* So when we implement FeatureCollection.iterator() this will work
* out of the box.
*/
public SimpleFeatureIterator features() {
SimpleFeatureIterator iterator = new DelegateSimpleFeatureIterator( this, iterator() );
open.add( iterator );
return iterator;
}
/**
* Iterator may (or may) not support modification.
*/
final public Iterator<SimpleFeature> iterator() {
Iterator<SimpleFeature> iterator;
try {
iterator = openIterator();
}
catch (IOException e) {
throw new RuntimeException( e );
}
open.add( iterator );
return iterator;
}
/**
* Returns a FeatureWriterIterator, or FeatureReaderIterator over content.
* <p>
* If you have a way to tell that you are readonly please subclass with
* a less hardcore check - this implementations catches a
* UnsupportedOpperationsException from wrtier()!
*
* @return Iterator, should be closed closeIterator
*/
protected Iterator<SimpleFeature> openIterator() throws IOException
{
try {
FeatureWriter writer = writer();
if(writer != null) {
return new FeatureWriterIterator( writer() );
}
} catch (IOException badWriter) {
return new NoContentIterator( badWriter );
} catch( UnsupportedOperationException readOnly ){
}
try {
return new FeatureReaderIterator( reader() );
} catch (IOException e) {
return new NoContentIterator( e );
}
}
final public void close( Iterator<SimpleFeature> close ) {
try {
closeIterator( close );
}
catch (IOException e) {
LOGGER.log( Level.WARNING, "Error closing iterator", e );
}
open.remove( close );
}
protected void closeIterator( Iterator<SimpleFeature> close ) throws IOException
{
if( close == null ){
// iterator probably failed during consturction !
}
else if( close instanceof FeatureReaderIterator ){
FeatureReaderIterator<SimpleFeature> iterator = (FeatureReaderIterator<SimpleFeature>) close;
iterator.close(); // only needs package visability
}
else if( close instanceof FeatureWriterIterator ){
FeatureWriterIterator iterator = (FeatureWriterIterator) close;
iterator.close(); // only needs package visability
}
}
public void close( FeatureIterator<SimpleFeature> iterator) {
iterator.close();
open.remove( iterator );
}
/** Default implementation based on getCount() - this may be expensive */
public int size() {
try {
return getCount();
} catch (IOException e) {
if (LOGGER.isLoggable(Level.FINE))
LOGGER.log(Level.FINE, "IOException while calculating size() of FeatureCollection", e);
return 0;
}
}
public void purge(){
for( Iterator i = open.iterator(); i.hasNext(); ){
Object iterator = i.next();
try {
if( iterator instanceof Iterator ){
closeIterator( (Iterator) iterator );
}
if( iterator instanceof FeatureIterator){
( (SimpleFeatureIterator) iterator ).close();
}
}
catch( Throwable e){
// TODO: Log e = ln
}
finally {
i.remove();
}
}
}
//
// Off into implementation land!
//
/**
* Default implementation based on creating an reader, testing hasNext, and closing.
* <p>
* For once the Collections API does not give us an escape route, we *have* to check the data.
* </p>
*/
public boolean isEmpty() {
FeatureReader<SimpleFeatureType, SimpleFeature> reader = null;
try {
reader = reader();
try {
return !reader.hasNext();
} catch (IOException e) {
return true; // error seems like no features are available
}
} catch (IOException e) {
return true;
}
finally {
if( reader != null ){
try {
reader.close();
} catch (IOException e) {
// return value already set
}
}
}
}
public boolean contains( Object o ) {
if( !(o instanceof SimpleFeature) ) return false;
SimpleFeature value = (SimpleFeature) o;
String ID = value.getID();
FeatureReader<SimpleFeatureType, SimpleFeature> reader = null;
try {
reader = reader();
try {
while( reader.hasNext() ){
SimpleFeature feature = reader.next();
if( !ID.equals( feature.getID() )){
continue; // skip with out full equal check
}
if( value.equals( feature )) return true;
}
return false; // not found
} catch (IOException e) {
return false; // error seems like no features are available
} catch (NoSuchElementException e) {
return false; // error seems like no features are available
} catch (IllegalAttributeException e) {
return false; // error seems like no features are available
}
} catch (IOException e) {
return false;
}
finally {
if( reader != null ){
try {
reader.close();
} catch (IOException e) {
// return value already set
}
}
}
}
public Object[] toArray() {
return toArray( new SimpleFeature[ size() ]);
}
public Object[] toArray( Object[] array ) {
List list = new ArrayList();
Iterator i = iterator();
try {
while( i.hasNext() ){
list.add( i.next() );
}
}
finally {
close( i );
}
return list.toArray( array );
}
public boolean add( SimpleFeature arg0 ) {
return false;
}
public boolean remove( Object arg0 ) {
return false;
}
public boolean containsAll( Collection<?> collection ) {
for (Object o: collection) {
if (contains(o)==false) return false;
}
return true;
}
/**
* Optimized implementation of addAll that recognizes the
* use of collections obtained with subCollection( filter ).
* <p>
* This method is constructed by either:
* <ul>
* <li>Filter OR
* <li>Removing an extact match of Filter AND
* </ul>
*
*/
public boolean addAll(Collection collection) {
if( collection instanceof FeatureCollection ){
return addAll( (FeatureCollection<?,?>) collection );
}
try {
FeatureWriter writer = writer();
if(writer == null) {
return false;
}
try {
// skip to end
while( writer.hasNext() ){
Feature feature = writer.next();
}
for( Object obj : collection ){
if( obj instanceof SimpleFeature){
SimpleFeature copy = (SimpleFeature) obj;
SimpleFeature feature = (SimpleFeature) writer.next();
feature.setAttributes( copy.getAttributes() );
writer.write();
}
}
}
finally {
if( writer != null ) writer.close();
}
return true;
}
catch( IOException ignore ){
return false;
}
}
public boolean addAll(FeatureCollection resource) {
return false;
}
public boolean removeAll( Collection arg0 ) {
return false;
}
public boolean retainAll( Collection arg0 ) {
return false;
}
public void clear() {
}
public void accepts(org.opengis.feature.FeatureVisitor visitor, org.opengis.util.ProgressListener progress) {
Iterator iterator = null;
if (progress == null) progress = new NullProgressListener();
try{
float size = size();
float position = 0;
progress.started();
for( iterator = iterator(); !progress.isCanceled() && iterator.hasNext(); progress.progress( 100.0f * position++ / size )){
try {
SimpleFeature feature = (SimpleFeature) iterator.next();
visitor.visit(feature);
}
catch( Exception erp ){
progress.exceptionOccurred( erp );
}
}
}
finally {
progress.complete();
close( iterator );
}
}
/**
* Will return an optimized subCollection based on access
* to the origional FeatureSource.
* <p>
* The subCollection is constructed by using an AND Filter.
* For the converse of this opperation please see
* collection.addAll( Collection ), it has been optimized
* to be aware of these filter based SubCollections.
* </p>
* <p>
* This method is intended in a manner similar to subList,
* example use:
* <code>
* collection.subCollection( myFilter ).clear()
* </code>
* </p>
* @param filter Filter used to determine sub collection.
* @since GeoTools 2.2, Filter 1.1
*/
public SimpleFeatureCollection subCollection(Filter filter) {
if( filter == Filter.INCLUDE ){
return this;
}
return new SubFeatureCollection( this, filter );
}
/**
* Construct a sorted view of this content.
* <p>
* Sorts may be combined togther in a stable fashion, in congruence
* with the Filter 1.1 specification.
* </p>
* This method should also be able to handle GeoTools specific
* sorting through detecting order as a SortBy2 instance.
*
* @param order
*
* @since GeoTools 2.2, Filter 1.1
* @return FeatureList sorted according to provided order
*/
public SimpleFeatureCollection sort(SortBy order) {
if( order instanceof SortBy2){
SortBy2 advanced = (SortBy2) order;
return sort( advanced );
}
return null; // new OrderedFeatureList( this, order );
}
/**
* Allows for "Advanced" sort capabilities specific to the
* GeoTools platform!
* <p>
* Advanced in this case really means making use of a generic
* Expression, rather then being limited to PropertyName.
* </p>
* @param order GeoTools SortBy
* @return FeatureList sorted according to provided order
*/
public SimpleFeatureCollection sort(SortBy2 order ){
return null;
}
public String getID() {
return id;
}
public final void addListener(CollectionListener listener) throws NullPointerException {
listeners.add(listener);
}
public final void removeListener(CollectionListener listener)
throws NullPointerException {
listeners.remove(listener);
}
public SimpleFeatureType getSchema() {
return schema;
}
}