/trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.impl/src/main/java/org/gvsig/fmap/dal/feature/paging/impl/FeaturePagingHelperImpl.java - Diff - Application: gvSIG desktop - gvSIG

Revision 44977 trunk/org.gvsig.desktop/org.gvsig.desktop.compat.cdc/org.gvsig.fmap.dal/org.gvsig.fmap.dal.impl/src/main/java/org/gvsig/fmap/dal/feature/paging/impl/FeaturePagingHelperImpl.java

     /**
      * gvSIG. Desktop Geographic Information System.
+     *
      * Copyright (C) 2007-2013 gvSIG Association.
      * Copyright (C) 2007-2020 gvSIG Association.
+     *
      * This program is free software; you can redistribute it and/or
      * modify it under the terms of the GNU General Public License
-...
     import java.util.Iterator;
     import java.util.List;
     import java.util.ListIterator;
     import java.util.logging.Level;
     import org.apache.commons.lang3.mutable.MutableBoolean;
     import org.slf4j.Logger;
     import org.slf4j.LoggerFactory;
-...
+     *
      * @author gvSIG Team
      */
     @SuppressWarnings("UseSpecificCatch")
     public class FeaturePagingHelperImpl extends DefaultDynObjectPagingHelper
         implements FeaturePagingHelper {
             implements FeaturePagingHelper {
         private static final Logger LOG = LoggerFactory.getLogger(FeaturePagingHelperImpl.class);
-...
             private final long number;
             private final int size;
             private long lastaccess;
             public Page(long number, int size) {
                 this.size = size;
                 this.number = number;
-...
             public void setFeature(int i, Feature copy) {
                 this.features[i] = copy;
+            }
             public Feature[] getFeatures() {
                 this.lastaccess = (new Date()).getTime();
                 return this.features;
+            }
             public long getPageNumber() {
                 return this.number;
+            }
             public long getLastAccess() {
                 return this.lastaccess;
+            }
             public int size() {
                 return this.size;
+            }
             public void dispose() {
                 for (int i = 0; i < features.length; i++) {
                     features[i] = null;
-...
                 this.features = null;
                 this.lastaccess = 0;
+            }
+        }
+        }
         private static class PageCache {
             private final int maxpages;
             private List<Page> pages;
             public PageCache(int maxpages) {
                 this.maxpages = maxpages;
                 this.pages = new ArrayList<>();
+            }
             public void clear() {
                 for (Page page : pages) {
                 pages.forEach((page) -> {
                     page.dispose();
+                }
                 this.pages = new ArrayList<>();
                 });
                 this.pages = new ArrayList<>();
+            }
             public Page get(long pageNumber) {
                 for( Page page : pages ) {
                     if( page.getPageNumber() == pageNumber ) {
                 for (Page page : pages) {
                     if (page.getPageNumber() == pageNumber) {
                         return page;
+                    }
+                }
                 return null;
+            }
             public void add(Page page) {
                 if( this.pages.size()< this.maxpages ) {
                 if (this.pages.size() < this.maxpages) {
                     this.pages.add(page);
                     return;
+                }
                 int toDrop = 0;
                 for( int i=0; i<this.pages.size(); i++ ) {
                     if( this.pages.get(i).getLastAccess()<this.pages.get(toDrop).getLastAccess() ) {
                 for (int i = 0; i < this.pages.size(); i++) {
                     if (this.pages.get(i).getLastAccess() < this.pages.get(toDrop).getLastAccess()) {
                         toDrop = i;
+                    }
+                }
                 this.pages.set(toDrop, page);
+            }
+        }
         private FeatureQuery query;
         private FeatureStore featureStore;
         /** If the selected Features must be returned as the first ones. **/
         /**
          * If the selected Features must be returned as the first ones. *
          */
         private boolean selectionUp = false;
         private FeatureSet featSet = null;
         private FeatureSelection initialSelection = null;
         private Feature[] features = null;
         private PageCache cachedPages = null;
-...
         private boolean initialization_completed = false;
         private FeatureSelection selection = null;
         /**
          * Constructs a FeaturePagingHelperImpl from data of a FeatureStore.
+         *
          * @param featureStore
          *            to extract data from
          * @throws DataException
          *             if there is an error initializing the helper
          * @param featureStore to extract data from
          * @throws DataException if there is an error initializing the helper
          */
         public FeaturePagingHelperImpl(FeatureStore featureStore)
             throws BaseException {
                 throws BaseException {
             this(featureStore, DEFAULT_PAGE_SIZE);
+        }
         /**
          * Constructs a FeaturePagingHelperImpl from data of a FeatureStore.
+         *
          * @param featureStore
          *            to extract data from
          * @param pageSize
          *            the number of elements per page data
          * @throws DataException
          *             if there is an error initializing the helper
          * @param featureStore to extract data from
          * @param pageSize the number of elements per page data
          * @throws DataException if there is an error initializing the helper
          */
         public FeaturePagingHelperImpl(FeatureStore featureStore, int pageSize)
             throws BaseException {
                 throws BaseException {
             this(featureStore, null, pageSize);
+        }
         /**
          * Constructs a FeaturePagingHelperImpl from data of a FeatureStore.
+         *
          * @param featureStore
          *            to extract data from
          * @throws DataException
          *             if there is an error initializing the helper
          * @param featureStore to extract data from
          * @param featureQuery
          * @throws DataException if there is an error initializing the helper
          */
         public FeaturePagingHelperImpl(FeatureStore featureStore,
             FeatureQuery featureQuery) throws BaseException {
                 FeatureQuery featureQuery) throws BaseException {
             this(featureStore, featureQuery, DEFAULT_PAGE_SIZE);
+        }
         /**
          * Constructs a FeaturePagingHelperImpl from data of a FeatureStore.
+         *
          * @param featureSet
          *            to extract data from
          * @param pageSize
          *            the number of elements per page data
          * @throws DataException
          *             if there is an error initializing the helper
          * @param featureStore
          * @param featureQuery
          * @param pageSize the number of elements per page data
          * @throws DataException if there is an error initializing the helper
          */
         public FeaturePagingHelperImpl(FeatureStore featureStore,
             FeatureQuery featureQuery, int pageSize) throws BaseException {
                 FeatureQuery featureQuery, int pageSize) throws BaseException {
             super();
             this.cachedPages = new PageCache(3);
             FeatureQuery query = featureQuery;
             FeatureQuery theQuery = featureQuery;
             if (featureQuery == null) {
                 query = featureStore.createFeatureQuery();
                 query.setFeatureType(featureStore.getDefaultFeatureType());
                 theQuery = featureStore.createFeatureQuery();
                 theQuery.setFeatureType(featureStore.getDefaultFeatureType());
+            }
             this.featureStore = featureStore;
             this.query = query;
             this.query = theQuery;
             this.query.setPageSize(pageSize);
             setDefaultCalculator(new Sizeable() {
                 public long getSize() {
                 	FeatureSet featureSet = getFeatureSet(false);
                     try {
     					return featureSet.getSize();
                     } catch (BaseException e) {
                         LOG.error("Error getting the size of the FeatureSet: "
                             + featureSet, e);
                         return 0l;
+                    }
             setDefaultCalculator(() -> {
                 FeatureSet featureSet = getFeatureSet(false);
                 try {
                     return featureSet.getSize();
                 } catch (BaseException e) {
                     LOG.warn("Error getting the size of the FeatureSet: " + featureSet, e);
                     return 0l;
+                }
             }, pageSize);
             if (LOG.isDebugEnabled()) {
                 LOG.debug("FeaturePagingHelperImpl created with {} pages, "
                     + "and a page size of {}", new Long(getCalculator()
                     .getNumPages()), new Integer(pageSize));
                 LOG.debug("FeaturePagingHelperImpl created with {} pages, and a page size of {}",
                         getCalculator().getNumPages(), pageSize
                 );
+            }
             this.initialization_completed = true;
+        }
-...
         /**
          * @return the selectionUp status
          */
         @Override
         public boolean isSelectionUp() {
             return selectionUp;
+        }
         @Override
         public FeatureSelection getSelection() {
             if (selection == null) {
                 try {
-...
+            }
             return selection;
+        }
         @Override
         public void setSelection(FeatureSelection selection) {
             this.selection = selection;
+        }
         @Override
         public void setSelectionUp(boolean selectionUp) {
             this.selectionUp = selectionUp;
-...
                 this.cachedPages.clear();
                 FeatureSelection currentSelection = getSelection();
                 if (selectionUp && !currentSelection.isEmpty()) {
                     initialSelection =(FeatureSelection) currentSelection.clone();
     //                initialSelection =(FeatureSelection) currentSelection.clone();
                     setCalculator(new OneSubsetOneSetPagingCalculator(
                         new FeatureSetSizeableDelegate(initialSelection),
                         new FeatureSetSizeableDelegate(getFeatureSet(false)),
                         getMaxPageSize()));
                             new FeatureSetSizeableDelegate(currentSelection),
                             new FeatureSetSizeableDelegate(getFeatureSet(false)),
                             getMaxPageSize()));
                 } else {
                     if (initialSelection != null) {
                         initialSelection.dispose();
                         initialSelection = null;
+                    }
                     setDefaultCalculator(new FeatureSetSizeableDelegate(
                         getFeatureSet(false)), getMaxPageSize());
                             getFeatureSet(false)), getMaxPageSize()
                     );
+                }
             } catch (BaseException e) {
                 LOG.error("Error setting the selection up setting to: "
                     + selectionUp, e);
             } catch (CloneNotSupportedException e) {
                 LOG.error("Error cloning the selection "
                     + "while setting the selection up", e);
                 LOG.warn("Error setting the selection up setting to: " + selectionUp, e);
+            }
+        }
         @Override
         public synchronized Feature getFeatureAt(long index) throws BaseException {
             // Check if we have currently loaded the viewed page data,
             // or we need to load a new one
         	int maxPageSize = getMaxPageSize();
         	long currentPage = getCurrentPage();
         	long currentPage2 = currentPage;
             int maxPageSize = getMaxPageSize();
             long currentPage = getCurrentPage();
             long currentPage2 = currentPage;
             long pageForIndex = (long) Math.floor(index / maxPageSize);
             if (pageForIndex != currentPage) {
-...
             if (positionForIndex >= getCurrentPageFeatures().length) {
                 throw new FeatureIndexException(
                     new IndexOutOfBoundsException("positionForIndex too big: "
                         + positionForIndex));
                         new IndexOutOfBoundsException("positionForIndex too big: "
                                 + positionForIndex));
             } else {
                 Feature feature = getCurrentPageFeatures()[(int) positionForIndex];
                 return feature;
-...
+        }
         @Override
         public Feature[] getCurrentPageFeatures() {
             if( this.features==null ) {
             if (this.features == null) {
                 try {
                     this.loadCurrentPageData();
                 } catch (BaseException ex) {
                     // Do nothing
+                }
                 if( this.features == null ) {
                 if (this.features == null) {
                     String msg = "Can't retrieve the features from current page.";
                     LOG.warn(msg);
                     throw new RuntimeException(msg);
-...
+            }
             return features;
+        }
         @Override
         public FeatureSet getFeatureSet() {
             return this.getFeatureSet(false);
+        }
         /**
          * Gets the feature set.
          * The boolean tells whether we must create the featureset
          * again (for example perhaps we need it after a feature
          * has been added/removed)
          * Gets the feature set. The boolean tells whether we must create the
          * featureset again (for example perhaps we need it after a feature has been
          * added/removed)
          */
         private FeatureSet getFeatureSet(boolean reset) {
-...
         @Override
         public DynObjectSet getDynObjectSet() {
         	return getFeatureSet(false).getDynObjectSet();
             return getFeatureSet(false).getDynObjectSet();
+        }
         @Override
         public void reloadCurrentPage() throws BaseException {
             boolean sel_up = this.isSelectionUp();
             setSelectionUp(false);
             if (getCalculator().getCurrentPage() > -1) {
                 this.cachedPages.clear();
                 loadCurrentPageData();
             try {
                 setSelectionUp(false);
                 if (getCalculator().getCurrentPage() > -1) {
                     this.cachedPages.clear();
                     loadCurrentPageData();
+                }
             } finally {
                 if (sel_up) {
                     setSelectionUp(true);
+                }
+            }
             if (sel_up) {
                 setSelectionUp(true);
+            }
+        }
         @Override
-...
              */
             this.getFeatureSet(true);
             setDefaultCalculator(new Sizeable() {
                 public long getSize() {
                 	FeatureSet featureSet = getFeatureSet(false);
                     try {
     					return featureSet.getSize();
                     } catch (BaseException e) {
                         LOG.error("Error getting the size of the FeatureSet: "
                             + featureSet, e);
                         return 0l;
+                    }
             setDefaultCalculator(() -> {
                 FeatureSet featureSet = getFeatureSet(false);
                 try {
                     return featureSet.getSize();
                 } catch (BaseException e) {
                     LOG.warn("Error getting the size of the FeatureSet: "+ featureSet, e);
                     return 0l;
+                }
             }, getCalculator().getMaxPageSize());
             reloadCurrentPage();
+        }
         @Override
         public FeatureStore getFeatureStore() {
             return featureStore;
+        }
         @Override
         public FeatureQuery getFeatureQuery() {
             return query;
+        }
         /**
          * Loads all the Features of the current page.
+         *
          * @throws org.gvsig.tools.exception.BaseException
          */
         @Override
         protected synchronized void loadCurrentPageData() throws BaseException {
             if( !initialization_completed ) {
             if (!initialization_completed) {
                 return;
+            }
             final int currentPageSize = getCalculator().getCurrentPageSize();
             final long currentPage = getCalculator().getCurrentPage();
             Page page = this.cachedPages.get(currentPage);
             if( page==null ) {
             if (page == null) {
                 page = new Page(currentPage, currentPageSize);
                 long t1 = 0;
-...
         private void loadCurrentPageDataWithSelectionUp(final Page page)
                 throws BaseException {
             FeatureSelection selection = initialSelection;
             if (selection == null) {
             FeatureSelection theSelection = getSelection();
             if (theSelection == null) {
                 loadCurrentPageDataNoSelection(page);
             } else {
                 FeatureSet set = getFeatureSet(false);
                 try {
                     OneSubsetOneSetPagingCalculator twoSetsCalculator = null;
                     if (getCalculator() instanceof OneSubsetOneSetPagingCalculator) {
                         twoSetsCalculator
                                 = (OneSubsetOneSetPagingCalculator) getCalculator();
                         twoSetsCalculator = (OneSubsetOneSetPagingCalculator) getCalculator();
                     } else {
                         twoSetsCalculator
                                 = new OneSubsetOneSetPagingCalculator(
                                         new FeatureSetSizeableDelegate(selection),
                         twoSetsCalculator = new OneSubsetOneSetPagingCalculator(
                                         new FeatureSetSizeableDelegate(theSelection),
                                         new FeatureSetSizeableDelegate(set),
                                         getMaxPageSize(), getCalculator().getCurrentPage());
                                         getMaxPageSize(), getCalculator().getCurrentPage()
                         );
                         setCalculator(twoSetsCalculator);
+                    }
     	        // First load values from the selection, if the current page has
                     // First load values from the selection, if the current page has
                     // elements from it
                     if (twoSetsCalculator.hasCurrentPageAnyValuesInFirstSet()) {
                         loadDataFromFeatureSet(page, 0, selection,
                         loadDataFromFeatureSet(page, 0, theSelection,
                                 twoSetsCalculator.getFirstSetInitialIndex(),
                                 twoSetsCalculator.getFirstSetHowMany(), null);
                                 twoSetsCalculator.getFirstSetHowMany(), null
                         );
+                    }
     	        // Next, load values from the FeatureSet if the current page has values
                     // Next, load values from the FeatureSet if the current page has values
                     // from it
                     if (twoSetsCalculator.hasCurrentPageAnyValuesInSecondSet()) {
                         loadDataFromFeatureSet(
-...
                                 // which is an int
                                 (int) twoSetsCalculator.getFirstSetHowMany(), set,
                                 twoSetsCalculator.getSecondSetInitialIndex(),
                                 twoSetsCalculator.getSecondSetHowMany(), selection);
                                 twoSetsCalculator.getSecondSetHowMany(), theSelection
                         );
+                    }
                 } finally {
                     /*
                      * This is the feature set
                      * we dont want to lose it
                      */
                     // This is the feature set we dont want to lose it
                     // set.dispose();
+                }
+            }
+        }
         private void loadCurrentPageDataNoSelection(final Page page)
             throws BaseException {
                 throws BaseException {
             long firstPosition = getCalculator().getInitialIndex();
             if (LOG.isDebugEnabled()) {
                 LOG.debug("Loading {} Features starting at position {}",
                     getCalculator().getCurrentPageSize(), firstPosition
                 LOG.debug("Loading {} Features starting at position {}",
                         getCalculator().getCurrentPageSize(), firstPosition
                 );
+            }
             FeatureSet featureSet = getFeatureSet(false);
             try {
             	loadDataFromFeatureSet(page, 0, featureSet, firstPosition,
             			getCalculator().getCurrentPageSize(), null);
             } catch(DataException ex) {
                 loadDataFromFeatureSet(page, 0, featureSet, firstPosition,
                         getCalculator().getCurrentPageSize(), null);
             } catch (DataException ex) {
                 throw ex;
                 // } finally {
             	// featureSet.dispose();
             } finally {
                 // This is the feature set we dont want to lose it
                 // featureSet.dispose();
+            }
+        }
         private void loadDataFromFeatureSet(final Page page,
             final int valuesPosition, FeatureSet set, long initialIndex,
             final long howMany, final FeatureSelection selectedFeaturesToSkip)
             throws DataException {
                 final int valuesPosition, FeatureSet set, long initialIndex,
                 final long howMany, final FeatureSelection selectedFeaturesToSkip)
                 throws DataException {
             try {
                 final MutableBoolean errorReported = new MutableBoolean(false);
-...
                     @Override
                     public void visit(Object obj) throws VisitCanceledException,
                         BaseException {
                             BaseException {
                         if (i >= valuesPosition + howMany) {
                             throw new VisitCanceledException();
+                        }
-...
                         // Add the current Feature only if we don't skip selected
                         // features or the feature is not selected
                         if (selectedFeaturesToSkip == null
                             || !selectedFeaturesToSkip.isSelected(current)) {
                                 || !selectedFeaturesToSkip.isSelected(current)) {
                             try {
                                 page.setFeature(i,current.getCopy());
                                 page.setFeature(i, current.getCopy());
                                 i++;
                             } catch(Exception ex) {
                             } catch (Exception ex) {
                                 // Aqui no deberia petar, pero...
                                 // me he encontrado un caso que tenia una referencia a
                                 // una feature seleccionada que ya no existia. No se como
-...
                                 // proyecto pero la feature ya no existia, y eso hacia que
                                 // petase al intentar leer de disco la feature a partir
                                 // de una referencia no valida.
                                 if( !errorReported.booleanValue() ) {
                                   // Solo sacamos un error por pagina de datos.
                                   LOG.warn("Problemas recuperando feature.",ex);
                                   errorReported.setTrue();
                                 if (!errorReported.booleanValue()) {
                                     // Solo sacamos un error por pagina de datos.
                                     LOG.warn("Problemas recuperando feature.", ex);
                                     errorReported.setTrue();
+                                }
+                            }
+                        }
+                    }
                 }, initialIndex, howMany);
             } catch(VisitCanceledException ex) {
             } catch (VisitCanceledException ex) {
                 // Do nothing
             } catch (BaseException e) {
                 if (e instanceof DataException) {
                     throw ((DataException) e);
                 } else {
                     LOG.warn("Error loading the data starting at position {}",
                         new Long(initialIndex), e);
                     LOG.warn("Error loading the data starting at position {}", initialIndex, e);
+                }
+            }
+        }
         @Override
         public void delete(Feature feature) throws BaseException {
             featureStore.delete(feature);
             /*
-...
             reloadCurrentPage();
+        }
         @Override
         public void insert(EditableFeature feature) throws BaseException {
         	featureStore.insert(feature);
             featureStore.insert(feature);
             /*
              * Force re-creation of feature set
              */
-...
             reloadCurrentPage();
+        }
         @Override
         public boolean isEmpty() {
             try {
                 return getFeatureSet(false).isEmpty();
-...
                 try {
                     return getFeatureSet(false).isEmpty();
                 } catch (DataException e) {
                     LOG.warn("Error asking about the emptiness of the list after reloading data.",e);
                     LOG.warn("Error asking about the emptiness of the list after reloading data.", e);
                     throw new RuntimeException(e);
+                }
             } catch (DataException ex) {
                 throw  new RuntimeException(ex);
                 throw new RuntimeException(ex);
+            }
+        }
         @Override
         public void update(EditableFeature feature) throws BaseException {
         	featureStore.update(feature);
             featureStore.update(feature);
             /*
              * Force re-creation of feature set
              */
-...
             reloadCurrentPage();
+        }
         @Override
         public FeatureType getFeatureType() {
             FeatureType ft = null;
-...
             try {
                 ft = featureStore.getDefaultFeatureType();
             } catch (DataException e) {
                 LOG.error("Error while getting feature type: " +
                     e.getMessage(), e);
                 LOG.warn("Error while getting feature type: "+ e.getMessage(), e);
+            }
             return ft;
             /*
+             *
             FeatureSet featureSet = getFeatureSet();
             try {
                 return featureSet.getDefaultFeatureType();
             } finally {
                 featureSet.dispose();
+            }
             */
+        }
         @Override
         protected void doDispose() throws BaseException {
             initialSelection.dispose();
             if (featSet != null) {
                 try {
                     featSet.dispose();
-...
+            }
+        }
         @Override
         public DynObject[] getCurrentPageDynObjects() {
             Feature[] features = getCurrentPageFeatures();
             DynObject[] dynobjects = new DynObject[features.length];
             Feature[] theFeatures = getCurrentPageFeatures();
             DynObject[] dynobjects = new DynObject[theFeatures.length];
             for (int i = 0; i < dynobjects.length; i++) {
                 dynobjects[i] = new DynObjectFeatureFacade(features[i]);
                 dynobjects[i] = new DynObjectFeatureFacade(theFeatures[i]);
+            }
             return dynobjects;
+        }
-...
+        }
         private class FeaturePagingHelperList extends PagingHelperList {
             @Override
             public Object get(int i) {
                 return this.get64(i);
-...
                 try {
                     return getFeatureAt(i);
                 } catch (ConcurrentDataModificationException ex) {
                     LOG.warn("ConcurrentDataModification error getting feature "+i+" of the list. Retrying reloading data.");
                     LOG.warn("ConcurrentDataModification error getting feature " + i + " of the list. Retrying reloading data.");
                     try {
                         reload();
                     } catch (BaseException e) {
-...
                     try {
                         return getFeatureAt(i);
                     } catch (Exception e) {
                         LOG.warn("Error getting feature "+i+" of the list after reloading data.",e);
                         LOG.warn("Error getting feature " + i + " of the list after reloading data.", e);
                         throw new RuntimeException(e);
+                    }
                 } catch (BaseException ex) {
                     throw  new RuntimeException(ex);
                     throw new RuntimeException(ex);
+                }
+            }
             @Override
             public Object set(int i, Object e) {
     //            Feature newFeature = (Feature) e;
     //            EditableFeature oldFeature = ((Feature) this.get(i)).getEditable();
     //            oldFeature.copyFrom(newFeature);
     //            update(oldFeature);
                 return super.set(i, e);
+            }
             @Override
             public Object remove(int i) {
     //            Feature feature = (Feature) this.get(i);
     //            delete(feature);
                 return super.remove(i);
+            }
             @Override
             public boolean add(Object e) {
     //            EditableFeature feature = (EditableFeature) e;
     //            insert(feature);
                 return super.add(e);
+            }
+        }
         private class DynObjectPagingHelperList extends PagingHelperList {
             @Override
             public Object get(int i) {
                 return this.get64(i);
-...
                 try {
                     return getDynObjectAt(position);
                 } catch (ConcurrentDataModificationException ex) {
                     LOG.warn("ConcurrentDataModification error getting element "+position+" of the list. Retrying reloading data.");
                     LOG.warn("ConcurrentDataModification error getting element " + position + " of the list. Retrying reloading data.");
                     try {
                         reload();
                     } catch (BaseException e) {
-...
                     try {
                         return getDynObjectAt(position);
                     } catch (Exception e) {
                         LOG.warn("Error getting element "+position+" of the list after reloading data.",e);
                         LOG.warn("Error getting element " + position + " of the list after reloading data.", e);
                         throw new RuntimeException(e);
+                    }
                 } catch (BaseException ex) {
                     throw  new RuntimeException(ex);
                     throw new RuntimeException(ex);
+                }
+            }
-...
             public String toString() {
                 return String.format("..(%d %ss)...", this.size(), featureStore.getName());
+            }
             @Override
             public long size64() {
                 try {
-...
                     try {
                         return getFeatureSet(false).getSize();
                     } catch (DataException e) {
                         LOG.warn("Error asking the size of the list after reloading data.",e);
                         LOG.warn("Error asking the size of the list after reloading data.", e);
                         throw new RuntimeException(e);
+                    }
                 } catch (DataException ex) {
                     throw  new RuntimeException(ex);
                     throw new RuntimeException(ex);
+                }
+            }
             @Override
             public int size() {
                 long sz = this.size64();
                 if( sz>Integer.MAX_VALUE ) {
                 if (sz > Integer.MAX_VALUE) {
                     sz = Integer.MAX_VALUE;
+                }
                 return (int) sz;
-...
                     try {
                         return getFeatureSet(false).isEmpty();
                     } catch (DataException e) {
                         LOG.warn("Error asking about the emptiness of the list after reloading data.",e);
                         LOG.warn("Error asking about the emptiness of the list after reloading data.", e);
                         throw new RuntimeException(e);
+                    }
                 } catch (DataException ex) {
                     throw  new RuntimeException(ex);
                     throw new RuntimeException(ex);
+                }
+            }
-...
                     try {
                         return getFeatureSet(false).fastIterator();
                     } catch (DataException e) {
                         LOG.warn("Error getting iterator of the list after reloading data.",e);
                         LOG.warn("Error getting iterator of the list after reloading data.", e);
                         throw new RuntimeException(e);
+                    }
                 } catch (DataException ex) {
                     throw  new RuntimeException(ex);
                     throw new RuntimeException(ex);
+                }
+            }

Also available in: Unified diff