/branches/v2_0_0_prep/libraries/libFMap_dal/src/org/gvsig/fmap/dal/feature/impl/DefaultFeatureIndex.java - Diff - | gvSIG desktop 1 - gvSIG

Revision 36235 branches/v2_0_0_prep/libraries/libFMap_dal/src/org/gvsig/fmap/dal/feature/impl/DefaultFeatureIndex.java

     import java.util.ArrayList;
     import java.util.List;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
     import org.cresques.Messages;
     import org.gvsig.fmap.dal.DataStoreNotification;
     import org.gvsig.fmap.dal.DataTypes;
     import org.gvsig.fmap.dal.exception.DataException;
     import org.gvsig.fmap.dal.exception.InitializeException;
     import org.gvsig.fmap.dal.feature.Feature;
     import org.gvsig.fmap.dal.feature.FeatureAttributeDescriptor;
     import org.gvsig.fmap.dal.feature.FeatureSet;
     import org.gvsig.fmap.dal.feature.FeatureStore;
     import org.gvsig.fmap.dal.feature.FeatureStoreNotification;
     import org.gvsig.fmap.dal.feature.FeatureType;
     import org.gvsig.fmap.dal.feature.exception.FeatureIndexException;
     import org.gvsig.fmap.dal.feature.exception.FeatureIndexOperationException;
     import org.gvsig.fmap.dal.feature.exception.InvalidFeatureIndexException;
     import org.gvsig.fmap.dal.feature.spi.DefaultLongList;
     import org.gvsig.fmap.dal.feature.spi.FeatureReferenceProviderServices;
     import org.gvsig.fmap.dal.feature.spi.FeatureStoreProviderServices;
     import org.gvsig.fmap.dal.feature.spi.index.FeatureIndexProvider;
     import org.gvsig.fmap.dal.feature.spi.index.FeatureIndexProviderServices;
     import org.gvsig.i18n.Messages;
     import org.gvsig.tools.ToolsLocator;
     import org.gvsig.tools.dispose.DisposableIterator;
     import org.gvsig.tools.dispose.DisposeUtils;
     import org.gvsig.tools.observer.impl.BaseWeakReferencingObservable;
     import org.gvsig.tools.task.SimpleTaskStatus;
     import org.gvsig.tools.task.TaskStatusManager;
     import org.gvsig.tools.observer.Observer;
     import org.gvsig.tools.observer.WeakReferencingObservable;
     import org.gvsig.tools.observer.impl.DelegateWeakReferencingObservable;
     import org.gvsig.tools.task.AbstractMonitorableTask;
     import org.gvsig.tools.task.CancellableTask;
     import org.gvsig.tools.task.MonitorableTask;
     /**
      * Default feature index provider services.
+     *
      * @author jyarza
+     *
      * @author gvSIG team
      */
     public class DefaultFeatureIndex extends BaseWeakReferencingObservable
         implements FeatureIndexProviderServices {
     public class DefaultFeatureIndex implements FeatureIndexProviderServices,
         WeakReferencingObservable {
         private static final Logger LOG = LoggerFactory
             .getLogger(DefaultFeatureIndex.class);
         private final FeatureStoreProviderServices featureStore;
         private final FeatureType featureType;
         private final String attributeName;
-...
         private final FeatureIndexProvider indexProvider;
         private List attributeNames;
         private boolean filling = false;
         private Object featureOperationTaskLock = new Object();
         private FeatureIndexOperationTask featureIndexTask;
         private boolean valid = true;
         private DelegateWeakReferencingObservable observable =
             new DelegateWeakReferencingObservable(this);
         public DefaultFeatureIndex(FeatureStoreProviderServices featureStore,
             FeatureType featureType, FeatureIndexProvider indexProvider,
             String attributeName, String indexName) {
             if (featureStore == null) {
                 throw new IllegalArgumentException("featureStore cannot be null.");
+            }
-...
             return featureType;
+        }
         public final String getName() {
             return indexName;
+        }
         public final String getAttributeName() {
             return attributeName;
+        }
-...
             return dataType;
+        }
         public final void fill() throws FeatureIndexException {
             fill(false);
+        }
         /**
          * {@link MonitorableTask} and {@link CancellableTask} to perform long
          * operations on the index: filling and inserting or deleting a feature set.
+         *
          * @author gvSIG Team
          * @version $Id$
          */
         private static class FeatureIndexOperationTask extends
             AbstractMonitorableTask {
         public void fill(boolean background)
             throws FeatureIndexException {
             if (background) {
                 filling = true;
             private final DefaultFeatureIndex index;
                 Runnable task = new Runnable() {
             public static final int OP_FILL = 0;
             public static final int OP_INSERT_FSET = 1;
             public static final int OP_DELETE_FSET = 2;
                     public void run() {
                         try {
                             clearAndFill();
                         } catch (DataException e) {
                             LOG.error("Error filling index: " + this, e);
             private static final String[] OP_NAMES = { //
                 Messages.getText("filling_index"), // OP_FILL
                     Messages.getText("updating_index"), // OP_INSERT_FSET
                     Messages.getText("updating_index"), // OP_DELETE_FSET
                 };
             private final int operation;
             private final FeatureSet data;
             private final Observer operationObserver;
             private final FeatureStore store;
             /**
              * Creates a new {@link FeatureIndexOperationTask}
+             *
              * @param index
              *            to operate on
              * @param store
              *            to index data from
              * @param operation
              *            to perform: {@link #OP_FILL}, {@link #OP_INSERT_FSET} or
              *            {@link #OP_DELETE_FSET}
              * @param data
              *            feature set to insert or delete in the insert or delete
              *            operations
              * @param operationObserver
              *            to be notified when the operation starts, finishes, is
              *            cancelled or has finished with errors
              */
             protected FeatureIndexOperationTask(DefaultFeatureIndex index,
                 FeatureStore store, int operation, FeatureSet data,
                 Observer operationObserver) {
                 super(OP_NAMES[operation]);
                 this.index = index;
                 this.store = store;
                 this.operation = operation;
                 this.data = data;
                 this.operationObserver = operationObserver;
                 setDaemon(true);
                 setPriority(MIN_PRIORITY);
+            }
             public void run() {
                 try {
                     switch (operation) {
                     case OP_FILL:
                         notify(FeatureStoreNotification.INDEX_FILLING_STARTED);
                         clearAndFill();
                         break;
                     case OP_INSERT_FSET:
                         notify(FeatureStoreNotification.INDEX_FILLING_STARTED);
                         insert(data);
                         break;
                     case OP_DELETE_FSET:
                         notify(FeatureStoreNotification.INDEX_FILLING_STARTED);
                         delete(data);
                         break;
+                    }
                 } catch (Exception e) {
                     Exception fioex =
                         new FeatureIndexOperationException(index,
                             OP_NAMES[operation], e);
                     notify(FeatureStoreNotification.INDEX_FILLING_ERROR, fioex);
                     throw new RuntimeException(fioex);
                 } finally {
                     index.removeTask(this);
+                }
+            }
             /**
              * Clears the index data and fills it again.
              */
             private void clearAndFill() throws DataException {
                 FeatureSet set = null;
                 try {
                     set = store.getFeatureSet();
                     synchronized (index) {
                         if (isCancellationRequested()) {
                             cancel();
                             return;
+                        }
                         index.clear();
                         if (isCancellationRequested()) {
                             cancel();
                             return;
+                        }
                         insert(set);
                         index.setValid(true);
+                    }
                 };
                 } finally {
                     DisposeUtils.dispose(set);
+                }
+            }
                 Thread thread = new Thread(task, "Fill index data");
                 thread.setDaemon(true);
                 // thread.setPriority(-1);
                 thread.start();
             } else {
             private void insert(FeatureSet data) throws DataException {
                 DisposableIterator it = null;
                 taskStatus.setRangeOfValues(0, data.getSize());
                 taskStatus.add();
                 long counter = 0;
                 try {
                     clearAndFill();
                     it = data.fastIterator();
                     synchronized (index) {
                         while (it.hasNext()) {
                             if (isCancellationRequested()) {
                                 index.clear();
                                 cancel();
                                 return;
+                            }
                             Feature feat = (Feature) it.next();
                             index.insert(feat);
                             taskStatus.setCurValue(counter++);
+                        }
                         notify(FeatureStoreNotification.INDEX_FILLING_SUCCESS);
+                    }
                     taskStatus.terminate();
                 } catch (RuntimeException e) {
                     taskStatus.abort();
                     throw e;
                 } catch (DataException e) {
                     taskStatus.abort();
                     throw e;
                 } finally {
                     DisposeUtils.dispose(it);
                     taskStatus.remove();
+                }
+            }
             private void delete(FeatureSet data) throws FeatureIndexException {
                 DisposableIterator it = null;
                 try {
                     it = data.fastIterator();
                     synchronized (index) {
                         while (it.hasNext()) {
                             if (isCancellationRequested()) {
                                 cancel();
                                 return;
+                            }
                             Feature feat = (Feature) it.next();
                             index.delete(feat);
+                        }
                         notify(FeatureStoreNotification.INDEX_FILLING_SUCCESS);
+                    }
                 } catch (DataException e) {
                     throw new FeatureIndexException(e);
                 } finally {
                     DisposeUtils.dispose(it);
+                }
+            }
+        }
         /**
          * Clears the index data and fills it again.
          */
         private synchronized void clearAndFill() throws DataException {
             FeatureSet set = null;
             try {
                 filling = true;
                 set =
                     getFeatureStoreProviderServices().getFeatureStore()
                         .getFeatureSet();
                 clear();
                 doInsert(set);
                 filling = false;
                 notify(this, new DefaultFeatureStoreNotification(
                     getFeatureStoreProviderServices().getFeatureStore(),
                     FeatureStoreNotification.INDEX_FILLED_SUCCESSFULLY, this));
             } catch (DataException e) {
                 filling = false;
                 setValid(false);
                 notify(this, new DefaultFeatureStoreNotification(
                     getFeatureStoreProviderServices().getFeatureStore(),
                     FeatureStoreNotification.INDEX_FILLING_ERROR, e));
                 throw new FeatureIndexException(e);
             } finally {
                 DisposeUtils.dispose(set);
             private void cancel() {
                 notify(FeatureStoreNotification.INDEX_FILLING_CANCELLED);
                 taskStatus.cancel();
+            }
+        }
         public synchronized final void insert(FeatureSet data) throws DataException {
             if (!isValid()) {
                 throw new InvalidFeatureIndexException();
             public void notifyOperationObserver(DataStoreNotification notification) {
                 if (this.operationObserver != null) {
                     this.operationObserver.update(index, notification);
+                }
+            }
             try {
                 filling = true;
                 doInsert(data);
             } finally {
                 filling = false;
             private void notify(String notificationType) {
                 DataStoreNotification notification =
                     new DefaultFeatureStoreNotification(store, notificationType,
                         index);
                 notifyOperationObserver(notification);
                 index.notifyObservers(notification);
+            }
             private void notify(String notificationType, Exception exception) {
                 DataStoreNotification notification =
                     new DefaultFeatureStoreNotification(store, notificationType,
                         exception);
                 notifyOperationObserver(notification);
                 index.notifyObservers(notification);
+            }
+        }
         private void doInsert(FeatureSet data) throws DataException {
             DisposableIterator it = null;
             TaskStatusManager statusManager = ToolsLocator.getTaskStatusManager();
             SimpleTaskStatus status =
                 statusManager.createDefaultSimpleTaskStatus(Messages
                     .getText("filling_index"));
             status.setCancellable(false);
             status.setRangeOfValues(0, data.getSize());
             status.add();
             long counter = 0;
             try {
                 it = data.fastIterator();
                 while (it.hasNext()) {
                     Feature feat = (Feature) it.next();
                     doInsert(feat);
                     status.setCurValue(counter++);
         private FeatureIndexOperationTask createIndexTask(int operation,
             FeatureSet data, Observer observer) {
             synchronized (featureOperationTaskLock) {
                 if (featureIndexTask != null) {
                     this.featureIndexTask.cancelRequest();
                     removeTask(this.featureIndexTask);
+                }
             } catch (RuntimeException e) {
                 status.abort();
                 throw e;
             } finally {
                 DisposeUtils.dispose(it);
                 status.remove();
                 FeatureIndexOperationTask fillingTask =
                     new FeatureIndexOperationTask(this,
                         featureStore.getFeatureStore(), operation, data, observer);
                 this.featureIndexTask = fillingTask;
                 return fillingTask;
+            }
+        }
         public synchronized final void insert(Feature feat) {
             if (!isValid()) {
                 throw new RuntimeException(new InvalidFeatureIndexException());
         private void removeTask(FeatureIndexOperationTask task) {
             synchronized (featureOperationTaskLock) {
                 // Remove if it is not null and the same task
                 if (this.featureIndexTask == task) {
                     featureIndexTask = null;
+                }
+            }
             try {
                 filling = true;
                 doInsert(feat);
             } finally {
                 filling = false;
+        }
         public void fill() throws FeatureIndexException {
             fill(false, null);
+        }
         public void fill(boolean background, Observer observer)
             throws FeatureIndexException {
             FeatureIndexOperationTask task =
                 createIndexTask(FeatureIndexOperationTask.OP_FILL, null, observer);
             if (background) {
                 task.start();
             } else {
                 task.run();
+            }
+        }
         private void doInsert(Feature feat) {
         public final void insert(FeatureSet data) throws DataException {
             if (!isValid()) {
                 throw new InvalidFeatureIndexException();
+            }
             FeatureIndexOperationTask task =
                 createIndexTask(FeatureIndexOperationTask.OP_INSERT_FSET, data,
                     null);
             task.run();
+        }
         public synchronized final void insert(Feature feat) throws DataException {
             try {
                 indexProvider.insert(feat.get(attributeName),
                 getIndexProvider().insert(feat.get(getAttributeName()),
                     (FeatureReferenceProviderServices) feat.getReference());
             } catch (NullPointerException e) {
                 throw new IllegalArgumentException(
                     "Feature does not contain a column with name " + attributeName);
                 throw new IllegalArgumentException("Could not add Feature: " + feat
                     + " to index " + this
                     + ". It does not contain a column with name "
                     + getAttributeName(), e);
             } catch (ClassCastException e) {
                 throw new IllegalArgumentException(
                     "Attribute data type is not valid.");
                 throw new IllegalArgumentException("Could not add Feature: " + feat
                     + " to index " + this + ". Attribute " + getAttributeName()
                     + " data type is not valid.", e);
+            }
+        }
         public FeatureSet getMatchFeatureSet(Object value)
         public final void delete(FeatureSet data) throws FeatureIndexException {
             if (!isValid()) {
                 throw new InvalidFeatureIndexException();
+            }
             FeatureIndexOperationTask task =
                 createIndexTask(FeatureIndexOperationTask.OP_DELETE_FSET, data,
                     null);
             task.run();
+        }
         public synchronized final void delete(Feature feat) throws DataException {
             getIndexProvider().delete(feat.get(getAttributeName()),
                 (FeatureReferenceProviderServices) feat.getReference());
+        }
         private synchronized void clear() throws DataException {
             getIndexProvider().clear();
+        }
         public synchronized FeatureSet getMatchFeatureSet(Object value)
             throws FeatureIndexException {
             if (!isValid()) {
                 throw new InvalidFeatureIndexException();
-...
                 indexProvider.match(value)));
+        }
         public FeatureSet getRangeFeatureSet(Object value1, Object value2)
             throws FeatureIndexException {
         public synchronized FeatureSet getRangeFeatureSet(Object value1,
             Object value2) throws FeatureIndexException {
             if (!isValid()) {
                 throw new InvalidFeatureIndexException();
+            }
-...
                 indexProvider.range(value1, value2)));
+        }
         public FeatureSet getNearestFeatureSet(int count, Object value)
         public synchronized FeatureSet getNearestFeatureSet(int count, Object value)
             throws FeatureIndexException {
             if (!isValid()) {
                 throw new InvalidFeatureIndexException();
-...
                 indexProvider.nearest(count, value)));
+        }
         public FeatureSet getNearestFeatureSet(int count, Object value,
             Object tolerance) throws FeatureIndexException {
         public synchronized FeatureSet getNearestFeatureSet(int count,
             Object value, Object tolerance) throws FeatureIndexException {
             if (!isValid()) {
                 throw new InvalidFeatureIndexException();
+            }
-...
             indexProvider.initialize();
+        }
         public synchronized final void delete(Feature feat) {
             if (!isValid()) {
                 throw new RuntimeException(new InvalidFeatureIndexException());
+            }
             try {
                 filling = true;
                 doDelete(feat);
             } finally {
                 filling = false;
+            }
+        }
         private void doDelete(Feature feat) {
             indexProvider.delete(feat.get(this.attributeName),
                 (FeatureReferenceProviderServices) feat.getReference());
+        }
         public synchronized final void delete(FeatureSet data)
             throws FeatureIndexException {
             if (!isValid()) {
                 throw new InvalidFeatureIndexException();
+            }
             DisposableIterator it = null;
             try {
                 filling = true;
                 it = data.fastIterator();
                 while (it.hasNext()) {
                     Feature feat = (Feature) it.next();
                     doDelete(feat);
+                }
             } catch (DataException e) {
                 throw new FeatureIndexException(e);
             } finally {
                 filling = false;
                 DisposeUtils.dispose(it);
+            }
+        }
         private void clear() throws DataException {
             indexProvider.clear();
+        }
         public List getAttributeNames() {
             return attributeNames;
+        }
-...
+        }
         public boolean isFilling() {
             return filling;
             synchronized (featureOperationTaskLock) {
                 return featureIndexTask != null;
+            }
+        }
         public boolean isValid() {
             return !isFilling() && valid;
             synchronized (featureOperationTaskLock) {
                 return !isFilling() && valid;
+            }
+        }
         public void setValid(boolean valid) {
             this.valid = valid;
             synchronized (featureOperationTaskLock) {
                 this.valid = valid;
+            }
+        }
         public String toString() {
-...
                 + ", for the FeatureType: " + featureType + ", and the attribute: "
                 + attributeName;
+        }
         public void notifyObservers(Object notification) {
             observable.notifyObservers(notification);
+        }
         public String getName() {
             return indexName;
+        }
         private FeatureIndexProvider getIndexProvider() {
             return indexProvider;
+        }
         public void addObserver(Observer observer) {
             observable.addObserver(observer);
+        }
         public void deleteObserver(Observer observer) {
             observable.deleteObserver(observer);
+        }
         public void deleteObservers() {
             observable.deleteObservers();
+        }
+    }

Also available in: Unified diff