Menu
▾
▴
[Geotools-commits] svn - r38370 - in trunk/modules/unsupported/property-ng/src: main/java/org/geotools/data/property main/java/org/geotools/data/property/ng test/java/org/geotools/data/property test/java/org/geotools/data/property/ng
Author: jive Date: 2011-11-22 22:23:42 -0800 (Tue, 22 Nov 2011) New Revision: 38370 Added: trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/ trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyAttributeWriter.java trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyDataStore.java trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyDataStoreFactory.java trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyFeatureReader.java trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyFeatureSource.java trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyFeatureStore.java trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyFeatureWriter.java trunk/modules/unsupported/property-ng/src/test/java/org/geotools/data/property/ng/ trunk/modules/unsupported/property-ng/src/test/java/org/geotools/data/property/ng/PropertyDataStore2Test.java trunk/modules/unsupported/property-ng/src/test/java/org/geotools/data/property/ng/PropertyDataStoreTest.java trunk/modules/unsupported/property-ng/src/test/java/org/geotools/data/property/ng/PropertyExamples.java Log: moved into property/ng folder Added: trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyAttributeWriter.java =================================================================== --- trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyAttributeWriter.java (rev 0) +++ trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyAttributeWriter.java 2011-11-23 06:23:42 UTC (rev 38370) @@ -0,0 +1,152 @@ +/* + * GeoTools - The Open Source Java GIS Toolkit + * http://geotools.org + * + * (C) 2002-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.property.ng; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; + +import org.geotools.data.AttributeWriter; +import org.geotools.data.DataUtilities; +import org.geotools.util.Converters; +import org.opengis.feature.simple.SimpleFeatureType; +import org.opengis.feature.type.AttributeDescriptor; + +import com.vividsolutions.jts.geom.Geometry; + +/** + * Simple AttributeWriter that produces Java properties files. + * <p> + * This AttributeWriter is part of the geotools2 DataStore tutorial, and should + * be considered a Toy. + * </p> + * <p> + * The content produced witll start with the property "_" with the value being + * the typeSpec describing the featureType. Thereafter each line will represent + * a Features with FeatureID as the property and the attribtues as the value + * separated by | characters. + * </p> + * + * <pre> + * <code> + * _=id:Integer|name:String|geom:Geometry + * fid1=1|Jody|<i>well known text</i> + * fid2=2|Brent|<i>well known text</i> + * fid3=3|Dave|<i>well known text</i> + * </code> + * </pre> + * + * @author Jody Garnett + * + * + * @source $URL$ + */ +public class PropertyAttributeWriter implements AttributeWriter { + BufferedWriter writer; + + SimpleFeatureType type; + + public PropertyAttributeWriter(File file, SimpleFeatureType featureType) + throws IOException { + writer = new BufferedWriter(new FileWriter(file)); + type = featureType; + writer.write("_="); + writer.write(DataUtilities.spec(type)); + } + + public int getAttributeCount() { + return type.getAttributeCount(); + } + + public AttributeDescriptor getAttributeType(int index) + throws ArrayIndexOutOfBoundsException { + return type.getDescriptor(index); + } + // constructor end + // next start + public boolean hasNext() throws IOException { + return false; + } + + public void next() throws IOException { + if (writer == null) { + throw new IOException("Writer has been closed"); + } + writer.newLine(); + writer.flush(); + } + // next end + + // writeFeatureID start + public void writeFeatureID(String fid) throws IOException { + if (writer == null) { + throw new IOException("Writer has been closed"); + } + writer.write(fid); + } + // writeFeatureID end + + // write start + public void write(int position, Object attribute) throws IOException { + if (writer == null) { + throw new IOException("Writer has been closed"); + } + writer.write(position == 0 ? "=" : "|"); + if (attribute == null) { + writer.write("<null>"); // nothing! + } else if( attribute instanceof String){ + // encode newlines + String txt = (String) attribute; + txt = txt.replace("\n", "\\n"); + txt = txt.replace("\r", "\\r"); + writer.write( txt ); + } else if (attribute instanceof Geometry) { + Geometry geometry = (Geometry) attribute; + writer.write( geometry.toText() ); + } else { + String txt = Converters.convert( attribute, String.class ); + if( txt == null ){ // could not convert? + txt = attribute.toString(); + } + writer.write( txt ); + } + } + // write end + + // close start + public void close() throws IOException { + if (writer == null) { + throw new IOException("Writer has already been closed"); + } + writer.close(); + writer = null; + type = null; + } + // close end + // echoLine start + public void echoLine(String line) throws IOException { + if (writer == null) { + throw new IOException("Writer has been closed"); + } + if (line == null) { + return; + } + writer.write(line); + } + // echoLine end +} Added: trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyDataStore.java =================================================================== --- trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyDataStore.java (rev 0) +++ trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyDataStore.java 2011-11-23 06:23:42 UTC (rev 38370) @@ -0,0 +1,144 @@ +/* + * GeoTools - The Open Source Java GIS Toolkit + * http://geotools.org + * + * (C) 2002-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.property.ng; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileNotFoundException; +import java.io.FileWriter; +import java.io.IOException; +import java.net.URI; +import java.net.URISyntaxException; +import java.util.ArrayList; +import java.util.List; + +import org.geotools.data.DataUtilities; +import org.geotools.data.DefaultServiceInfo; +import org.geotools.data.Query; +import org.geotools.data.ServiceInfo; +import org.geotools.data.store.ContentDataStore; +import org.geotools.data.store.ContentEntry; +import org.geotools.data.store.ContentFeatureSource; +import org.geotools.factory.CommonFactoryFinder; +import org.geotools.feature.FeatureTypes; +import org.geotools.feature.NameImpl; +import org.geotools.feature.type.FeatureTypeFactoryImpl; +import org.opengis.feature.simple.SimpleFeatureType; +import org.opengis.feature.type.Name; + +import com.vividsolutions.jts.geom.GeometryFactory; + +/** + * Sample DataStore implementation, please see formal tutorial included with + * users docs. + * + * @author Jody Garnett, Refractions Research Inc. + * + * + * @source $URL$ + */ +public class PropertyDataStore extends ContentDataStore { + protected File file; + + public PropertyDataStore(File dir) { + this(dir, null); + } + + // constructor start + public PropertyDataStore(File file, String namespaceURI) { + if (file.isDirectory()) { + throw new IllegalArgumentException(file + " must be a property file"); + } + if (namespaceURI == null) { + if( file.getParent() != null ){ + namespaceURI = file.getParentFile().getName(); + } + } + this.file = file; + setNamespaceURI(namespaceURI); + // + // factories + setFilterFactory(CommonFactoryFinder.getFilterFactory(null)); + setGeometryFactory(new GeometryFactory()); + setFeatureTypeFactory(new FeatureTypeFactoryImpl()); + setFeatureFactory(CommonFactoryFinder.getFeatureFactory(null)); + } + // constructor end + + // createSchema start + public void createSchema(SimpleFeatureType featureType) throws IOException { + if( file.exists() ){ + throw new FileNotFoundException("Unable to create a new property file: file exists "+file); + } + String typeName = featureType.getTypeName(); + BufferedWriter writer = new BufferedWriter(new FileWriter(file)); + writer.write("_="); + writer.write(DataUtilities.spec(featureType)); + writer.flush(); + writer.close(); + } + + // createSchema end + + // info start + public ServiceInfo getInfo() { + DefaultServiceInfo info = new DefaultServiceInfo(); + info.setDescription("Features from " + file ); + info.setSchema(FeatureTypes.DEFAULT_NAMESPACE); + info.setSource(file.toURI()); + try { + info.setPublisher(new URI(System.getProperty("user.name"))); + } catch (URISyntaxException e) { + } + return info; + } + + // info end + + public void setNamespaceURI(String namespaceURI) { + this.namespaceURI = namespaceURI; + } + + protected java.util.List<Name> createTypeNames() throws IOException { + String name = file.getName(); + String typeName = name.substring(0,name.lastIndexOf('.')); + List<Name> typeNames = new ArrayList<Name>(); + typeNames.add( new NameImpl(namespaceURI, typeName)); + return typeNames; + } + + public List<Name> getNames() throws IOException { + String[] typeNames = getTypeNames(); + List<Name> names = new ArrayList<Name>(typeNames.length); + for (String typeName : typeNames) { + names.add(new NameImpl(namespaceURI, typeName)); + } + return names; + } + + @Override + protected ContentFeatureSource createFeatureSource(ContentEntry entry) throws IOException { + if( file.canWrite() ){ + return new PropertyFeatureStore( entry, Query.ALL ); + } + else { + return new PropertyFeatureSource( entry, Query.ALL ); + } + } + + +} Added: trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyDataStoreFactory.java =================================================================== --- trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyDataStoreFactory.java (rev 0) +++ trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyDataStoreFactory.java 2011-11-23 06:23:42 UTC (rev 38370) @@ -0,0 +1,162 @@ +/* + * GeoTools - The Open Source Java GIS Toolkit + * http://geotools.org + * + * (C) 2002-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.property.ng; + +import java.io.File; +import java.io.FileNotFoundException; +import java.io.IOException; +import java.util.Map; +import java.util.logging.Logger; + +import org.geotools.data.DataStore; +import org.geotools.data.DataStoreFactorySpi; + + +/** + * DataStore factory that creates {@linkplain org.geotools.data.property.ng.PropertyDataStore}s + * + * @author Jody garnett + * + * + * @source $URL$ + * @version $Id$ + */ +public class PropertyDataStoreFactory implements DataStoreFactorySpi { + // private static final Logger LOGGER = org.geotools.util.logging.Logging.getLogger(PropertyDataStoreFactory.class.getPackage().getName()); + + public static final Param FILE = new Param("file", File.class, + "Property file", true); + + public static final Param NAMESPACE = new Param("namespace", String.class, + "namespace of datastore", false); + + public DataStore createDataStore(Map params) throws IOException { + File dir = fileLookup(params); + String namespaceURI = (String) NAMESPACE.lookUp( params ); + if (dir.exists() && dir.isDirectory()) { + return new PropertyDataStore(dir,namespaceURI); + } else { + throw new IOException("Directory is required"); + } + } + + // createNewDataStore start + public DataStore createNewDataStore(Map params) throws IOException { + File dir = (File)FILE.lookUp(params); + + if (dir.exists()) { + throw new IOException(dir + " already exists"); + } + + String namespaceURI = (String) NAMESPACE.lookUp(params); + return new PropertyDataStore(dir,namespaceURI); + } + // createNewDataStore end + + public String getDisplayName() { + return "Properties NG"; + } + + public String getDescription() { + return "Allows access to Java Property files containing Feature information"; + } + + /** + * @see #DIRECTORY + * @see PropertyDataStoreFactory#NAMESPACE + */ + public Param[] getParametersInfo() { + return new Param[] { FILE, NAMESPACE }; + } + + /** + * Test to see if this datastore is available, if it has all the + * appropriate libraries to construct a datastore. This datastore just + * returns true for now. This method is used for gui apps, so as to not + * advertise data store capabilities they don't actually have. + * + * @return <tt>true</tt> if and only if this factory is available to create + * DataStores. + * + * @task <code>true</code> property datastore is always available + */ + public boolean isAvailable() { + return true; + } + + /** + * Works for a file directory or property file + * + * @param params Connection parameters + * + * @return true for connection parameters indicating a directory or property file + */ + public boolean canProcess(Map params) { + try { + fileLookup(params); + return true; + } catch (Exception erp) { + //can't process, just return false + return false; + } + } + + /** + * No implementation hints are provided at this time. + */ + public Map getImplementationHints(){ + return java.util.Collections.EMPTY_MAP; + } + + /** + * Lookups the property file in the params argument, and + * returns the corresponding <code>java.io.File</code>. + * <p> + * The file is first checked for existence as an absolute path in the filesystem. If + * such a directory is not found, then it is treated as a relative path, taking Java + * system property <code>"user.dir"</code> as the base. + * </p> + * @param params + * @throws IllegalArgumentException if file is a directory. + * @throws FileNotFoundException if directory does not exists + * @throws IOException if {@linkplain #DIRECTORY} doesn't find parameter in <code>params</code> + * file does not exists. + */ + private File fileLookup(Map params) throws IOException, FileNotFoundException, + IllegalArgumentException { + File file = (File) FILE.lookUp(params); + if( file.exists() ){ + if( file.isDirectory() ){ + throw new IllegalArgumentException("Property file is required (not a directory) "+file.getAbsolutePath()); + } + return file; + } + else { + File dir = file.getParentFile(); + if( dir == null || !dir.exists() ){ + // quickly check if it exists relative to the user directory + File currentDir = new File(System.getProperty("user.dir")); + + File file2 = new File(currentDir, file.getPath()); + if (file2.exists()) { + return file2; + } + } + return file; + } + } +} \ No newline at end of file Added: trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyFeatureReader.java =================================================================== --- trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyFeatureReader.java (rev 0) +++ trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyFeatureReader.java 2011-11-23 06:23:42 UTC (rev 38370) @@ -0,0 +1,289 @@ +/* + * GeoTools - The Open Source Java GIS Toolkit + * http://geotools.org + * + * (C) 2002-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.property.ng; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.io.IOException; +import java.util.NoSuchElementException; +import java.util.Properties; +import java.util.logging.Logger; + +import org.geotools.data.DataSourceException; +import org.geotools.data.DataUtilities; +import org.geotools.data.FeatureReader; +import org.geotools.feature.SchemaException; +import org.geotools.feature.simple.SimpleFeatureBuilder; +import org.geotools.util.Converters; +import org.geotools.util.logging.Logging; +import org.opengis.feature.simple.SimpleFeature; +import org.opengis.feature.simple.SimpleFeatureType; +import org.opengis.feature.type.AttributeDescriptor; +import org.opengis.feature.type.GeometryType; +import org.opengis.referencing.crs.CoordinateReferenceSystem; + +import com.vividsolutions.jts.geom.Geometry; + +/** + * Read a property file directly. + * <p> + * This implementation does not perform any filtering or processing; it leaves that up to wrappers to manipulate the content into the format or + * projection requested by the user. + * <p> + * + * <p> + * The content of this file should start with a the property "_" with the value being the typeSpec describing the featureType. Thereafter each line + * will should have a FeatureID as the property and the attribtues as the value separated by | characters. + * </p> + * + * <pre> + * <code> + * _=id:Integer|name:String|geom:Geometry + * fid1=1|Jody|<i>well known text</i> + * fid2=2|Brent|<i>well known text</i> + * fid3=3|Dave|<i>well known text</i> + * </code> + * </pre> + * + * <p> + * Many values may be represented by a special tag: <code><null></code>. An empty element: <code>||</code> is interpreted as the empty string: + * </p> + * + * <pre> + * <code> + * fid4=4||<null> -> Feature( id=2, name="", geom=null ) + * </code> + * </pre> + * + * @author Jody Garnett (LISAsoft) + * + * @source $URL$ + * @version $Id + * @since 8.0 + */ +public class PropertyFeatureReader implements FeatureReader<SimpleFeatureType, SimpleFeature> { + private static final Logger LOGGER = Logging.getLogger("org.geotools.data.property"); + + BufferedReader reader; + + SimpleFeatureType type; + + String line; + + String next; + + String[] text; + + String fid; + + public PropertyFeatureReader(String namespace, File file) throws IOException { + reader = new BufferedReader(new FileReader(file)); + + // read until "_="; + while ((line = reader.readLine()) != null) { + if (line.startsWith("_=")) + break; + } + + if ((line == null) || !line.startsWith("_=")) { + throw new IOException("Property file schema not available found"); + } + String typeSpec = line.substring(2); + String name = file.getName(); + String typeName = name.substring(0,name.lastIndexOf('.')); + try { + type = DataUtilities.createType(namespace, typeName, typeSpec); + } catch (SchemaException e) { + throw new DataSourceException(typeName + " schema not available", e); + } + line = null; + next = null; + } + + public SimpleFeatureType getFeatureType() { + return type; + } + + /** + * Grab the next feature from the property file. + * + * @return feature + * + * @throws IOException + * @throws NoSuchElementException Check hasNext() to avoid reading off the end of the file + */ + public SimpleFeature next() throws IOException, NoSuchElementException { + if (hasNext()) { + line = next; + next = null; + + int split = line.indexOf('='); + fid = line.substring(0, split); + text = line.substring(split + 1).split("\\|", -1);// use -1 as limit to include empty trailing spaces + if (type.getAttributeCount() != text.length) + throw new DataSourceException("Format error: expected " + type.getAttributeCount() + + " attributes, but found " + text.length + ". [" + line + "]"); + } else { + throw new NoSuchElementException(); + } + Object[] values = new Object[type.getAttributeCount()]; + + for (int i = 0; i < type.getAttributeCount(); i++) { + try { + values[i] = read(i); + } catch (RuntimeException e) { + values[i] = null; + } catch (IOException e) { + throw e; + } + } + return SimpleFeatureBuilder.build(type, values, fid); + } + + /** + * Read attribute in position marked by <code>index</code>. + * + * @param index Attribute position to read + * + * @return Value for the attribtue in position <code>index</code> + * + * @throws IOException + * @throws ArrayIndexOutOfBoundsException + */ + public Object read(int index) throws IOException, ArrayIndexOutOfBoundsException { + if (line == null) { + throw new IOException("No content available - did you remeber to call next?"); + } + + AttributeDescriptor attType = type.getDescriptor(index); + + String stringValue = null; + try { + // read the value + stringValue = text[index]; + } catch (RuntimeException e1) { + e1.printStackTrace(); + stringValue = null; + } + // check for special <null> flag + if ("<null>".equals(stringValue)) { + stringValue = null; + } + if (stringValue == null) { + if (attType.isNillable()) { + return null; // it was an explicit "<null>" + } + } + // Use of Converters to convert from String to requested java binding + Object value = Converters.convert(stringValue, attType.getType().getBinding()); + + if (attType.getType() instanceof GeometryType) { + // this is to be passed on in the geometry objects so the srs name gets encoded + CoordinateReferenceSystem crs = ((GeometryType) attType.getType()) + .getCoordinateReferenceSystem(); + if (crs != null) { + // must be geometry, but check anyway + if (value != null && value instanceof Geometry) { + ((Geometry) value).setUserData(crs); + } + } + } + return value; + } + + /** + * DOCUMENT ME! + * + * @return DOCUMENT ME! + * + * @throws IOException DOCUMENT ME! + */ + public boolean hasNext() throws IOException { + if (next != null) { + return true; + } + next = readLine(); + return next != null; + } + + String readLine() throws IOException { + StringBuilder buffer = new StringBuilder(); + while (true) { + String txt = reader.readLine(); + if (txt == null) { + break; + } + if (txt.startsWith("#") || txt.startsWith("!")) { + continue; // skip content + } + txt = trimLeft(txt); + if (txt.endsWith("\\")) { + buffer.append(txt.substring(0, txt.length() - 1)); + buffer.append("\n"); + continue; + } else { + buffer.append(txt); + break; + } + } + if (buffer.length() == 0) { + return null; // there is no line + } + String raw = buffer.toString(); + raw = raw.replace("\\n", "\n"); + raw = raw.replace("\\r", "\r"); + raw = raw.replace("\\t", "\t"); + return raw; + } + + /** + * Trim leading white space as described Properties. + * + * @see Properties#load(java.io.Reader) + * @param txt + * @return txt leading whitespace removed + */ + String trimLeft(String txt) { + // trim + int start = 0; + WHITESPACE: for (int i = 0; i < txt.length(); i++) { + char ch = txt.charAt(i); + if (Character.isWhitespace(ch)) { + continue; + } else { + start = i; + break WHITESPACE; + } + } + return txt.substring(start); + } + + /** + * Be sure to call close when you are finished with this reader; as it must close the file it has open. + * + * @throws IOException + */ + public void close() throws IOException { + if (reader == null) { + LOGGER.warning("Stream seems to be already closed."); + } else { + reader.close(); + } + reader = null; + } +} Added: trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyFeatureSource.java =================================================================== --- trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyFeatureSource.java (rev 0) +++ trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyFeatureSource.java 2011-11-23 06:23:42 UTC (rev 38370) @@ -0,0 +1,126 @@ +/* + * GeoTools - The Open Source Java GIS Toolkit + * http://geotools.org + * + * (C) 2002-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.property.ng; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.io.IOException; + +import org.geotools.data.DataSourceException; +import org.geotools.data.DataUtilities; +import org.geotools.data.FeatureReader; +import org.geotools.data.Query; +import org.geotools.data.QueryCapabilities; +import org.geotools.data.store.ContentEntry; +import org.geotools.data.store.ContentFeatureSource; +import org.geotools.feature.SchemaException; +import org.geotools.geometry.jts.ReferencedEnvelope; +import org.opengis.feature.simple.SimpleFeature; +import org.opengis.feature.simple.SimpleFeatureType; + +import com.sun.jdi.connect.spi.TransportService.Capabilities; + +/** + * + * + * @source $URL$ + */ +public class PropertyFeatureSource extends ContentFeatureSource { + public PropertyFeatureSource(ContentEntry entry, Query query) { + super(entry, query); + } + @Override + protected QueryCapabilities buildQueryCapabilities() { + return new QueryCapabilities(){ + public boolean isUseProvidedFIDSupported() { + return true; + } + }; + } + + @Override + protected ReferencedEnvelope getBoundsInternal(Query query) throws IOException { + ReferencedEnvelope bounds = new ReferencedEnvelope(getSchema() + .getCoordinateReferenceSystem()); + + FeatureReader<SimpleFeatureType, SimpleFeature> featureReader = getReaderInternal(query); + try { + while (featureReader.hasNext()) { + SimpleFeature feature = featureReader.next(); + bounds.include(feature.getBounds()); + } + } finally { + featureReader.close(); + } + return bounds; + } + + @Override + protected int getCountInternal(Query query) throws IOException { + int count = 0; + FeatureReader<SimpleFeatureType, SimpleFeature> featureReader = getReaderInternal(query); + try { + while (featureReader.hasNext()) { + featureReader.next(); + count++; + } + } finally { + featureReader.close(); + } + return count; + } + + @Override + protected SimpleFeatureType buildFeatureType() throws IOException { + String typeName = getEntry().getTypeName(); + String namespace = getEntry().getName().getNamespaceURI(); + + String typeSpec = property("_"); + try { + return DataUtilities.createType(namespace, typeName, typeSpec); + } catch (SchemaException e) { + e.printStackTrace(); + throw new DataSourceException(typeName + " schema not available", e); + } + } + + private String property(String key) throws IOException { + PropertyDataStore dataStore = (PropertyDataStore) getEntry().getDataStore(); + File file = dataStore.file; + + BufferedReader reader = new BufferedReader(new FileReader(file)); + try { + for (String line = reader.readLine(); line != null; line = reader.readLine()) { + if (line.startsWith(key + "=")) { + return line.substring(key.length() + 1); + } + } + } finally { + reader.close(); + } + return null; + } + + + @Override + protected FeatureReader<SimpleFeatureType, SimpleFeature> getReaderInternal(Query query) + throws IOException { + PropertyDataStore dataStore = (PropertyDataStore) getEntry().getDataStore(); + return new PropertyFeatureReader(dataStore.getNamespaceURI(),dataStore.file); + } +} \ No newline at end of file Added: trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyFeatureStore.java =================================================================== --- trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyFeatureStore.java (rev 0) +++ trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyFeatureStore.java 2011-11-23 06:23:42 UTC (rev 38370) @@ -0,0 +1,92 @@ +/* + * GeoTools - The Open Source Java GIS Toolkit + * http://geotools.org + * + * (C) 2002-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.property.ng; + +import java.io.IOException; + +import org.geotools.data.FeatureReader; +import org.geotools.data.FeatureWriter; +import org.geotools.data.Query; +import org.geotools.data.QueryCapabilities; +import org.geotools.data.store.ContentEntry; +import org.geotools.data.store.ContentFeatureStore; +import org.geotools.geometry.jts.ReferencedEnvelope; +import org.opengis.feature.simple.SimpleFeature; +import org.opengis.feature.simple.SimpleFeatureType; + +/** + * Implementation used for writeable property files. + * Supports limited caching of number of features and bounds. + * + * + * @source $URL$ + */ +public class PropertyFeatureStore extends ContentFeatureStore { + + String typeName; + SimpleFeatureType featureType; + PropertyDataStore store; + PropertyFeatureSource delegate; + + PropertyFeatureStore( ContentEntry entry, Query query ) throws IOException{ + super( entry, query ); + delegate = new PropertyFeatureSource(entry, query ); + this.store = (PropertyDataStore) entry.getDataStore(); + this.typeName = entry.getTypeName(); + } + + protected QueryCapabilities buildQueryCapabilities() { + return new QueryCapabilities(){ + public boolean isUseProvidedFIDSupported() { + return true; + } + }; + } + + + public PropertyDataStore getDataStore() { + return (PropertyDataStore) super.getDataStore(); + } + + @Override + protected FeatureWriter<SimpleFeatureType, SimpleFeature> getWriterInternal(Query query, + int flags) throws IOException { + return new PropertyFeatureWriter(this,getState(), query, (flags | WRITER_ADD) == WRITER_ADD); + } + + @Override + protected ReferencedEnvelope getBoundsInternal(Query query) throws IOException { + return delegate.getBoundsInternal(query); + } + + @Override + protected int getCountInternal(Query query) throws IOException { + return delegate.getCountInternal(query); + } + + @Override + protected FeatureReader<SimpleFeatureType, SimpleFeature> getReaderInternal(Query query) + throws IOException { + return delegate.getReaderInternal(query); + } + + @Override + protected SimpleFeatureType buildFeatureType() throws IOException { + return delegate.buildFeatureType(); + } + +} Added: trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyFeatureWriter.java =================================================================== --- trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyFeatureWriter.java (rev 0) +++ trunk/modules/unsupported/property-ng/src/main/java/org/geotools/data/property/ng/PropertyFeatureWriter.java 2011-11-23 06:23:42 UTC (rev 38370) @@ -0,0 +1,288 @@ +/* + * GeoTools - The Open Source Java GIS Toolkit + * http://geotools.org + * + * (C) 2002-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.property.ng; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileInputStream; +import java.io.FileOutputStream; +import java.io.FileWriter; +import java.io.IOException; +import java.nio.channels.FileChannel; + +import org.geotools.data.DataSourceException; +import org.geotools.data.DataUtilities; +import org.geotools.data.FeatureWriter; +import org.geotools.data.Query; +import org.geotools.data.Transaction; +import org.geotools.data.store.ContentFeatureSource; +import org.geotools.data.store.ContentState; +import org.geotools.factory.Hints; +import org.geotools.feature.simple.SimpleFeatureBuilder; +import org.geotools.geometry.jts.ReferencedEnvelope; +import org.geotools.util.Converters; +import org.opengis.feature.IllegalAttributeException; +import org.opengis.feature.simple.SimpleFeature; +import org.opengis.feature.simple.SimpleFeatureType; + +import com.vividsolutions.jts.geom.Geometry; + +/** + * Uses PropertyAttributeWriter to generate a property file on disk. + * + * + * @source $URL$ + */ +public class PropertyFeatureWriter implements FeatureWriter<SimpleFeatureType, SimpleFeature> { + + PropertyDataStore store; + ContentFeatureSource featureSource; + File read; + PropertyFeatureReader reader; + File write; + BufferedWriter writer; + SimpleFeatureType type; + + SimpleFeature origional = null; + SimpleFeature live = null; + private ContentState state; + + public PropertyFeatureWriter(ContentFeatureSource source, ContentState contentState, Query query, boolean append) throws IOException { + this.state = contentState; + this.featureSource = source; + PropertyDataStore store = (PropertyDataStore) contentState.getEntry().getDataStore(); + String namespaceURI = store.getNamespaceURI(); + String typeName = query.getTypeName(); + + read = store.file; + File dir = read.getParentFile(); + write = File.createTempFile(typeName + System.currentTimeMillis(),null, dir); + + // start reading + reader = new PropertyFeatureReader(namespaceURI, read ); + + type = reader.getFeatureType(); + + // open writer + writer = new BufferedWriter(new FileWriter(write)); + // write header + writer.write("_="); + writer.write(DataUtilities.spec(type)); + } + + // constructor end + + // getFeatureType start + public SimpleFeatureType getFeatureType() { + return reader.getFeatureType(); + } + + // getFeatureType end + // hasNext start + public boolean hasNext() throws IOException { + if (writer == null) { + throw new IOException("Writer has been closed"); + } + if (live != null && origional != null) { + // we have returned something to the user, + // and it has not been writen out or removed + // + writeImplementation(origional); + origional = null; + live = null; + } + return reader.hasNext(); + } + + // hasNext end + // writeImplementation start + private void writeImplementation(SimpleFeature f) throws IOException { + if (writer == null) { + throw new IOException("Writer has been closed"); + } + writer.newLine(); + writer.flush(); + String fid = f.getID(); + if( Boolean.TRUE.equals( f.getUserData().get(Hints.USE_PROVIDED_FID) ) ){ + if( f.getUserData().containsKey(Hints.PROVIDED_FID)){ + fid = (String) f.getUserData().get(Hints.PROVIDED_FID); + } + } + writeFeatureID(fid); + for (int i = 0; i < f.getAttributeCount(); i++) { + Object value = f.getAttribute(i); + write(i, value ); + } + } + public void writeFeatureID(String fid) throws IOException { + if (writer == null) { + throw new IOException("Writer has been closed"); + } + writer.write(fid); + } + public void write(int position, Object attribute) throws IOException { + if (writer == null) { + throw new IOException("Writer has been closed"); + } + writer.write(position == 0 ? "=" : "|"); + if (attribute == null) { + writer.write("<null>"); // nothing! + } else if( attribute instanceof String){ + // encode newlines + String txt = (String) attribute; + txt = txt.replace("\n", "\\n"); + txt = txt.replace("\r", "\\r"); + writer.write( txt ); + } else if (attribute instanceof Geometry) { + Geometry geometry = (Geometry) attribute; + writer.write( geometry.toText() ); + } else { + String txt = Converters.convert( attribute, String.class ); + if( txt == null ){ // could not convert? + txt = attribute.toString(); + } + writer.write( txt ); + } + } + // writeImplementation end + // next start + public SimpleFeature next() throws IOException { + if (writer == null) { + throw new IOException("Writer has been closed"); + } + String fid = null; + try { + if (hasNext()) { + reader.next(); // grab next line + + fid = reader.fid; + Object values[] = new Object[type.getAttributeCount()]; + for (int i = 0; i < type.getAttributeCount(); i++) { + values[i] = reader.read(i); + } + + origional = SimpleFeatureBuilder.build(type, values, fid); + live = SimpleFeatureBuilder.copy(origional); + return live; + } else { + fid = type.getTypeName() + "." + System.currentTimeMillis(); + Object values[] = DataUtilities.defaultValues(type); + + origional = null; + live = SimpleFeatureBuilder.build(type, values, fid); + return live; + } + } catch (IllegalAttributeException e) { + String message = "Problem creating feature " + + (fid != null ? fid : ""); + throw new DataSourceException(message, e); + } + } + + // next end + // write start + public void write() throws IOException { + if (live == null) { + throw new IOException("No current feature to write"); + } + if (live.equals(origional)) { + writeImplementation(origional); + } else { + writeImplementation(live); + String typeName = live.getFeatureType().getTypeName(); + Transaction autoCommit = Transaction.AUTO_COMMIT; + if (origional != null) { + ReferencedEnvelope bounds = new ReferencedEnvelope(); + bounds.include(live.getBounds()); + bounds.include(origional.getBounds()); + state.fireFeatureUpdated(featureSource, live, bounds); + //store.listenerManager.fireFeaturesChanged(typeName, autoCommit, bounds, false); + } else { + state.fireFeatureAdded(featureSource, live); + // store.listenerManager.fireFeaturesAdded(typeName, autoCommit, ReferencedEnvelope.reference(live.getBounds()), false); + } + } + origional = null; + live = null; + } + + // write end + // remove start + public void remove() throws IOException { + if (live == null) { + throw new IOException("No current feature to remove"); + } + if (origional != null) { + String typeName = live.getFeatureType().getTypeName(); + Transaction autoCommit = Transaction.AUTO_COMMIT; + state.fireFeatureRemoved(featureSource,origional); + //store.listenerManager.fireFeaturesRemoved(typeName, autoCommit,ReferencedEnvelope.reference(origional.getBounds()), false); + } + origional = null; + live = null; // prevent live and remove from being written out + } + // remove end + + // close start + public void close() throws IOException { + if (writer == null) { + throw new IOException("writer already closed"); + } + // write out remaining contents from reader + // if applicable + while (reader.hasNext()) { + reader.next(); // advance + writer.newLine(); + writer.flush(); + echoLine(reader.line); // echo unchanged + } + writer.close(); + reader.close(); + writer = null; + reader = null; + read.delete(); + + if (write.exists() && !write.renameTo(read)) { + FileChannel out = new FileOutputStream(read).getChannel(); + FileChannel in = new FileInputStream(write).getChannel(); + try { + long len = in.size(); + long copied = out.transferFrom(in, 0, in.size()); + + if (len != copied) { + throw new IOException("unable to complete write"); + } + } finally { + in.close(); + out.close(); + } + } + read = null; + write = null; + store = null; + } + public void echoLine(String line) throws IOException { + if (writer == null) { + throw new IOException("Writer has been closed"); + } + if (line == null) { + return; + } + writer.write(line); + } + // close end +} Added: trunk/modules/unsupported/property-ng/src/test/java/org/geotools/data/property/ng/PropertyDataStore2Test.java =================================================================== --- trunk/modules/unsupported/property-ng/src/test/java/org/geotools/data/property/ng/PropertyDataStore2Test.java (rev 0) +++ trunk/modules/unsupported/property-ng/src/test/java/org/geotools/data/property/ng/PropertyDataStore2Test.java 2011-11-23 06:23:42 UTC (rev 38370) @@ -0,0 +1,192 @@ +/* + * GeoTools - The Open Source Java GIS Toolkit + * http://geotools.org + * + * (C) 2002-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.property.ng; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileWriter; + +import junit.framework.TestCase; + +import org.geotools.data.DefaultQuery; +import org.geotools.data.Query; +import org.geotools.data.property.ng.PropertyDataStore; +import org.geotools.data.simple.SimpleFeatureCollection; +import org.geotools.data.simple.SimpleFeatureIterator; +import org.geotools.data.simple.SimpleFeatureSource; +import org.geotools.referencing.CRS; +import org.opengis.feature.Property; +import org.opengis.feature.simple.SimpleFeature; +import org.opengis.feature.simple.SimpleFeatureType; +import org.opengis.feature.type.GeometryDescriptor; +import org.opengis.feature.type.GeometryType; +import org.opengis.filter.Filter; +import org.opengis.referencing.crs.CoordinateReferenceSystem; + +import com.vividsolutions.jts.geom.Geometry; + +/** + * Test non functionality of PropertyDataStore. + * + * @author Jody Garnett, Refractions Research Inc. + * + * + * @source $URL$ + */ +public class PropertyDataStore2Test extends TestCase { + PropertyDataStore store; + + PropertyDataStore sridStore; + /** + * Constructor for SimpleDataStoreTest. + * @param arg0 + */ + public PropertyDataStore2Test(String arg0) { + super(arg0); + } + protected void setUp() throws Exception { + File dir = new File(".", "propertyTestData" ); + dir.mkdir(); + + File file = new File( dir ,"road.properties"); + if( file.exists()){ + file.delete(); + } + BufferedWriter writer = new BufferedWriter( new FileWriter( file ) ); + writer.write("_=id:Integer,*geom:Geometry,name:String"); writer.newLine(); + writer.write("fid1=1|LINESTRING(0 0,10 10)|jody"); writer.newLine(); + writer.write("fid2=2|LINESTRING(20 20,30 30)|brent"); writer.newLine(); + writer.write("fid3=3|LINESTRING(5 0, 5 10)|dave"); writer.newLine(); + writer.write("fid4=4|LINESTRING(0 5, 5 0, 10 5, 5 10, 0 5)|justin"); + writer.close(); + store = new PropertyDataStore( file, "propertyTestData" ); + + // Create a similar data store but with srid in the geometry column + File dir2 = new File(".", "propertyTestData2"); + dir2.mkdir(); + File file2 = new File(dir2, "road2.properties"); + if (file2.exists()) { + file2.delete(); + } + BufferedWriter writer2 = new BufferedWriter(new FileWriter(file2)); + writer2.write("_=id:Integer,geom:Geometry:srid=4283"); + writer2.newLine(); + writer2.write("fid1=1|LINESTRING(0 0,10 10)"); + writer2.newLine(); + writer2.write("fid2=2|LINESTRING(20 20,30 30)"); + writer2.newLine(); + writer2.write("fid3=3|LINESTRING(5 0, 5 10)"); + writer2.newLine(); + writer2.write("fid4=4|LINESTRING(0 5, 5 0, 10 5, 5 10, 0 5)"); + writer2.close(); + sridStore = new PropertyDataStore( file2, "propertyTestData2" ); + + super.setUp(); + } + protected void tearDown() throws Exception { + File dir = new File( "propertyTestData" ); + File list[]=dir.listFiles(); + for( int i=0; i<list.length;i++){ + list[i].delete(); + } + dir.delete(); + + dir = new File( "propertyTestData2" ); + File list2[] = dir.listFiles(); + for( int i=0; i<list2.length;i++){ + list2[i].delete(); + } + dir.delete(); + + super.tearDown(); + } + + /** + * Test CRS being passed into Geometry user data. + * + * @throws Exception + */ + public void testCRS() throws Exception { + SimpleFeatureSource road = sridStore.getFeatureSource("road2"); + SimpleFeatureCollection features = road.getFeatures(); + assertEquals(4, features.size()); + + SimpleFeature feature; + Geometry geom; + Property prop; + GeometryType geomType; + SimpleFeatureIterator iterator = features.features(); + while (iterator.hasNext()) { + feature = iterator.next(); + prop = feature.getProperty("geom"); + assertTrue(prop.getType() instanceof GeometryType); + geomType = (GeometryType) prop.getType(); + + Object val = prop.getValue(); + assertTrue(val != null && val instanceof Geometry); + geom = (Geometry) val; + + Object userData = geom.getUserData(); + assertTrue(userData != null && userData instanceof CoordinateReferenceSystem); + // ensure the same CRS is passed on to userData for encoding + assertEquals(userData, geomType.getCoordinateReferenceSystem()); + } + } + + public void testSimple() throws Exception { + SimpleFeatureSource road = store.getFeatureSource( "road" ); + SimpleFeatureCollection features = road.getFeatures(); + + //assertEquals( 1, features.getFeatureType().getAttributeCount() ); + assertEquals( 4, features.size() ); + } + public void testQuery() throws Exception { + SimpleFeatureSource road = store.getFeatureSource( "road" ); + + DefaultQuery query = new DefaultQuery( "road", Filter.INCLUDE, + new String[]{ "name" } ); + + SimpleFeatureCollection features = road.getFeatures( query ); + assertEquals( 4, features.size() ); + //assertEquals( 1, features.getFeatureType().getAttributeCount() ); + } + + public void testQueryReproject() throws Exception { + CoordinateReferenceSystem world = CRS.decode("EPSG:4326"); // world lon/lat + CoordinateReferenceSystem local = CRS.decode("EPSG:3005"); // british columbia + + + SimpleFeatureSource road = store.getFeatureSource( "road" ); + SimpleFeatureType origionalType = road.getSchema(); + + Query query = new Query( "road", Filter.INCLUDE, + new String[]{ "geom", "name" } ); + + query.setCoordinateSystem( local ); // FROM + query.setCoordinateSystemReproject( world ); // TO + + SimpleFeatureCollection features = road.getFeatures( query ); + SimpleFeatureType resultType = features.getSchema(); + + assertNotNull( resultType ); + assertNotSame( resultType, origionalType ); + + assertEquals( world, resultType.getCoordinateReferenceSystem() ); + + GeometryDescriptor geometryDescriptor = resultType.getGeometryDescriptor(); + } +} Added: trunk/modules/unsupported/property-ng/src/test/java/org/geotools/data/property/ng/PropertyDataStoreTest.java =================================================================== --- trunk/modules/unsupported/property-ng/src/test/java/org/geotools/data/property/ng/PropertyDataStoreTest.java (rev 0) +++ trunk/modules/unsupported/property-ng/src/test/java/org/geotools/data/property/ng/PropertyDataStoreTest.java 2011-11-23 06:23:42 UTC (rev 38370) @@ -0,0 +1,601 @@ +/* + * GeoTools - The Open Source Java GIS Toolkit + * http://geotools.org + * + * (C) 2002-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.property.ng; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.NoSuchElementException; +import java.util.Set; + +import junit.framework.TestCase; + +import org.geotools.data.DataUtilities; +import org.geotools.data.DefaultQuery; +import org.geotools.data.DefaultTransaction; +import org.geotools.data.FeatureReader; +import org.geotools.data.FeatureWriter; +import org.geotools.data.Query; +import org.geotools.data.Transaction; +import org.geotools.data.property.ng.PropertyDataStore; +import org.geotools.data.property.ng.PropertyFeatureStore; +import org.geotools.data.property.ng.PropertyFeatureWriter; +import org.geotools.data.simple.SimpleFeatureCollection; +import org.geotools.data.simple.SimpleFeatureIterator; +import org.geotools.data.simple.SimpleFeatureSource; +import org.geotools.data.simple.SimpleFeatureStore; +import org.geotools.data.store.ContentFeatureStore; +import org.geotools.factory.CommonFactoryFinder; +import org.geotools.factory.Hints; +import org.geotools.feature.simple.SimpleFeatureBuilder; +import org.geotools.filter.identity.FeatureIdImpl; +import org.opengis.feature.Feature; +import org.opengis.feature.FeatureVisitor; +import org.opengis.feature.IllegalAttributeException; +import org.opengis.feature.simple.SimpleFeature; +import org.opengis.feature.simple.SimpleFeatureType; +import org.opengis.feature.type.AttributeDescriptor; +import org.opengis.filter.Filter; +import org.opengis.filter.FilterFactory2; +import org.opengis.filter.identity.FeatureId; + +/** + * Test functioning of PropertyDataStore. + * + * @author Jody Garnett, Refractions Research Inc. + * + * + * @source $URL$ + */ +public class PropertyDataStoreTest extends TestCase { + private PropertyDataStore store; + + private PropertyDataStore storeDots; + + private PropertyDataStore storeMultiline; + + private PropertyDataStore storeTable; + + static FilterFactory2 ff = (FilterFactory2) CommonFactoryFinder.getFilterFactory(null); + + /** + * Constructor for SimpleDataStoreTest. + * @param arg0 + */ + public PropertyDataStoreTest(String arg0) { + super(arg0); + } + protected void setUp() throws Exception { + File dir = new File(".", "propertyTestData" ); + dir.mkdir(); + + File file = new File( dir ,"road.properties"); + if( file.exists()){ + file.delete(); + } + BufferedWriter writer = new BufferedWriter( new FileWriter( file ) ); + writer.write("_=id:Integer,name:String"); writer.newLine(); + writer.write("fid1=1|jody"); writer.newLine(); + writer.write("fid2=2|brent"); writer.newLine(); + writer.write("fid3=3|dave"); writer.newLine(); + writer.write("fid4=4|justin"); writer.newLine(); + writer.write("fid5=5|"); + writer.close(); + store = new PropertyDataStore( file, "propertyTestData" ); + + file = new File( dir ,"dots.in.name.properties"); + if( file.exists()){ + file.delete(); + } + writer = new BufferedWriter( new FileWriter( file ) ); + writer.write("_=id:Integer,name:String"); writer.newLine(); + writer.write("fid1=1|jody"); writer.newLine(); + writer.write("fid2=2|brent"); writer.newLine(); + writer.write("fid3=3|dave"); writer.newLine(); + writer.write("fid4=4|justin"); + writer.close(); + storeDots = new PropertyDataStore( file, "propertyTestData" ); + + file = new File( dir ,"multiline.properties"); + if( file.exists()){ + file.delete(); + } + writer = new BufferedWriter( new FileWriter( file ) ); + writer.write("_=id:Integer,name:String"); writer.newLine(); + writer.write("fid1=1|jody \\"); writer.newLine(); + writer.write(" garnett"); writer.newLine(); + writer.write("fid2=2|brent"); writer.newLine(); + writer.write("fid3=3|dave"); writer.newLine(); + writer.write("fi... [truncated message content] |