/ - Diff - | gvSIG desktop 1 - gvSIG

     import org.gvsig.fmap.data.exceptions.InitializeException;
     import org.gvsig.fmap.data.exceptions.ProviderNotRegisteredException;
     import org.gvsig.fmap.data.resource.ResourceManager;
     import org.gvsig.tools.evaluator.Evaluator;
     /**
      * This class contains all DAL specific services (note that resource management is {@link ResourceManager}'s responsibility)
      * are not related to resources.
+     *
      */
     public interface DataManager {
         /**
-...
     	 */
     	/**
     	 * Start a instance of the solicited parameters inicialize the instance name
     	 * and returns it.
     	 * Creates, initializes and returns an instance of the solicited parameters given the name with which they are registered.
+    	 *
     	 * @param String
     	 *            name
     	 *            name with which the parameters type were registered
     	 * @throws InitializeException
     	 *             TODO
     	 * @throws ProviderNotRegisteredException

     import java.util.Iterator;
     import org.gvsig.fmap.data.feature.spi.FeatureSetProvider;
     import org.gvsig.tools.evaluator.Evaluator;
     public interface FeatureIndexes {
     	/*
     	 * Returns an Index given the FeatureType and the name of the column.
     	 * If the column has no index then this method returns <code>null</code>.
     	 * @param fType FeatureType to which belongs the index
     	 * @param colName name of the column
     	 * @return if the index exists then this method returns the index, otherwise it returns null.
     	/**
     	 * Returns a FeatureIndex given the name with which it was created.
+    	 *
     	 * @param name FeatureIndex name
+    	 *
     	 * @return FeatureIndex or null if it is not found.
     	 */
     	//public DataIndex getDataIndex(FeatureType fType, String[] attrName);
     	public FeatureIndex getFeatureIndex(String name);
     	/**
     	 * Using the given evaluator attributes, choose and use an appropriate index
     	 * to obtain a FeatureSetProvider. If no index can be applied, then this method returns null
+    	 *
     	 * @return
     	 * @param evaluator
     	 * @return FeatureSetProvider or null if could not find any appropriate index.
+    	 *
     	 */
     	public FeatureSetProvider getFeatureSet(Evaluator evaluator);
     	/**
     	 * Returns an iterator over the indexes. Elements are of type FeatureIndex.
+    	 *
     	 * @return Iterator over the FeatureIndex(es).
     	 */
     	public Iterator iterator();
+    }

     import org.gvsig.fmap.data.exceptions.DataException;
     import org.gvsig.fmap.data.feature.FeatureIndex;
     import org.gvsig.fmap.data.feature.FeatureIndexes;
     import org.gvsig.fmap.data.feature.FeatureType;
     import org.gvsig.fmap.data.feature.exceptions.FeatureIndexException;
     import org.gvsig.fmap.data.feature.spi.FeatureSetProvider;
     import org.gvsig.fmap.data.feature.spi.index.FeatureIndexProviderServices;
-...
     import org.gvsig.tools.evaluator.EvaluatorFieldValue;
     /**
      * This class provides access to a FeatureStore local indexes either by
      * FeatureType and attrName or by index name.
      * This class provides access to a FeatureStore local indexes and also
      * decides which index to use given an evaluator containing the filter expression.
+     *
      * @author jyarza
      */
      */
     public class DefaultFeatureIndexes implements FeatureIndexes {
     	// Access by FeatureType and attribute name
     	private Map featureTypes = new HashMap();
     	// Access by index name
     	private Map names = new HashMap();
     	private Map names;
     	// Store to which this belongs
     	private DefaultFeatureStore store;
     	/**
-...
     	 */
     	public DefaultFeatureIndexes(DefaultFeatureStore store)
     			throws DataException {
     		names = new HashMap();
     		this.store = store;
     		Iterator it = store.getFeatureTypes().iterator();
     		while (it.hasNext()) {
     			FeatureType type = (FeatureType) it.next();
     			featureTypes.put(type, new HashMap());
+    		}
+    	}
     	/**
     	 * @see org.gvsig.fmap.data.index.DataIndexes#getDataIndex(org.gvsig.fmap.data.feature.FeatureType,
     	 *      java.lang.String)
     	 * @deprecated
     	 */
     	public FeatureIndex getFeatureIndex(FeatureType fType, String attrName) {
     		Map indexes = (Map) featureTypes.get(fType);
     		if (indexes != null) {
     			return (FeatureIndex) (indexes.get(attrName));
+    		}
     		return null;
+    	}
     	/* (non-Javadoc)
     	 * @see org.gvsig.fmap.data.index.DataIndexes#getDataIndex(java.lang.String)
     	 */
-...
     	 * @see org.gvsig.fmap.data.index.DataIndexes#addIndex(org.gvsig.fmap.data.feature.FeatureType, java.lang.String, org.gvsig.fmap.data.feature.DataIndex)
     	 */
     	public void addIndex(FeatureIndexProviderServices index) {
     		Map indexes = (Map) featureTypes.get(index.getFeatureType());
     		if (indexes == null) {
     			// This would mean that a new feature type has been added to the FeatureStore since this Indexes was created
     			indexes = new HashMap();
     			featureTypes.put(index.getFeatureType(), indexes);
+    		}
     		// FIXME Taking into account only the first attribute
     		indexes.put(index.getAttributeNames().get(0), index);
     		// By name
     		names.put(index.getName(), index);
+    	}
     	/**
     	 * @see org.gvsig.fmap.data.index.DataIndexes#contains(org.gvsig.fmap.data.feature.FeatureType,
     	 *      java.lang.String)
     	 * @deprecated
     	 */
     	public boolean contains(FeatureType fType, String attrName) {
     		Map map = (Map) featureTypes.get(fType);
     		return map == null ? false : map.containsKey(attrName);
+    	}
     	/**
     	 * @deprecated
     	 */
     	public boolean contains(String name) {
     		return names.containsKey(name);
+    	}
     	public Iterator iterator() {
     		return names.values().iterator();
+    	}
     	/**
     	 * Obtain a FeatureSetProvider over an index with the attributes used in the
     	 * evaluator or null if can't apply any index.
     	 * Using the given evaluator attributes, choose and use an appropriate index
     	 * to obtain a FeatureSetProvider. If no index can be applied, then this method returns null
+    	 *
     	 * @param evaluator
     	 * @return FeatureSetProvider or null if not has index availables.
     	 * @return FeatureSetProvider or null if could not find any appropriate index.
+    	 *
     	 */
     	public FeatureSetProvider getFeatureSet(Evaluator evaluator) {
-...
     			return index.apply();
     		} catch (Exception e) {
     			this.store.getLogger().error("Error buscando indice que aplicar.",
     			this.store.getLogger().error("Error searching for an index to apply.",
     					e);
     			return null;
+    		}

     package org.gvsig.fmap.data;
     /**
      * DataExplorer parameter container. Adds a method to obtain the
      * specific DataExplorerType described by this parameters.
+     *
      */
     public interface DataExplorerParameters extends DataParameters {
     	/**
     	 * Returns the DataExplorerType which describes the type of the DataExplorer represented
     	 * by this DataExplorerParameters
+    	 *
     	 * @return an instance of DataExplorerType
     	 */
     	public DataExplorerType getType();
+    }

     import org.gvsig.tools.locator.Locator;
     import org.gvsig.tools.locator.LocatorException;
     /**
      * @see {@link Locator}
+     *
      * This locator is the entry point of gvSIG's DAL, providing access to all DAL services.
      * DAL services are grouped in two managers {@link DataManager} and {@link ResourceManager}.
+     *
      * This locator offers methods for registering as well as for obtaining both managers' unique instances.
+     *
      */
     public class DALLocator extends AbstractLocator {
     	private static final String LOCATOR_NAME = "DALLocator";
     	/**
     	 * DataManager name used by the locator to access the instance
     	 */
     	public static final String DATA_MANAGER_NAME = "DataManager";
     	private static final String DATA_MANAGER_DESCRIPTION = "DataManager of gvSIG Data Access Library";
     	/**
     	 * ResourceManager name used by the locator to access the instance
     	 */
     	public static final String RESOURCE_MANAGER_NAME = "ResourceManager";
     	private static final String RESOURCE_MANAGER_DESCRIPTION = "ResourceManager of gvSIG Data Access Library";
-...
     		return instance;
+    	}
     	/**
     	 * Returns the Locator name.
+    	 *
     	 * @return String containing the locator name.
     	 */
     	public String getLocatorName() {
     		return LOCATOR_NAME;
+    	}
-...
     				clazz);
+    	}
     	/**
     	 * Registers a class as the default DataManager.
+    	 *
     	 * @param clazz
     	 * 			  implementing the DataManager interface
     	 */
     	public static void registerDefaultDataManager(Class clazz) {
     		getInstance().registerDefault(DATA_MANAGER_NAME, DATA_MANAGER_DESCRIPTION,
     				clazz);

     import org.gvsig.tools.locator.BaseLibrary;
     import org.gvsig.tools.locator.ReferenceNotRegisteredException;
     /**
      * Initializes gvSIG's desktop DAL by registering the default implementation for {@link DataManager}
      * and {@link ResourceManager}.
+     *
      */
     public class DALLibrary extends BaseLibrary {
         public void initialize() throws ReferenceNotRegisteredException {

     import org.gvsig.fmap.data.exceptions.DataException;
     /**
      * This interface provides a list of the available data stores in a server.
      * As its name indicates, it is used to explore the contents of a server.
+     *
      */
     public interface DataExplorer {
     	/**
     	 * Returns the DataExplorer's name
+    	 *
     	 * @return String containing this DataExplorer's name
     	 */
     	public String getName();
     	/**
     	 * Indicates whether this DataExplorer can be created.
+    	 *
     	 * @return true if this DataExplorer can be created or false otherwise.
     	 */
     	public boolean canCreate();
     	public List list() throws DataException; // List of DataStoreParameter
     	/**
     	 * Provides a list of available DataStoreParameters in the server.
+    	 *
     	 * @return list of DataStoreParameters
+    	 *
     	 * @throws DataException
     	 */
     	public List list() throws DataException;
     	/**
     	 * Adds a DataStoreParameters to this DataExplorer.
+    	 *
     	 * @param
     	 * 		parameters, an instance of DataStoreParameters.
     	 * @return true if the DataStoreParameters were successfully added, false otherwise.
+    	 *
     	 * @throws DataException
     	 */
     	public boolean add(DataStoreParameters parameters)
     			throws DataException;
     	/**
+    	 *
     	 * @param parameters
     	 * @throws DataException
     	 */
     	void remove(DataStoreParameters parameters) throws DataException;
     	/**
+    	 *
     	 * @param storeName
     	 * @return
     	 */
     	public DataStoreParameters getCreationParameters(String storeName);
     	/**
+    	 *
     	 * @throws DataException
     	 */
     	public void dispose() throws DataException;
     	/**
+    	 *
     	 * @return
     	 */
     	public DataExplorerParameters getParameters();
+    }

     package org.gvsig.fmap.data;
     /**
      * This interface describes a DataExplorerType
      * by providing its name and description.
      */
     public interface DataExplorerType {
     	/**
     	 * Returns the name of this DataExplorerType
+    	 *
     	 * @return String containing the name of this DataExplorerType
     	 */
     	public String getName();
     	/**
     	 * Returns the description of this DataExplorerType
+    	 *
     	 * @return String containing the description of this DataExplorerType
     	 */
     	public String getDescription();
+    }

| gvSIG desktop 1

Revision 24366