Application: gvSIG desktop

package org.gvsig.fmap.dal.feature.spi.simpleprovider;

import java.io.File;

import java.io.IOException;

import java.io.InputStream;

import java.net.URL;

import org.apache.commons.io.FilenameUtils;

import org.gvsig.fmap.dal.DALFileLocator;

import org.gvsig.fmap.dal.DALLocator;

import org.gvsig.fmap.dal.DataParameters;

import org.gvsig.fmap.dal.feature.FeatureStoreProviderFactory;

import org.gvsig.fmap.dal.feature.OpenFeatureStoreParameters;

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

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

import org.gvsig.metadata.MetadataLocator;

import org.gvsig.metadata.MetadataManager;

import org.gvsig.tools.ToolsLocator;

import org.gvsig.tools.dynobject.DynStruct;

import org.gvsig.tools.persistence.PersistenceManager;

import org.gvsig.tools.util.URLUtils;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

/**

 *

 * @author jjdelcerro

 */

public abstract class AbstractSimpleSequentialReaderFactory implements SimpleSequentialReaderFactory {

    protected Logger LOGGER = LoggerFactory.getLogger(AbstractSimpleSequentialReaderFactory.class);

    private final String name;

    private final String description;

    private final String[] extensions;

    protected AbstractSimpleSequentialReaderFactory(

            String name,

            String description,

            String[] extensions

    ) {

        this.name = name;

        this.description = description;

        this.extensions = extensions;

    }

    protected Logger logger() {

        return LOGGER;

    }

    @Override

    public String getName() {

        return name;

    }

    @Override

    public String getDescription() {

        return description;

    }

    @Override

    public String[] getExtensions() {

        return extensions;

    }

    public final boolean isValidExtension(File f) {

      if( f == null ) {

        return false;

      }

      String[] theExtensions = this.getExtensions();

      if( theExtensions==null ) {

        // Si no hay especificadas extensiones decimos que vale.

        return true; 

      }

      String extension = FilenameUtils.getExtension(f.getName()).trim();

      if( extension.isEmpty() ) {

        // Si el fichero no tiene extension decimos que vale.

        return true; 

      }

      for (String currentExtension : theExtensions) {

        if (currentExtension != null ) {

          currentExtension = currentExtension.trim();

          if( !currentExtension.isEmpty() && extension.equalsIgnoreCase(currentExtension) ) {

            return true;

          }

        }

      }

      return false;

    }

    @Override

    public boolean accept(File f) {

        return isValidExtension(f);

    }

    @Override

    public FeatureStoreProviderFactory createStoreProviderFactory() {

        return new SimpleSequentialReaderStoreProviderFactory(this);

    }

    @Override

    public FilesystemServerExplorerProviderFactory createFilesystemServerProviderFactory() {

        return new SimpleSequentialReaderFilesystemServerProviderFactory(this);

    }

    private InputStream openStream(URL url) {

//        try {

            return URLUtils.openStream(url);

//        } catch (IOException ex) {

//            return null;

//        }

    }

    @Override

    public void selfRegister(Class loader) {

        this.selfRegister(

                loader.getResource(this.getName() + "Parameters.xml"),

                loader.getResource(this.getName() + "Metadata.xml")

        );    

    }

    @SuppressWarnings("UseSpecificCatch")

    @Override

    public void selfRegister(URL parameters_xml, URL metadata_xml) {

        DynStruct definition;

        PersistenceManager persistenceManager = ToolsLocator.getPersistenceManager();

        definition = persistenceManager.getDefinition(this.getName());

        if (definition == null) {

            InputStream stream = this.openStream(parameters_xml);

            if (stream == null) {

                throw new RuntimeException("Can't access parameters definition in resource '" + parameters_xml.toString() + "'.");

            }

            persistenceManager.updateDefinition(

                    SimpleSequentialReaderStoreParameters.class,

                    this.getName(),

                    stream,

                    SimpleSequentialReaderStoreParameters.class.getClassLoader(),

                    null,

                    null

            );

        }

        if( metadata_xml!=null ) {

            MetadataManager metadataManager = MetadataLocator.getMetadataManager();

            try {

                definition = metadataManager.getDefinition(this.getName());

                if (definition == null) {

                    InputStream stream = this.openStream(metadata_xml);

                    metadataManager.addDefinition(

                            this.getName(),

                            stream,

                            SimpleSequentialReaderStoreParameters.class.getClassLoader()

                    );

                }

            } catch (Exception e) {

                LOGGER.warn(

                        "Can't access metadata definition in resource '" + metadata_xml.toString() + "'.",

                        e

                );

            }

        }

        DataManagerProviderServices dataman = (DataManagerProviderServices) DALLocator

                .getDataManager();

        if (!dataman.getStoreProviders().contains(this.getName())) {

            dataman.registerStoreProviderFactory(

                    new SimpleSequentialReaderStoreProviderFactory(this)

            );

        }

        try {

            DALFileLocator.getFilesystemServerExplorerManager()

                    .registerProviderFactory(

                            new SimpleSequentialReaderFilesystemServerProviderFactory(this)

                    );

        } catch (Exception e) {

            LOGGER.warn(

                "Can't register filesystem server provider factory ("+this.getName()+").",

                e

            );

        }

    }

    @Override

    public void fetchDefaultParameters(DataParameters parameters) {

        // Default do nothing

    }

    @Override

    public abstract SimpleSequentialReader createReader(OpenFeatureStoreParameters params);

}