entry : entries) {
+ result.put(entry.getKey(), entry.getValue().toExternalForm());
+ }
+
+ return result;
+ }
+
+ /**
+ * Returns the string form of the url that identifies the file indicated by
+ * the type parameter or null if it is known that the file does not exist.
+ *
+ *
+ * Note: a URL should NOT be constructed from the string instead the URL
+ * should be obtained through calling one of the aquireLock methods.
+ *
+ * @param type
+ * indicates the type of file the caller is interested in.
+ *
+ * @return the string form of the url that identifies the file indicated by
+ * the type parameter or null if it is known that the file does not
+ * exist.
+ */
+ public String get(ShpFileType type) {
+ return urls.get(type).toExternalForm();
+ }
+
+ /**
+ * Returns the number of locks on the current set of shapefile files. This
+ * is not thread safe so do not count on it to have a completely accurate
+ * picture but it can be useful debugging
+ *
+ * @return the number of locks on the current set of shapefile files.
+ */
+ public int numberOfLocks() {
+ int count = 0;
+ for (Collection lockerList : lockers.values()) {
+ count += lockerList.size();
+ }
+ return count;
+ }
+ /**
+ * Acquire a File for read only purposes. It is recommended that get*Stream or
+ * get*Channel methods are used when reading or writing to the file is
+ * desired.
+ *
+ *
+ * @see #getInputStream(ShpFileType, FileReader)
+ * @see #getReadChannel(ShpFileType, FileReader)
+ * @see #getWriteChannel(ShpFileType, FileReader)
+ *
+ * @param type
+ * the type of the file desired.
+ * @param requestor
+ * the object that is requesting the File. The same object
+ * must release the lock and is also used for debugging.
+ * @return the File type requested
+ */
+ public File acquireReadFile(ShpFileType type,
+ FileReader requestor) {
+ if(!isLocalTab() ){
+ throw new IllegalStateException("This method only applies if the files are local");
+ }
+ URL url = acquireRead(type, requestor);
+ return DataUtilities.urlToFile(url);
+ }
+
+ /**
+ * Acquire a URL for read only purposes. It is recommended that get*Stream or
+ * get*Channel methods are used when reading or writing to the file is
+ * desired.
+ *
+ *
+ * @see #getInputStream(ShpFileType, FileReader)
+ * @see #getReadChannel(ShpFileType, FileReader)
+ * @see #getWriteChannel(ShpFileType, FileReader)
+ *
+ * @param type
+ * the type of the file desired.
+ * @param requestor
+ * the object that is requesting the URL. The same object
+ * must release the lock and is also used for debugging.
+ * @return the URL to the file of the type requested
+ */
+ public URL acquireRead(ShpFileType type, FileReader requestor) {
+ URL url = urls.get(type);
+ if (url == null)
+ return null;
+
+ readWriteLock.readLock().lock();
+ Collection threadLockers = getCurrentThreadLockers();
+ threadLockers.add(new ShpFilesLocker(url, requestor));
+ return url;
+ }
+
+ /**
+ * Tries to acquire a URL for read only purposes. Returns null if the
+ * acquire failed or if the file does not.
+ * It is recommended that get*Stream or
+ * get*Channel methods are used when reading or writing to the file is
+ * desired.
+ *
+ *
+ * @see #getInputStream(ShpFileType, FileReader)
+ * @see #getReadChannel(ShpFileType, FileReader)
+ * @see #getWriteChannel(ShpFileType, FileReader)
+ *
+ * @param type
+ * the type of the file desired.
+ * @param requestor
+ * the object that is requesting the URL. The same object
+ * must release the lock and is also used for debugging.
+ * @return A result object containing the URL or the reason for the failure.
+ */
+ public Result tryAcquireRead(ShpFileType type,
+ FileReader requestor) {
+ URL url = urls.get(type);
+ if (url == null) {
+ return new Result(null, State.NOT_EXIST);
+ }
+
+ boolean locked = readWriteLock.readLock().tryLock();
+ if (!locked) {
+ return new Result(null, State.LOCKED);
+ }
+
+ getCurrentThreadLockers().add(new ShpFilesLocker(url, requestor));
+
+ return new Result(url, State.GOOD);
+ }
+
+ /**
+ * Unlocks a read lock. The file and requestor must be the the same as the
+ * one of the lockers.
+ *
+ * @param file
+ * file that was locked
+ * @param requestor
+ * the class that requested the file
+ */
+ public void unlockRead(File file, FileReader requestor) {
+ Collection allURLS = urls.values();
+ for (URL url : allURLS) {
+ if (DataUtilities.urlToFile(url).equals(file)) {
+ unlockRead(url, requestor);
+ }
+ }
+ }
+
+ /**
+ * Unlocks a read lock. The url and requestor must be the the same as the
+ * one of the lockers.
+ *
+ * @param url
+ * url that was locked
+ * @param requestor
+ * the class that requested the url
+ */
+ public void unlockRead(URL url, FileReader requestor) {
+ if (url == null) {
+ throw new NullPointerException("url cannot be null");
+ }
+ if (requestor == null) {
+ throw new NullPointerException("requestor cannot be null");
+ }
+
+ Collection threadLockers = getCurrentThreadLockers();
+ boolean removed = threadLockers.remove(new ShpFilesLocker(url, requestor));
+ if (!removed) {
+ throw new IllegalArgumentException(
+ "Expected requestor "
+ + requestor
+ + " to have locked the url but it does not hold the lock for the URL");
+ }
+ if(threadLockers.size() == 0)
+ lockers.remove(Thread.currentThread());
+ readWriteLock.readLock().unlock();
+ }
+
+ /**
+ * Acquire a File for read and write purposes.
+ * It is recommended that get*Stream or
+ * get*Channel methods are used when reading or writing to the file is
+ * desired.
+ *
+ *
+ * @see #getInputStream(ShpFileType, FileReader)
+ * @see #getReadChannel(ShpFileType, FileReader)
+ * @see #getWriteChannel(ShpFileType, FileReader)
+
+ *
+ * @param type
+ * the type of the file desired.
+ * @param requestor
+ * the object that is requesting the File. The same object
+ * must release the lock and is also used for debugging.
+ * @return the File to the file of the type requested
+ */
+ public File acquireWriteFile(ShpFileType type,
+ FileWriter requestor) {
+ if(!isLocalTab() ){
+ throw new IllegalStateException("This method only applies if the files are local");
+ }
+ URL url = acquireWrite(type, requestor);
+ return DataUtilities.urlToFile(url);
+ }
+ /**
+ * Acquire a URL for read and write purposes.
+ * It is recommended that get*Stream or
+ * get*Channel methods are used when reading or writing to the file is
+ * desired.
+ *
+ *
+ * @see #getInputStream(ShpFileType, FileReader)
+ * @see #getReadChannel(ShpFileType, FileReader)
+ * @see #getWriteChannel(ShpFileType, FileReader)
+
+ *
+ * @param type
+ * the type of the file desired.
+ * @param requestor
+ * the object that is requesting the URL. The same object
+ * must release the lock and is also used for debugging.
+ * @return the URL to the file of the type requested
+ */
+ public URL acquireWrite(ShpFileType type, FileWriter requestor) {
+ URL url = urls.get(type);
+ if (url == null) {
+ return null;
+ }
+
+ // we need to give up all read locks before getting the write one
+ Collection threadLockers = getCurrentThreadLockers();
+ relinquishReadLocks(threadLockers);
+ readWriteLock.writeLock().lock();
+ threadLockers.add(new ShpFilesLocker(url, requestor));
+ mapCache.cleanFileCache(url);
+ return url;
+ }
+
+ /**
+ * Tries to acquire a URL for read/write purposes. Returns null if the
+ * acquire failed or if the file does not exist
+ * It is recommended that get*Stream or
+ * get*Channel methods are used when reading or writing to the file is
+ * desired.
+ *
+ *
+ * @see #getInputStream(ShpFileType, FileReader)
+ * @see #getReadChannel(ShpFileType, FileReader)
+ * @see #getWriteChannel(ShpFileType, FileReader)
+
+ *
+ * @param type
+ * the type of the file desired.
+ * @param requestor
+ * the object that is requesting the URL. The same object
+ * must release the lock and is also used for debugging.
+ * @return A result object containing the URL or the reason for the failure.
+ */
+ public Result tryAcquireWrite(ShpFileType type,
+ FileWriter requestor) {
+
+ URL url = urls.get(type);
+ if (url == null) {
+ return new Result(null, State.NOT_EXIST);
+ }
+
+ Collection threadLockers = getCurrentThreadLockers();
+ boolean locked = readWriteLock.writeLock().tryLock();
+ if (!locked && threadLockers.size() > 1) {
+ // hum, it may be be because we are holding a read lock
+ relinquishReadLocks(threadLockers);
+ locked = readWriteLock.writeLock().tryLock();
+ if(locked == false) {
+ regainReadLocks(threadLockers);
+ return new Result(null, State.LOCKED);
+ }
+ }
+
+ threadLockers.add(new ShpFilesLocker(url, requestor));
+ return new Result(url, State.GOOD);
+ }
+
+ /**
+ * Unlocks a read lock. The file and requestor must be the the same as the
+ * one of the lockers.
+ *
+ * @param file
+ * file that was locked
+ * @param requestor
+ * the class that requested the file
+ */
+ public void unlockWrite(File file, FileWriter requestor) {
+ Collection allURLS = urls.values();
+ for (URL url : allURLS) {
+ if (DataUtilities.urlToFile(url).equals(file)) {
+ unlockWrite(url, requestor);
+ }
+ }
+ }
+
+ /**
+ * Unlocks a read lock. The requestor must be have previously obtained a
+ * lock for the url.
+ *
+ *
+ * @param url
+ * url that was locked
+ * @param requestor
+ * the class that requested the url
+ */
+ public void unlockWrite(URL url, FileWriter requestor) {
+ if (url == null) {
+ throw new NullPointerException("url cannot be null");
+ }
+ if (requestor == null) {
+ throw new NullPointerException("requestor cannot be null");
+ }
+ Collection threadLockers = getCurrentThreadLockers();
+ boolean removed = threadLockers.remove(new ShpFilesLocker(url, requestor));
+ if (!removed) {
+ throw new IllegalArgumentException(
+ "Expected requestor "
+ + requestor
+ + " to have locked the url but it does not hold the lock for the URL");
+ }
+
+ if(threadLockers.size() == 0) {
+ lockers.remove(Thread.currentThread());
+ } else {
+ // get back read locks before giving up the write one
+ regainReadLocks(threadLockers);
+ }
+ readWriteLock.writeLock().unlock();
+ }
+
+ /**
+ * Returns the list of lockers attached to a given thread, or creates it if missing
+ * @return
+ */
+ private Collection getCurrentThreadLockers() {
+ Collection threadLockers = lockers.get(Thread.currentThread());
+ if(threadLockers == null) {
+ threadLockers = new ArrayList();
+ lockers.put(Thread.currentThread(), threadLockers);
+ }
+ return threadLockers;
+ }
+
+ /**
+ * Gives up all read locks in preparation for lock upgade
+ * @param threadLockers
+ */
+ private void relinquishReadLocks(Collection threadLockers) {
+ for (ShpFilesLocker shpFilesLocker : threadLockers) {
+ if(shpFilesLocker.reader != null && !shpFilesLocker.upgraded) {
+ readWriteLock.readLock().unlock();
+ shpFilesLocker.upgraded = true;
+ }
+ }
+ }
+
+ /**
+ * Re-takes the read locks in preparation for lock downgrade
+ * @param threadLockers
+ */
+ private void regainReadLocks(Collection threadLockers) {
+ for (ShpFilesLocker shpFilesLocker : threadLockers) {
+ if(shpFilesLocker.reader != null && shpFilesLocker.upgraded) {
+ readWriteLock.readLock().lock();
+ shpFilesLocker.upgraded = false;
+ }
+ }
+ }
+
+ /**
+ * Determine if the location of this shapefile is local or remote.
+ *
+ * @return true if local, false if remote
+ */
+ public boolean isLocalTab() {
+ return urls.get(ShpFileType.SHP).toExternalForm().toLowerCase().startsWith("file:");
+ }
+
+ /**
+ * Delete all the shapefile files. If the files are not local or the one
+ * files cannot be deleted return false.
+ */
+ public boolean delete() {
+ BasicShpFileWriter requestor = new BasicShpFileWriter("ShpFiles for deleting all files");
+ URL writeLockURL = acquireWrite(SHP, requestor);
+ boolean retVal = true;
+ try {
+ if (isLocalTab()) {
+ Collection values = urls.values();
+ for (URL url : values) {
+ File f = DataUtilities.urlToFile(url);
+ if (!f.delete()) {
+ retVal = false;
+ }
+ }
+ } else {
+ retVal = false;
+ }
+ } finally {
+ unlockWrite(writeLockURL, requestor);
+ }
+ return retVal;
+ }
+
+ /**
+ * Opens a input stream for the indicated file. A read lock is requested at
+ * the method call and released on close.
+ *
+ * @param type
+ * the type of file to open the stream to.
+ * @param requestor
+ * the object requesting the stream
+ * @return an input stream
+ *
+ * @throws IOException
+ * if a problem occurred opening the stream.
+ */
+ public InputStream getInputStream(ShpFileType type,
+ final FileReader requestor) throws IOException {
+ final URL url = acquireRead(type, requestor);
+
+ try {
+ FilterInputStream input = new FilterInputStream(url.openStream()) {
+
+ private volatile boolean closed = false;
+
+ @Override
+ public void close() throws IOException {
+ try {
+ super.close();
+ } finally {
+ if (!closed) {
+ closed = true;
+ unlockRead(url, requestor);
+ }
+ }
+ }
+
+ };
+ return input;
+ } catch (Throwable e) {
+ unlockRead(url, requestor);
+ if (e instanceof IOException) {
+ throw (IOException) e;
+ } else if( e instanceof RuntimeException) {
+ throw (RuntimeException) e;
+ } else if( e instanceof Error ) {
+ throw (Error) e;
+ } else {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ /**
+ * Opens a output stream for the indicated file. A write lock is requested at
+ * the method call and released on close.
+ *
+ * @param type
+ * the type of file to open the stream to.
+ * @param requestor
+ * the object requesting the stream
+ * @return an output stream
+ *
+ * @throws IOException
+ * if a problem occurred opening the stream.
+ */
+ public OutputStream getOutputStream(ShpFileType type,
+ final FileWriter requestor) throws IOException {
+ final URL url = acquireWrite(type, requestor);
+
+ try {
+
+ OutputStream out;
+ if (isLocalTab()) {
+ File file = DataUtilities.urlToFile(url);
+ out = new FileOutputStream(file);
+ } else {
+ URLConnection connection = url.openConnection();
+ connection.setDoOutput(true);
+ out = connection.getOutputStream();
+ }
+
+ FilterOutputStream output = new FilterOutputStream(out) {
+
+ private volatile boolean closed = false;
+
+ @Override
+ public void close() throws IOException {
+ try {
+ super.close();
+ } finally {
+ if (!closed) {
+ closed = true;
+ unlockWrite(url, requestor);
+ }
+ }
+ }
+
+ };
+
+ return output;
+ } catch (Throwable e) {
+ unlockWrite(url, requestor);
+ if (e instanceof IOException) {
+ throw (IOException) e;
+ } else if (e instanceof RuntimeException) {
+ throw (RuntimeException) e;
+ } else if (e instanceof Error) {
+ throw (Error) e;
+ } else {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ /**
+ * Obtain a ReadableByteChannel from the given URL. If the url protocol is
+ * file, a FileChannel will be returned. Otherwise a generic channel will be
+ * obtained from the urls input stream.
+ *
+ * A read lock is obtained when this method is called and released when the
+ * channel is closed.
+ *
+ *
+ * @param type
+ * the type of file to open the channel to.
+ * @param requestor
+ * the object requesting the channel
+ *
+ */
+ public ReadableByteChannel getReadChannel(ShpFileType type,
+ FileReader requestor) throws IOException {
+ URL url = acquireRead(type, requestor);
+ ReadableByteChannel channel = null;
+ try {
+ if (isLocalTab()) {
+
+ File file = DataUtilities.urlToFile(url);
+
+ RandomAccessFile raf = new RandomAccessFile(file, "r");
+ channel = new FileChannelDecorator(raf.getChannel(), this, url,
+ requestor);
+
+ } else {
+ InputStream in = url.openConnection().getInputStream();
+ channel = new ReadableByteChannelDecorator(Channels
+ .newChannel(in), this, url, requestor);
+ }
+ } catch (Throwable e) {
+ unlockRead(url, requestor);
+ if (e instanceof IOException) {
+ throw (IOException) e;
+ } else if (e instanceof RuntimeException) {
+ throw (RuntimeException) e;
+ } else if (e instanceof Error) {
+ throw (Error) e;
+ } else {
+ throw new RuntimeException(e);
+ }
+ }
+ return channel;
+ }
+
+ /**
+ * Obtain a WritableByteChannel from the given URL. If the url protocol is
+ * file, a FileChannel will be returned. Currently, this method will return
+ * a generic channel for remote urls, however both shape and dbf writing can
+ * only occur with a local FileChannel channel.
+ *
+ *
+ * A write lock is obtained when this method is called and released when the
+ * channel is closed.
+ *
+ *
+ *
+ * @param type
+ * the type of file to open the stream to.
+ * @param requestor
+ * the object requesting the stream
+ *
+ * @return a WritableByteChannel for the provided file type
+ *
+ * @throws IOException
+ * if there is an error opening the stream
+ */
+ public WritableByteChannel getWriteChannel(ShpFileType type,
+ FileWriter requestor) throws IOException {
+
+ URL url = acquireWrite(type, requestor);
+
+ try {
+ WritableByteChannel channel;
+ if (isLocalTab()) {
+
+ File file = DataUtilities.urlToFile(url);
+
+ RandomAccessFile raf = new RandomAccessFile(file, "rw");
+ channel = new FileChannelDecorator(raf.getChannel(), this, url,
+ requestor);
+
+ ((FileChannel) channel).lock();
+
+ } else {
+ OutputStream out = url.openConnection().getOutputStream();
+ channel = new WritableByteChannelDecorator(Channels
+ .newChannel(out), this, url, requestor);
+ }
+
+ return channel;
+ } catch (Throwable e) {
+ unlockWrite(url, requestor);
+ if (e instanceof IOException) {
+ throw (IOException) e;
+ } else if (e instanceof RuntimeException) {
+ throw (RuntimeException) e;
+ } else if (e instanceof Error) {
+ throw (Error) e;
+ } else {
+ throw new RuntimeException(e);
+ }
+ }
+ }
+
+ /**
+ * Obtains a Storage file for the type indicated. An id is provided so that
+ * the same file can be obtained at a later time with just the id
+ *
+ * @param type
+ * the type of file to create and return
+ *
+ * @return StorageFile
+ * @throws IOException
+ * if temporary files cannot be created
+ */
+ public StorageFile getStorageFile(ShpFileType type) throws IOException {
+ String baseName = getTypeName();
+ if (baseName.length() < 3) { // min prefix length for createTempFile
+ baseName = baseName + "___".substring(0, 3 - baseName.length());
+ }
+ File tmp = File.createTempFile(baseName, type.extensionWithPeriod);
+ return new StorageFile(this, tmp, type);
+ }
+
+ public String getTypeName() {
+ String path = SHP.toBase(urls.get(SHP));
+ int slash = Math.max(0, path.lastIndexOf('/') + 1);
+ int dot = path.indexOf('.', slash);
+
+ if (dot < 0) {
+ dot = path.length();
+ }
+
+ return path.substring(slash, dot);
+ }
+
+ /**
+ * Internal method that the file channel decorators will call to allow reuse of the memory mapped buffers
+ * @param wrapped
+ * @param url
+ * @param mode
+ * @param position
+ * @param size
+ * @return
+ * @throws IOException
+ */
+ MappedByteBuffer map(FileChannel wrapped, URL url, MapMode mode, long position, long size) throws IOException {
+ if(memoryMapCacheEnabled) {
+ return mapCache.map(wrapped, url, mode, position, size);
+ } else {
+ return wrapped.map(mode, position, size);
+ }
+ }
+
+ /**
+ * Returns the status of the memory map cache. When enabled the memory mapped portions of the files are cached and shared
+ * (giving each thread a clone of it)
+ * @param memoryMapCacheEnabled
+ */
+ public boolean isMemoryMapCacheEnabled() {
+ return memoryMapCacheEnabled;
+ }
+
+ /**
+ * Enables the memory map cache. When enabled the memory mapped portions of the files are cached and shared
+ * (giving each thread a clone of it)
+ * @param memoryMapCacheEnabled
+ */
+ public void setMemoryMapCacheEnabled(boolean memoryMapCacheEnabled) {
+ this.memoryMapCacheEnabled = memoryMapCacheEnabled;
+ if (!memoryMapCacheEnabled) {
+ mapCache.clean();
+ }
+ }
+
+ /**
+ * Returns true if the file exists. Throws an exception if the file is not
+ * local.
+ *
+ * @param fileType
+ * the type of file to check existance for.
+ *
+ * @return true if the file exists.
+ *
+ * @throws IllegalArgumentException
+ * if the files are not local.
+ */
+ public boolean existsTab(ShpFileType fileType) throws IllegalArgumentException {
+ if (!isLocalTab()) {
+ throw new IllegalArgumentException(
+ "This method only makes sense if the files are local");
+ }
+ URL url = urls.get(fileType);
+ if (url == null) {
+ return false;
+ }
+
+ File file = DataUtilities.urlToFile(url);
+ return file.exists();
+ }
+}
Index: applications/editors/josm/plugins/opendata/src/org/openstreetmap/josm/plugins/opendata/core/OdConstants.java
===================================================================
--- applications/editors/josm/plugins/opendata/src/org/openstreetmap/josm/plugins/opendata/core/OdConstants.java (revision 29013)
+++ applications/editors/josm/plugins/opendata/src/org/openstreetmap/josm/plugins/opendata/core/OdConstants.java (revision 29014)
@@ -143,5 +143,5 @@
* Resources
*/
- public static final String RESOURCE_PATH = "/org/openstreetmap/josm/plugins/opendata/core/resources/";
+ public static final String RESOURCE_PATH = "/resources/org/openstreetmap/josm/plugins/opendata/core/resources/";
public static final String DICTIONARY_FR = RESOURCE_PATH+"dictionary.fr.csv";
}
Index: applications/editors/josm/plugins/opendata/src/org/openstreetmap/josm/plugins/opendata/core/datasets/fr/FrenchConstants.java
===================================================================
--- applications/editors/josm/plugins/opendata/src/org/openstreetmap/josm/plugins/opendata/core/datasets/fr/FrenchConstants.java (revision 29013)
+++ applications/editors/josm/plugins/opendata/src/org/openstreetmap/josm/plugins/opendata/core/datasets/fr/FrenchConstants.java (revision 29014)
@@ -33,4 +33,4 @@
* NEPTUNE XML Schema
*/
- public static final String NEPTUNE_XSD = "/neptune/neptune.xsd";
+ public static final String NEPTUNE_XSD = "/resources/neptune/neptune.xsd";
}
Index: applications/editors/josm/plugins/opendata/src/org/openstreetmap/josm/plugins/opendata/core/io/geographic/TabReader.java
===================================================================
--- applications/editors/josm/plugins/opendata/src/org/openstreetmap/josm/plugins/opendata/core/io/geographic/TabReader.java (revision 29013)
+++ applications/editors/josm/plugins/opendata/src/org/openstreetmap/josm/plugins/opendata/core/io/geographic/TabReader.java (revision 29014)
@@ -21,12 +21,9 @@
import java.io.InputStream;
import java.io.InputStreamReader;
-import java.net.URL;
import java.nio.charset.Charset;
import java.util.ArrayList;
import java.util.List;
-import org.geotools.data.DataUtilities;
-import org.geotools.data.shapefile.ShpFileType;
-import org.geotools.data.shapefile.ShpFiles;
+import org.geotools.data.shapefile.TabFiles;
import org.geotools.data.shapefile.dbf.DbaseFileReader;
import org.geotools.data.shapefile.dbf.DbaseFileReader.Row;
@@ -54,24 +51,5 @@
return new TabReader(handler).parse(in, file, instance, Charset.forName(ISO8859_15));
}
-
- private class TabFiles extends ShpFiles {
- public TabFiles(File headerFile, File dataFile) throws IllegalArgumentException {
- super(DataUtilities.fileToURL(headerFile));
- urls.put(ShpFileType.DBF, DataUtilities.fileToURL(dataFile));
- }
- @Override
- protected String baseName(Object obj) {
- if (obj instanceof URL) {
- return toBase(((URL) obj).toExternalForm());
- }
- return null;
- }
-
- private String toBase(String path) {
- return path.substring(0, path.toLowerCase().lastIndexOf(".tab"));
- }
- }
-
private class TabOsmReader extends SpreadSheetReader {