/*
* Geotoolkit - An Open Source Java GIS Toolkit
* http://www.geotoolkit.org
*
* (C) 2009, Geomatys
*
* 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.geotoolkit.data.memory;
import java.io.Closeable;
import java.io.IOException;
import java.util.Iterator;
import java.util.logging.Level;
import org.geotoolkit.data.FeatureIterator;
import org.geotoolkit.data.FeatureReader;
import org.geotoolkit.data.FeatureStoreRuntimeException;
import org.geotoolkit.data.FeatureWriter;
import org.apache.sis.util.Classes;
import org.apache.sis.util.logging.Logging;
import org.opengis.feature.Feature;
import org.opengis.feature.FeatureType;
/**
* Basic support for a FeatureIterator that delegate to a standard java iterator.
*
* @author Johann Sorel (Geomatys)
* @module
*/
public class GenericWrapFeatureIterator implements FeatureIterator {
protected final Iterator<? extends Feature> iterator;
/**
* Creates a new instance of GenericWrapFeatureIterator
*
* @param iterator FeatureReader to limit
* @param maxFeatures maximum number of feature
*/
private GenericWrapFeatureIterator(final Iterator<? extends Feature> iterator) {
this.iterator = iterator;
}
/**
* {@inheritDoc }
*/
@Override
public Feature next() throws FeatureStoreRuntimeException {
return iterator.next();
}
/**
* {@inheritDoc }
*
* This implementation does nothing since standard iterator dont have a close
* method.
*/
@Override
public void close() throws FeatureStoreRuntimeException {
if (iterator instanceof Closeable) {
try {
((Closeable) iterator).close();
} catch (IOException ex) {
Logging.getLogger("org.geotoolkit.data.memory").log(Level.WARNING, null, ex);
}
}
}
/**
* {@inheritDoc }
*/
@Override
public boolean hasNext() throws FeatureStoreRuntimeException {
return iterator.hasNext();
}
/**
* {@inheritDoc }
*/
@Override
public void remove() {
iterator.remove();
}
@Override
public String toString() {
final StringBuilder sb = new StringBuilder(Classes.getShortClassName(this));
sb.append('\n');
String subIterator = "\u2514\u2500\u2500" + iterator.toString(); //move text to the right
subIterator = subIterator.replaceAll("\n", "\n\u00A0\u00A0\u00A0"); //move text to the right
sb.append(subIterator);
return sb.toString();
}
/**
* Wrap an Iterator as a FeatureReader.
*
* @param <T> extends FeatureType
* @param <F> extends Feature
* @param <R> extends FeatureReader<T,F>
*/
private static final class GenericWrapFeatureReader extends GenericWrapFeatureIterator implements FeatureReader{
private final FeatureType type;
private GenericWrapFeatureReader(final Iterator<? extends Feature> ite, final FeatureType type){
super(ite);
this.type = type;
}
@Override
public FeatureType getFeatureType() {
return type;
}
}
/**
* Wrap an Iterator as a FeatureWriter.
*
* @param <T> extends FeatureType
* @param <F> extends Feature
* @param <R> extends FeatureWriter<T,F>
*/
private static final class GenericWrapFeatureWriter extends GenericWrapFeatureIterator implements FeatureWriter{
private final FeatureType type;
private GenericWrapFeatureWriter(final Iterator<? extends Feature> iterator, final FeatureType type){
super(iterator);
this.type = type;
}
@Override
public FeatureType getFeatureType() {
return type;
}
@Override
public void write() throws FeatureStoreRuntimeException {
throw new FeatureStoreRuntimeException("Can not write on a wrapped iterator.");
}
}
/**
* Wrap an Iterator as a FeatureIterator.
*/
public static FeatureIterator wrapToIterator(final Iterator<? extends Feature> reader){
return new GenericWrapFeatureIterator(reader);
}
/**
* Wrap an Iterator as a FeatureReader.
*/
public static FeatureReader wrapToReader(final Iterator<? extends Feature> reader, final FeatureType type){
return new GenericWrapFeatureReader(reader, type);
}
/**
* Wrap an Iterator as a FeatureWriter.
*/
public static FeatureWriter wrapToWriter(final Iterator<? extends Feature> writer, final FeatureType type){
return new GenericWrapFeatureWriter(writer, type);
}
}