Application: gvSIG desktop » gvSIG raster

org.gvsig.raster.multifile.io.DefaultMultiFileIOLibrary

<!DOCTYPE TimeSeriesFormat [

<!ELEMENT TimeSeriesFormat (Name,URIs)>

<!ELEMENT Name (#PCDATA)>

<!ELEMENT URIs (URI)+>

<!ELEMENT URI (#PCDATA)>

]>

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

*

* This program is free software; you can redistribute it and/or

* modify it under the terms of the GNU General Public License

* as published by the Free Software Foundation; either version 2

* of the License, or (at your option) any later version.

*

* This program 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 General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

* MA  02110-1301, USA.

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

package org.gvsig.raster.multifile.io;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.spi.AbstractDataParameters;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynClass;

import org.gvsig.tools.dynobject.DynObjectManager;

/**

 * Parameters for the Multifile explorer provider

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class MultiFileServerExplorerParameters extends AbstractDataParameters implements DataServerExplorerParameters {

	public static final String     DYNCLASS_NAME       = "MultifileServerExplorerParameters";

	protected static DynClass      DYNCLASS            = null;

	private DelegatedDynObject     delegatedDynObject  = null;

	public MultiFileServerExplorerParameters() {

		super();

		initialize();

	}

	protected void initialize() {

		this.delegatedDynObject = (DelegatedDynObject) ToolsLocator

				.getDynObjectManager().createDynObject(

						DYNCLASS);

	}

	public static void registerDynClass() {

		DynObjectManager dynman = ToolsLocator.getDynObjectManager();

		DynClass dynClass;

		if(dynman == null)

			return;

		if (DYNCLASS == null) {

			dynClass = dynman.add(DYNCLASS_NAME);

			DYNCLASS = dynClass;

		}

	}

	protected DelegatedDynObject getDelegatedDynObject() {

		return delegatedDynObject;

	}

	public String getDataStoreName() {

		return MultiFileProvider.NAME;

	}

	public String getDescription() {

		return MultiFileProvider.DESCRIPTION;

	}

	public String getExplorerName() {

		return MultiFileProvider.NAME;

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

*

* This program is free software; you can redistribute it and/or

* modify it under the terms of the GNU General Public License

* as published by the Free Software Foundation; either version 2

* of the License, or (at your option) any later version.

*

* This program 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 General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

* MA  02110-1301, USA.

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

package org.gvsig.raster.multifile.io;

import java.net.URI;

import java.util.List;

import org.gvsig.fmap.dal.coverage.store.RasterDataStore;

import org.gvsig.fmap.dal.coverage.store.parameter.RasterDataParameters;

import org.gvsig.fmap.dal.spi.DataStoreProvider;

import org.gvsig.raster.impl.provider.RasterProvider;

/**

 * Parameters for the Multifile provider

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public interface MultiFileDataParameters extends RasterDataParameters {

	public static final String            FIELD_PROVIDERS           = "Providers";

	/**

	 * Removes all providers

	 */

	public void removeAllProviders();

	/**

	 * Returns true if this multifile has providers loaded

	 * @return boolean

	 */

	public boolean hasProviders();

	/**

	 * Removes a provider from the list

	 * @param uri

	 */

	public void removeProvider(URI uri);

	/**

	 * Adds a provider to the list if the this is not tiled

	 * @param provider

	 * @param prov

	 */

	public void addProviderNotTiled(DataStoreProvider provider);

	/**

	 * Set the selected provider in the first position

	 * @param provider

	 */

	public void setFirstProvider(DataStoreProvider provider);

	/**

	 * Adds a provider to the list

	 * @param provider

	 * @param prov

	 */

	public void addProvider(DataStoreProvider provider);

	/**

	 * Adds a provider to the list from a RasterDataStore

	 * @param rasterDataStore

	 */

	public void addProvider(RasterDataStore rasterDataStore);

	/**

	 * Gets the list of providers

	 * @return the list of providers

	 */

	public List<RasterProvider> getProviders();

}

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

*

* This program is free software; you can redistribute it and/or

* modify it under the terms of the GNU General Public License

* as published by the Free Software Foundation; either version 2

* of the License, or (at your option) any later version.

*

* This program 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 General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

* MA  02110-1301, USA.

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

package org.gvsig.raster.multifile.io;

import java.net.URI;

import java.util.ArrayList;

import java.util.List;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.coverage.store.RasterDataStore;

import org.gvsig.fmap.dal.coverage.store.parameter.RasterDataParameters;

import org.gvsig.fmap.dal.exception.InitializeException;

import org.gvsig.fmap.dal.exception.ProviderNotRegisteredException;

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

import org.gvsig.fmap.dal.spi.DataStoreProvider;

import org.gvsig.raster.impl.provider.AbstractRasterProvider;

import org.gvsig.raster.impl.provider.RasterProvider;

import org.gvsig.raster.impl.store.AbstractRasterDataParameters;

import org.gvsig.raster.impl.store.AbstractRasterFileDataParameters;

import org.gvsig.raster.impl.store.DefaultRasterStore;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DelegatedDynObject;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.persistence.PersistentState;

import org.gvsig.tools.persistence.exception.PersistenceException;

/**

 * Parameters for the Multifile provider

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class MultiFileDataParametersImpl extends AbstractRasterFileDataParameters implements MultiFileDataParameters {

	private List<RasterProvider>    providerList = null;

	public MultiFileDataParametersImpl() {

		super();

		providerList = new ArrayList<RasterProvider>();

		initialize();

	}

	protected void initialize() {

		delegatedDynObject = (DelegatedDynObject) ToolsLocator

				.getDynObjectManager().createDynObject(

						registerDynClass());

	}

	@SuppressWarnings("unchecked")

	public void loadFromState(PersistentState state)

			throws PersistenceException {

		super.loadFromState(state);

		DataManagerProviderServices dataManager = (DataManagerProviderServices)DALLocator.getDataManager();

		List<RasterDataParameters> parameters = state.getList("parameters");

		for (int i = 0; i < parameters.size(); i++) {

			try {

				DefaultRasterStore dSet = new DefaultRasterStore();

				AbstractRasterProvider provider = (AbstractRasterProvider)dataManager.createProvider(dSet, parameters.get(i));

				addProvider(provider);

			} catch (InitializeException e) {

				throw new PersistenceException(e);

			} catch (ProviderNotRegisteredException e) {

				throw new PersistenceException(e);

			}

		}

	}

	public void saveToState(PersistentState state) throws PersistenceException {

		super.saveToState(state);

		List<RasterProvider> provList = getProviders();

		List<RasterDataParameters> rasterDataParametersList = new ArrayList<RasterDataParameters>();

		for (int j = 0; j < provList.size(); j++) {

			rasterDataParametersList.add(provList.get(j).getDataParameters());

		}

		state.set("parameters", rasterDataParametersList);

	}

	public static DynStruct registerDynClass() {

		PersistenceManager manager = ToolsLocator.getPersistenceManager();

		DynStruct definition = manager.getDefinition("MultiFileDataParameters_Persistent");

		if( definition == null ) {

			definition = manager.addDefinition(

					MultiFileDataParametersImpl.class,

					"MultiFileDataParameters_Persistent",

					"MultiFileDataParameters Persistent",

					null,

					null

			);

			AbstractRasterDataParameters.registerDynClass(definition);

		}

		definition.addDynFieldList("parameters")

		.setClassOfItems(RasterDataParameters.class)

		.setMandatory(false);

		return definition;

	}

	public void removeAllProviders() {

		getProviders().clear();

		getParams().clear();

	}

	public boolean hasProviders() {

		return getProviders().size() > 0;

	}

	public void removeProvider(URI uri) {

		if(getProviders() != null) {

			List<RasterProvider> provList = getProviders();

			List<RasterDataParameters> paramList = getParams();

			for (int i = 0; i < provList.size(); i++) {

				RasterProvider rProv = provList.get(i);

				if(rProv.getURIOfFirstProvider().compareTo(uri) == 0) {

					provList.remove(i);

					paramList.remove(i);

					return;

				}

			}

		}

	}

	public void addProviderNotTiled(DataStoreProvider provider) {

		if(provider instanceof RasterProvider) {

			RasterProvider prov = (RasterProvider)provider;

			if(!prov.isTiled()) {

				addToList(prov);

			}

		}

	}

	public void setFirstProvider(DataStoreProvider provider) {

		if(provider instanceof RasterProvider) {

			RasterProvider prov = (RasterProvider)provider;

			if(getProviders() != null) {

				getProviders().set(0, prov);

				getParams().set(0, prov.getDataParameters());

			}

		}

	}

	public void addProvider(DataStoreProvider provider) {

		if(provider instanceof RasterProvider) {

			RasterProvider prov = (RasterProvider)provider;

			addToList(prov);

		}

	}

	public void addProvider(RasterDataStore rasterDataStore) {

		if(rasterDataStore instanceof DefaultRasterStore) {

			RasterProvider prov = (RasterProvider)((DefaultRasterStore)rasterDataStore).getProvider();

			addToList(prov);

		}

	}

	private void addToList(RasterProvider prov) {

		addProviderToList(prov);

		addParamToList(prov);

	}

	@SuppressWarnings("unchecked")

	private List<RasterDataParameters> getParams() {

		return (List<RasterDataParameters>)getDynValue("parameters");

	}

	private void addParamToList(RasterProvider prov) {

		List<RasterDataParameters> paramList = getParams();

		if(paramList == null) {

			paramList = new ArrayList<RasterDataParameters>();

			paramList.add(prov.getDataParameters());

			setDynValue("parameters", paramList);

		} else {

			paramList.add(prov.getDataParameters());

		}

	}

	public List<RasterProvider> getProviders() {

		return this.providerList;

	}

	private void addProviderToList(RasterProvider prov) {

		List<RasterProvider> provList = getProviders();

		if(provList == null) {

			provList = new ArrayList<RasterProvider>();

			provList.add(prov);

			setDynValue("parameters", provList);

		} else {

			provList.add(prov);

		}

	}

	public void setProviders(ArrayList<RasterProvider> provList) {

		List<RasterDataParameters> paramsList = new ArrayList<RasterDataParameters>();

		for (int i = 0; i < provList.size(); i++) {

			paramsList.add(provList.get(i).getDataParameters());

		}

		setDynValue("parameters", paramsList);

		providerList = provList;

	}

	public String getDataStoreName() {

		return MultiFileProvider.NAME;

	}

	public String getDescription() {

		return MultiFileProvider.DESCRIPTION;

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.raster.multifile.io;

import org.gvsig.fmap.dal.DALFileLibrary;

import org.gvsig.fmap.dal.DALLibrary;

import org.gvsig.tools.ToolsLibrary;

import org.gvsig.tools.library.AbstractLibrary;

import org.gvsig.tools.library.Library;

import org.gvsig.tools.library.LibraryException;

/**

 *

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class DefaultMultiFileIOLibrary extends AbstractLibrary {	

	@SuppressWarnings("deprecation")

	public DefaultMultiFileIOLibrary() {

		super(DefaultMultiFileIOLibrary.class,Library.TYPE.IMPL);

		require(ToolsLibrary.class);

		require(DALLibrary.class);

		require(DALFileLibrary.class);

	}

	@Override

	protected void doInitialize() throws LibraryException {

	}

	@Override

	protected void doPostInitialize() throws LibraryException {

		MultiFileServerExplorerParameters.registerDynClass();

		MultiFileDataParametersImpl.registerDynClass();

		MultiFileProvider.register();

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.raster.multifile.io;

import java.io.File;

import java.io.FileWriter;

import java.io.IOException;

import java.io.Reader;

import java.io.StringReader;

import java.text.ParseException;

import org.gvsig.fmap.dal.coverage.exception.ParsingException;

import org.gvsig.raster.impl.store.rmf.ClassSerializer;

import org.gvsig.raster.impl.store.rmf.RmfBlocksManager;

import org.kxml2.io.KXmlParser;

import org.xmlpull.v1.XmlPullParserException;

/**

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class MultiFileFormatSerializer extends ClassSerializer {

	//TAGS

	public static final String MAIN_TAG          = "MultiFileFormat";

	public static final String URIS              = "URIs";

	public static final String URI               = "URI";

	public static final String NAME              = "Name";

	private MultiFileFormat   multiFileFormat    = null;

	/**

	 * @param timeSeriesFormat

	 */

	public MultiFileFormatSerializer(MultiFileFormat timeSeriesFormat) {

		this.multiFileFormat = timeSeriesFormat;

	}

 	/**

	 * Parsers a date list

	 * @param tInfo

	 * @param parser

	 * @param xml

 	 * @param parseableTag

	 * @param tag

	 * @throws XmlPullParserException

	 * @throws IOException

	 * @throws ParsingException

	 * @throws NumberFormatException

	 * @throws ParseException

	 */

	public void parseURIs(KXmlParser parser, String xml, String parseableTag) throws XmlPullParserException, IOException, NumberFormatException, ParsingException, ParseException  {

		boolean end = false;

		boolean init = false;

		boolean readFile = false;

		int tag = parser.next();

		while (!end) {

			switch (tag) {

				case KXmlParser.END_DOCUMENT:

					return;

				case KXmlParser.START_TAG:

					if (parser.getName().compareTo(parseableTag) == 0) {

						init = true;

					}

					if(init) {

						if (parser.getName().compareTo(URI) == 0) {

							readFile = true;

						}

					}

					break;

				case KXmlParser.END_TAG:

					if (parser.getName().compareTo(parseableTag) == 0)

						end = true;

					break;

				case KXmlParser.TEXT:

					if(readFile) {

						String file = parser.getText();

						multiFileFormat.addFile(new File(file));

						readFile = false;

					}

					break;

			}

			if (!end)

				tag = parser.next();

		}

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.raster.dataset.io.rmf.IRmfBlock#read(java.lang.String)

	 */

	public void read(String xml) throws ParsingException {

		if(multiFileFormat == null)

			multiFileFormat = new MultiFileFormat();

		else {

			multiFileFormat.clean();

		}

		boolean init = false;

		boolean end = false;

		KXmlParser parser = new KXmlParser();

		Reader reader = new StringReader(xml);

		try {

			parser.setInput(reader);

		} catch (XmlPullParserException e) {

			throw new ParsingException(xml);

		}

		try {

			int tag = parser.nextTag();

			if ( parser.getEventType() != KXmlParser.END_DOCUMENT ){

				parser.require(KXmlParser.START_TAG, null, MAIN_TAG);

				while(tag != KXmlParser.END_DOCUMENT) {

					switch(tag) {

						case KXmlParser.START_TAG:

							if (parser.getName().compareTo(MAIN_TAG) == 0)

								init = true;

							break;

						case KXmlParser.END_TAG:

							if(parser.getName().compareTo(MAIN_TAG) == 0)

								end = true;

							break;

						case KXmlParser.TEXT:

							if(init) {

								String name = parserString(parser, NAME, null);

								multiFileFormat.setName(name);

								parseURIs(parser, xml, URIS);

								init = false;

							}

							break;

					}

					if(end)

						break;

					tag = parser.next();

				}

			}

		} catch (XmlPullParserException e) {

			throw new ParsingException(xml);

		} catch (IOException e) {

			throw new ParsingException(xml);

		} catch (NumberFormatException e) {

			throw new ParsingException(xml);

		} catch (ParseException e) {

			throw new ParsingException(xml);

		}

	}

	/**

	 * Writes a MultiFileFormat to disk

	 * @param multiFileFormat

	 * @param fileName

	 * @param file

	 * @throws IOException

	 */

	public static void write(MultiFileFormat multiFileFormat, String fileName) throws IOException {

		File file = new File(fileName);

		file.createNewFile();

		FileWriter writer = new FileWriter(file);

		MultiFileFormatSerializer serializer = new MultiFileFormatSerializer(multiFileFormat);

		writer.write(serializer.write());

		writer.close();

	}

	/**

	 * Reads a TimeSeriesFormat from disk

	 * @param timeSeriesFormat

	 * @param file

	 * @return MultiFileFormat

	 * @throws IOException

	 * @throws ParsingException

	 */

	public static MultiFileFormat read(MultiFileFormat timeSeriesFormat, String file) throws IOException, ParsingException {

		RmfBlocksManager manager = new RmfBlocksManager(file);

		MultiFileFormatSerializer serializer = new MultiFileFormatSerializer(timeSeriesFormat);

		manager.addClient(serializer);

		manager.read(null);

		return timeSeriesFormat;

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.raster.dataset.io.rmf.IRmfBlock#write()

	 */

	public String write() {

		StringBuffer b = new StringBuffer();

		b.append("<?xml version=\"1.0\" encoding=\"ISO-8859-15\"?>\n");

		b.append("<" + MAIN_TAG + ">\n");

		putProperty(b, NAME, multiFileFormat.getName(), 2);

		b.append("\t\t<" + URIS + ">\n");

		for (int i = 0; i < multiFileFormat.getNumberOfFiles(); i++) {

			putProperty(b, URI, multiFileFormat.getPathToFile(i), 3);

		}

		b.append("\t\t</" + URIS + ">\n");

		b.append("</" + MAIN_TAG + ">\n");

		return b.toString();

	}

	/*

	 * (non-Javadoc)

	 * @see org.gvsig.raster.dataset.io.rmf.IRmfBlock#getResult()

	 */

	public Object getResult() {

		return multiFileFormat;

	}

	/*

	 *  (non-Javadoc)

	 * @see org.gvsig.raster.dataset.io.rmf.IRmfBlock#getMainTag()

	 */

	public String getMainTag() {

		return MAIN_TAG;

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

*

* Copyright (C) 2007-2008 Infrastructures and Transports Department

* of the Valencian Government (CIT)

*

* This program is free software; you can redistribute it and/or

* modify it under the terms of the GNU General Public License

* as published by the Free Software Foundation; either version 2

* of the License, or (at your option) any later version.

*

* This program 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 General Public License for more details.

*

* You should have received a copy of the GNU General Public License

* along with this program; if not, write to the Free Software

* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

* MA  02110-1301, USA.

*

*/

/*

* AUTHORS (In addition to CIT):

* 2009 IVER T.I   {{Task}}

*/

package org.gvsig.raster.multifile.io;

import java.io.File;

import java.util.List;

import org.apache.commons.io.FilenameUtils;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataManager;

import org.gvsig.fmap.dal.DataServerExplorer;

import org.gvsig.fmap.dal.DataServerExplorerParameters;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.NewDataStoreParameters;

import org.gvsig.fmap.dal.coverage.RasterLocator;

import org.gvsig.fmap.dal.exception.CreateException;

import org.gvsig.fmap.dal.exception.DataException;

import org.gvsig.fmap.dal.exception.InitializeException;

import org.gvsig.fmap.dal.exception.ProviderNotRegisteredException;

import org.gvsig.fmap.dal.exception.RemoveException;

import org.gvsig.fmap.dal.serverexplorer.filesystem.impl.AbstractFilesystemServerExplorerProvider;

import org.gvsig.fmap.dal.serverexplorer.filesystem.spi.FilesystemServerExplorerProviderServices;

import org.gvsig.fmap.dal.spi.DataServerExplorerProvider;

import org.gvsig.fmap.dal.spi.DataServerExplorerProviderServices;

import org.gvsig.raster.impl.store.AbstractRasterFileDataParameters;

/**

 * Explorer for a Multifile

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class MultiFileServerExplorer extends AbstractFilesystemServerExplorerProvider implements DataServerExplorerProvider  {

	/**

	 *

	 */

	public MultiFileServerExplorer() {

	}

	/**

	 * @param parameters

	 * @param services

	 * @throws InitializeException

	 */

	public MultiFileServerExplorer(

			MultiFileServerExplorerParameters parameters,

			DataServerExplorerProviderServices services)

			throws InitializeException {

		System.out.println();

	}

        @Override

        public DataStoreParameters get(String string) throws DataException {

            return null;

        }

	public String getDataStoreProviderName() {

		return MultiFileProvider.NAME;

	}

	public String getDescription() {

		return MultiFileProvider.DESCRIPTION;

	}

	/**

	 * @return the DataStoreParameters

	 */

	public DataStoreParameters getStoreParameters() {

		DataManager manager = DALLocator.getDataManager();

		try {

			return  manager.createStoreParameters(this.getDataStoreProviderName());

		} catch (InitializeException e) {

			e.printStackTrace();

		} catch (ProviderNotRegisteredException e) {

			e.printStackTrace();

		}

		return null;

	}

	public List<?> getDataStoreProviderNames() {

		return null;

	}

	public String getProviderName() {

		return MultiFileProvider.NAME;

	}

	public DataServerExplorerProviderServices getServerExplorerProviderServices() {

		return null;

	}

	public boolean canCreate() {

		return false;

	}

	public boolean canCreate(NewDataStoreParameters parameters) {

		return false;

	}

	public void create(NewDataStoreParameters parameters, boolean overwrite)

			throws CreateException {

		throw new UnsupportedOperationException();

	}

	public NewDataStoreParameters getCreateParameters() throws DataException {

		return null;

	}

	public void initialize(

			FilesystemServerExplorerProviderServices serverExplorer) {

	}

	public boolean accept(File pathname) {

		return RasterLocator.getManager().getProviderServices().isExtensionSupported(

				pathname.getAbsolutePath(),

				MultiFileProvider.class);

	}

	public void remove(DataStoreParameters parameters) throws RemoveException {

		throw new UnsupportedOperationException();

	}

	public boolean add(String provider, NewDataStoreParameters parameters,

			boolean overwrite) throws DataException {

		return false;

	}

	public boolean canAdd() {

		return false;

	}

	public boolean canAdd(String storeName) throws DataException {

		return false;

	}

	public NewDataStoreParameters getAddParameters(String storeName)

			throws DataException {

		return null;

	}

	/**

	 * Creates store parameters from the file and returns it.

	 * @param file

	 * @return the DataStoreParameters

	 * @throws DataException

	 */

	public DataStoreParameters getParameters(File file) throws DataException {

		DataManager manager = DALLocator.getDataManager();

		AbstractRasterFileDataParameters params = (AbstractRasterFileDataParameters) manager

				.createStoreParameters(this.getDataStoreProviderName());

		params.setFile(file);

		return params;

	}

	public DataServerExplorerParameters getParameters() {

		return null;

	}

	public List<?> list() throws DataException {

		return null;

	}

	public List<?> list(int mode) throws DataException {

		return null;

	}

	public void dispose() {

	}

	public int getMode() {

		return DataServerExplorer.MODE_RASTER;

	}

    /* (non-Javadoc)

     * @see org.gvsig.fmap.dal.DataServerExplorer#getResourcePath(org.gvsig.fmap.dal.DataStore, java.lang.String)

     */

    @Override

    public File getResourcePath(DataStore dataStore, String resourceName) throws DataException {

        String rootPathName = getResourceRootPathName(dataStore);

        if (rootPathName == null) {

            return null;

        }

        File f = new File(FilenameUtils.getPathNoEndSeparator(rootPathName),resourceName);

        if( f.exists() ) {

            return f;

        }

        return new File(rootPathName + "." + resourceName);

    }

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.raster.multifile.io;

import java.io.File;

import java.io.IOException;

import java.util.ArrayList;

/**

 * MultiFileFormat information

 *

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class MultiFileFormat {

	public ArrayList<File>   fileList                       = new ArrayList<File>();

	private String           name                           = null;

	/**

	 * Gets the name of this serial

	 * @return String

	 */

	public String getName() {

		return name;

	}

	/**

	 * Sets the name of this serie

	 * @param name

	 */

	public void setName(String name) {

		this.name = name;

	}

	/**

	 * Gets the number of files of this serial

	 * @return int

	 */

	public int getNumberOfFiles() {

		return fileList.size();

	}

	/**

	 * Gets the path of the file in the selected position

	 * @param file

	 * @return String

	 */

	public String getPathToFile(int file) {

		return fileList.get(file).getAbsolutePath();

	}

	/**

	 * Adds a file to the list

	 * @param file

	 */

	public void addFile(File file) {

		fileList.add(file);

	}

	/**

	 * Cleans the list of files

	 */

	public void clean() {

		fileList.clear();

		name = null;

	}

	/**

	 * @param fileName

	 * @param path

	 * @param uriList

	 * @return String

	 * @throws IOException

	 */

	public static String saveMultiFileFormat(String fileName, String path, ArrayList<File> uriList) throws IOException {

		path = path + File.separator + fileName + ".mff";

		MultiFileFormat format = new MultiFileFormat();

		for (int i = 0; i < uriList.size(); i++) {

			format.addFile(uriList.get(i));

		}

		format.setName(fileName);

		format.write(path);

		return path;

	}

	/**

	 * Writes a MultiFileFormat to disk

	 * @param fileName

	 * @param file

	 * @throws IOException

	 */

	public void write(String fileName) throws IOException {

		MultiFileFormatSerializer.write(this, fileName);

	}

}

/* gvSIG. Geographic Information System of the Valencian Government

 *

 * Copyright (C) 2007-2008 Infrastructures and Transports Department

 * of the Valencian Government (CIT)

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of the GNU General Public License

 * as published by the Free Software Foundation; either version 2

 * of the License, or (at your option) any later version.

 *

 * This program 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 General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,

 * MA  02110-1301, USA.

 *

 */

package org.gvsig.raster.multifile.io;

import java.awt.geom.AffineTransform;

import java.awt.geom.Point2D;

import java.awt.geom.Rectangle2D;

import java.io.File;

import java.io.IOException;

import java.net.URI;

import java.net.URISyntaxException;

import java.util.List;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import org.gvsig.fmap.dal.DALFileLocator;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataStore;

import org.gvsig.fmap.dal.DataStoreParameters;

import org.gvsig.fmap.dal.coverage.RasterLocator;

import org.gvsig.fmap.dal.coverage.datastruct.BandList;

import org.gvsig.fmap.dal.coverage.datastruct.Extent;

import org.gvsig.fmap.dal.coverage.exception.BandAccessException;

import org.gvsig.fmap.dal.coverage.exception.BandNotFoundInListException;

import org.gvsig.fmap.dal.coverage.exception.FileNotOpenException;

import org.gvsig.fmap.dal.coverage.exception.FileNotSupportedException;

import org.gvsig.fmap.dal.coverage.exception.InvalidSetViewException;

import org.gvsig.fmap.dal.coverage.exception.InvalidSourceException;

import org.gvsig.fmap.dal.coverage.exception.NotSupportedExtensionException;

import org.gvsig.fmap.dal.coverage.exception.ParsingException;

import org.gvsig.fmap.dal.coverage.exception.ProcessInterruptedException;

import org.gvsig.fmap.dal.coverage.exception.RasterDriverException;

import org.gvsig.fmap.dal.coverage.store.parameter.RasterDataParameters;

import org.gvsig.fmap.dal.coverage.store.props.ColorInterpretation;

import org.gvsig.fmap.dal.coverage.store.props.ColorTable;

import org.gvsig.fmap.dal.coverage.store.props.HistogramComputer;

import org.gvsig.fmap.dal.coverage.store.props.Statistics;

import org.gvsig.fmap.dal.coverage.util.ProviderServices;

import org.gvsig.fmap.dal.exception.CloseException;

import org.gvsig.fmap.dal.exception.InitializeException;

import org.gvsig.fmap.dal.exception.OpenException;

import org.gvsig.fmap.dal.exception.ProviderNotRegisteredException;

import org.gvsig.fmap.dal.exception.ValidateDataParametersException;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorer;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemServerExplorerParameters;

import org.gvsig.fmap.dal.serverexplorer.filesystem.FilesystemStoreParameters;

import org.gvsig.fmap.dal.spi.DataManagerProviderServices;

import org.gvsig.fmap.dal.spi.DataStoreProvider;

import org.gvsig.fmap.dal.spi.DataStoreProviderServices;

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.raster.cache.tile.provider.TileServer;

import org.gvsig.raster.impl.buffer.SpiRasterQuery;

import org.gvsig.raster.impl.datastruct.BandListImpl;

import org.gvsig.raster.impl.datastruct.DatasetBandImpl;

import org.gvsig.raster.impl.datastruct.ExtentImpl;

import org.gvsig.raster.impl.provider.AbstractRasterProvider;

import org.gvsig.raster.impl.provider.RasterProvider;

import org.gvsig.raster.impl.provider.tile.FileTileServer;

import org.gvsig.raster.impl.store.DefaultRasterStore;

import org.gvsig.raster.impl.store.DefaultStoreFactory;

import org.gvsig.raster.impl.store.properties.DataStoreColorInterpretation;

import org.gvsig.raster.impl.store.properties.DataStoreTransparency;

import org.gvsig.raster.impl.store.properties.MultiProviderHistogramComputer;

import org.gvsig.raster.impl.store.properties.MultiProviderStatistics;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.locator.LocatorException;

/**

 * A data provider for a multiband image readed from different files

 *

 * @author Nacho Brodin (nachobrodin@gmail.com)

 */

public class MultiFileProvider extends AbstractRasterProvider {

	public static String                     NAME                     = "Multifile Raster";

	public static String                     DESCRIPTION              = "Multifile Raster Support";

	public final String                      METADATA_DEFINITION_NAME = NAME;

	private Extent                           viewRequest              = null;

	private TileServer                       tileServer               = null;

	private boolean                          open                     = false;

    private DataStoreTransparency            fileTransparency         = null;

    private static final Logger              logger                   = LoggerFactory.getLogger(MultiFileProvider.class);

    protected static String[]                formatList               = null;

	/**

	 *

	 */

	public static void register() {

		DataManagerProviderServices dataman = (DataManagerProviderServices) DALLocator.getDataManager();

		registerFormats();

		if (dataman != null && !dataman.getStoreProviders().contains(NAME)) {

			dataman.registerStoreProvider(NAME,

					MultiFileProvider.class, MultiFileDataParametersImpl.class);

		}

		if(DALFileLocator.getFilesystemServerExplorerManager() != null)

			DALFileLocator.getFilesystemServerExplorerManager().registerProvider(

					NAME, DESCRIPTION,

					MultiFileServerExplorer.class);

		if (!dataman.getExplorerProviders().contains(NAME)) {

			dataman.registerExplorerProvider(NAME, MultiFileServerExplorer.class, MultiFileServerExplorerParameters.class);

		}

		dataman.registerStoreFactory(NAME, DefaultStoreFactory.class);

	}

	private static void registerFormats() {

		formatList      = new String[] {

				"mff"};

		for (int i = 0; i < formatList.length; i++)

			RasterLocator.getManager().getProviderServices().addFormat(

					formatList[i],

					MultiFileProvider.class);

	}

	/**

	 *

	 */

	public MultiFileProvider() {

	}

	/**

	 * Opens the dataset.

	 * @param params

	 * @param proj Projection

	 * @param fName File name

	 * @throws NotSupportedExtensionException

	 * @throws OpenException

     * @deprecated use {@link #MultiFileProvider(URI)}, this constructor will be removed in gvSIG 2.5

	 */

	public MultiFileProvider(String params) throws NotSupportedExtensionException, OpenException {

		super(params);

        logger.info("Deprecated use of MultiFileProvider constructor");

		if(params instanceof String) {

			MultiFileDataParameters p = new MultiFileDataParametersImpl();

			URI uriObj;

            try {

                uriObj = new URI((String)params);

            } catch (URISyntaxException e) {

                throw new OpenException("Can't create uri from "+(String)params, e);

            }

			p.setURI(uriObj);

			super.init(p, null, ToolsLocator.getDynObjectManager()

					.createDynObject(

							MetadataLocator.getMetadataManager().getDefinition(

									DataStore.METADATA_DEFINITION_NAME)));

			init(p, null);

		}

	}

	 /**

     * Opens the dataset.

	 * @param uri

     * @param proj Projection

     * @param fName File name

     * @throws NotSupportedExtensionException

	 * @throws OpenException

     */

    public MultiFileProvider(URI uri) throws NotSupportedExtensionException, OpenException {

        super(uri);

        MultiFileDataParameters p = new MultiFileDataParametersImpl();

        p.setURI(uri);

        super.init(

            p,

            null,

            ToolsLocator.getDynObjectManager().createDynObject(

                MetadataLocator.getMetadataManager().getDefinition(DataStore.METADATA_DEFINITION_NAME)));

        init(p, null);

    }

    /**

     * @param params

     * @param storeServices

     * @throws NotSupportedExtensionException

     * @throws OpenException

     */

    public MultiFileProvider(MultiFileDataParametersImpl params,

			DataStoreProviderServices storeServices) throws NotSupportedExtensionException, OpenException {

		super(params, storeServices, ToolsLocator.getDynObjectManager()

				.createDynObject(

						MetadataLocator.getMetadataManager().getDefinition(

								DataStore.METADATA_DEFINITION_NAME)));

		init(params, storeServices);

	}

	/**

	 * Build file references

	 * @param params

	 * @param storeServices

	 * @param proj Projection

	 * @param param Load parameters

	 * @throws NotSupportedExtensionException

	 * @throws OpenException

	 */

	public void init(MultiFileDataParameters params,

			DataStoreProviderServices storeServices) throws NotSupportedExtensionException, OpenException {

		openFromMff();

		uri = getParameters().getURI();

		setParam(storeServices, params);

		try {

			setFirstProviderToNotTiled();

		} catch (InvalidSourceException e1) {

			throw new OpenException(e1.getMessage(), e1);

		}

		super.init();

		try {

			loadFromRmf(getRmfBlocksManager());

		} catch (ParsingException e) {

			logger.debug("Problems reading from RMF", e);

		}

		open = true;

	}

	/**

	 * Open from a .mff file.

	 * This method loads all providers and adds these to the parameters

	 * @throws OpenException

	 */

	private void openFromMff() throws OpenException {

		URI uriParam = getParameters().getURI();

        if (uriParam != null) {

            File fileFromUriParam = new File(uriParam);

            if (fileFromUriParam.exists()) {

                boolean loadedProviders = true;

                if (getParameters().hasProviders()) {

                    // solo se considera que est?n todos los providers cargados

                    // si existen y est?n open,

                    // sino se leer?n de disco

                    for (int i = 0; i < getParameters().getProviders().size(); i++) {

                        if (!getParameters().getProviders().get(i).isOpen())

                            loadedProviders = false;

                    }

                } else

                    loadedProviders = false;

                if (loadedProviders)

                    return;

                try {

                    if (getParameters().hasProviders())

                        getParameters().removeAllProviders();

                    MultiFileFormat multiFileFormat = new MultiFileFormat();

                    multiFileFormat = MultiFileFormatSerializer.read(multiFileFormat, fileFromUriParam.getAbsolutePath());

                    for (int i = 0; i < multiFileFormat.getNumberOfFiles(); i++) {

                        try {

                            File file = new File(multiFileFormat.getPathToFile(i));

                            if (file.exists()) {

                                RasterProvider prov = loadProvider(multiFileFormat.getPathToFile(i), storeServices);

                                getParameters().addProvider(prov);

                            }

                        } catch (ProviderNotRegisteredException e) {

                            throw new OpenException("A provider can't be loaded", e);

                        } catch (InitializeException e) {

                            throw new OpenException("A provider can't be initialized", e);

                        }

                    }

                } catch (IOException e1) {

                    throw new OpenException("File .mff can't be read", e1);

                } catch (ParsingException e1) {

                    throw new OpenException("File .mff can't be parsed", e1);

                }

            }

        }

	}

	/**

	 * Loads the specific provider

	 * @param file

	 * @return

	 * @throws NotSupportedExtensionException

	 * @throws FileNotSupportedException

	 */

	@SuppressWarnings("unchecked")

	private RasterProvider loadProvider(String file, DataStoreProviderServices storeServices) throws ProviderNotRegisteredException, InitializeException {

		DataManagerProviderServices dataManager = (DataManagerProviderServices)DALLocator.getDataManager();

		DataStoreProvider prov = null;

		if(file != null) {

			//We have to locate a provider's name which manages the selected file

			//A FilesystemServerExplorer will give a getProviderNames service

			FilesystemServerExplorerParameters paramsExplorer = (FilesystemServerExplorerParameters)dataManager.createServerExplorerParameters(FilesystemServerExplorer.NAME);

			FilesystemServerExplorer serverExplorer = null;

			try {

				paramsExplorer.setRoot(File.separator);

				serverExplorer = (FilesystemServerExplorer)dataManager.openServerExplorer(FilesystemServerExplorer.NAME, paramsExplorer);

			} catch (ValidateDataParametersException e) {

				throw new InitializeException(e);

			}

			File f = new File(file);

			//Gets the list of provider's name to manage the file

			List<String> provName = serverExplorer.getProviderNameList(f);

			if(provName.size() > 0) {

				for (int i = 0; i < provName.size(); i++) {

					//Gets the first provider what is not a TileProvider

					if(provName.get(i).compareTo("Tile Store") != 0) {

						DataStoreParameters newparams = dataManager.createStoreParameters(provName.get(i));

						((FilesystemStoreParameters)newparams).setFile(f);

						prov = dataManager.createProvider(storeServices, newparams);

					}

				}

			}

		}

		if(prov != null && prov instanceof RasterProvider) {

			if(((RasterProvider)prov).isRotated())

				throw new InitializeException("Rotation not supported tiling files", new Throwable());

			return (RasterProvider)prov;

		}

		return null;

	}

	/**

	 * Checks if the new file is compatible with the old one

	 * @param file

	 * @return

	 * @throws LocatorException

	 * @throws NotSupportedExtensionException

	 * @throws RasterDriverException

	 * @throws CloseException

	 */

	private boolean checkNewProvider(RasterProvider p) {

		Rectangle2D extentOrigin = getExtent().toRectangle2D();

		Extent extentNewFile = p.getExtent();

		// Comprobamos que el extent y tama�o del fichero a�adido sea igual al

		// fichero original. Si no es as� no abrimos la capa y mostramos un aviso

		double widthNewFile = (extentNewFile.getMax().getX() - extentNewFile.getMin().getX());

		double heightNewFile = (extentNewFile.getMax().getY() - extentNewFile.getMin().getY());

		if ((widthNewFile - extentOrigin.getWidth()) > 1.0 || (widthNewFile - extentOrigin.getWidth()) < -1.0 || (heightNewFile - extentOrigin.getHeight()) > 1.0