Merged in support for derived properties.

7 files changed, 514 insertions, 15 deletions

diff --git a/src/main/java/com/amazon/carbonado/repo/indexed/DependentStorableFetcher.java b/src/main/java/com/amazon/carbonado/repo/indexed/DependentStorableFetcher.java
new file mode 100644
index 0000000..4c24c04
--- /dev/null
+++ b/src/main/java/com/amazon/carbonado/repo/indexed/DependentStorableFetcher.java
@@ -0,0 +1,174 @@
+/*

+ * Copyright 2007 Amazon Technologies, Inc. or its affiliates.

+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks

+ * of Amazon Technologies, Inc. or its affiliates.  All rights reserved.

+ *

+ * Licensed under the Apache License, Version 2.0 (the "License");

+ * you may not use this file except in compliance with the License.

+ * You may obtain a copy of the License at

+ *

+ *     http://www.apache.org/licenses/LICENSE-2.0

+ *

+ * Unless required by applicable law or agreed to in writing, software

+ * distributed under the License is distributed on an "AS IS" BASIS,

+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+ * See the License for the specific language governing permissions and

+ * limitations under the License.

+ */

+

+package com.amazon.carbonado.repo.indexed;

+

+import java.util.Arrays;

+import java.util.ArrayList;

+import java.util.List;

+

+import org.cojen.util.BeanPropertyAccessor;

+

+import com.amazon.carbonado.Cursor;

+import com.amazon.carbonado.FetchException;

+import com.amazon.carbonado.Query;

+import com.amazon.carbonado.RepositoryException;

+import com.amazon.carbonado.Storable;

+import com.amazon.carbonado.Storage;

+import com.amazon.carbonado.SupportException;

+import com.amazon.carbonado.Transaction;

+

+import com.amazon.carbonado.filter.Filter;

+import com.amazon.carbonado.filter.RelOp;

+

+import com.amazon.carbonado.info.ChainedProperty;

+import com.amazon.carbonado.info.StorableProperty;

+

+/**

+ * Fetches Storables that have indexed derived-to properties which depend on S.

+ *

+ * @author Brian S O'Neill

+ */

+class DependentStorableFetcher<S extends Storable, D extends Storable> {

+    private final IndexedRepository mRepository;

+    private final IndexEntryAccessor<D>[] mIndexEntryAccessors;

+    private final Query<D> mQuery;

+    private final String[] mJoinProperties;

+    private final BeanPropertyAccessor mPropertyAccessor;

+

+    /**

+     * @param derivedTo special chained property from StorableProperty.getDerivedToProperties

+     */

+    DependentStorableFetcher(IndexedRepository repository,

+                             Class<S> sType, ChainedProperty<D> derivedTo)

+        throws RepositoryException

+    {

+        if (derivedTo.getChainCount() == 0) {

+            throw new IllegalArgumentException();

+        }

+        if (derivedTo.getLastProperty().getType() != sType) {

+            throw new IllegalArgumentException();

+        }

+        if (!derivedTo.getLastProperty().isJoin()) {

+            throw new IllegalArgumentException();

+        }

+

+        Class<D> dType = derivedTo.getPrimeProperty().getEnclosingType();

+

+        // Find the indexes that contain the prime derivedTo property.

+        List<IndexEntryAccessor<D>> accessorList = new ArrayList<IndexEntryAccessor<D>>();

+        for (IndexEntryAccessor<D> acc : repository.getIndexEntryAccessors(dType)) {

+            for (String indexPropName : acc.getPropertyNames()) {

+                if (indexPropName.equals(derivedTo.getPrimeProperty().getName())) {

+                    accessorList.add(acc);

+                    break;

+                }

+            }

+        }

+

+        if (accessorList.size() == 0) {

+            throw new SupportException

+                ("Unable to find index accessors for derived-to property: " + derivedTo +

+                 ", enclosing type: " + dType);

+        }

+

+        // Build a query on D joined to S.

+

+        StorableProperty<S> join = (StorableProperty<S>) derivedTo.getLastProperty();

+

+        ChainedProperty<?> base;

+        if (derivedTo.getChainCount() <= 1) {

+            base = null;

+        } else {

+            base = derivedTo.tail().trim();

+        }

+

+        int joinElementCount = join.getJoinElementCount();

+        String[] joinProperties = new String[joinElementCount];

+

+        Filter<D> dFilter = Filter.getOpenFilter(dType);

+        for (int i=0; i<joinElementCount; i++) {

+            StorableProperty<S> element = join.getInternalJoinElement(i);

+            joinProperties[i] = element.getName();

+            if (base == null) {

+                dFilter = dFilter.and(element.getName(), RelOp.EQ);

+            } else {

+                dFilter = dFilter.and(base.append(element).toString(), RelOp.EQ);

+            }

+        }

+

+        mRepository = repository;

+        mIndexEntryAccessors = accessorList.toArray(new IndexEntryAccessor[accessorList.size()]);

+        mQuery = repository.storageFor(dType).query(dFilter);

+        mJoinProperties = joinProperties;

+        mPropertyAccessor = BeanPropertyAccessor.forClass(sType);

+    }

+

+    public Transaction enterTransaction() {

+        return mRepository.enterTransaction();

+    }

+

+    public Cursor<D> fetchDependenentStorables(S storable) throws FetchException {

+        Query<D> query = mQuery;

+        for (String property : mJoinProperties) {

+            query = query.with(mPropertyAccessor.getPropertyValue(storable, property));

+        }

+        return query.fetch();

+    }

+

+    /**

+     * @return amount added to list

+     */

+    public int createIndexEntries(D master, List<Storable> indexEntries) {

+        IndexEntryAccessor[] accessors = mIndexEntryAccessors;

+        int length = accessors.length;

+        for (int i=0; i<length; i++) {

+            IndexEntryAccessor accessor = accessors[i];

+            Storable indexEntry = accessor.getIndexEntryStorage().prepare();

+            accessor.copyFromMaster(indexEntry, master);

+            indexEntries.add(indexEntry);

+        }

+        return length;

+    }

+

+    @Override

+    public int hashCode() {

+        return mQuery.getFilter().hashCode();

+    }

+

+    @Override

+    public boolean equals(Object obj) {

+        if (this == obj) {

+            return true;

+        }

+        if (obj instanceof DependentStorableFetcher) {

+            DependentStorableFetcher other = (DependentStorableFetcher) obj;

+            return mQuery.getFilter().equals(other.mQuery.getFilter())

+                && Arrays.equals(mJoinProperties, other.mJoinProperties)

+                && Arrays.equals(mIndexEntryAccessors, other.mIndexEntryAccessors);

+        }

+        return false;

+    }

+

+    @Override

+    public String toString() {

+        return "DependentStorableFetcher: {indexes=" + Arrays.toString(mIndexEntryAccessors) +

+            ", query=" + mQuery +

+            ", join properties=" + Arrays.toString(mJoinProperties) + '}';

+    }

+}

diff --git a/src/main/java/com/amazon/carbonado/repo/indexed/DerivedIndexesTrigger.java b/src/main/java/com/amazon/carbonado/repo/indexed/DerivedIndexesTrigger.java
new file mode 100644
index 0000000..0a99fdd
--- /dev/null
+++ b/src/main/java/com/amazon/carbonado/repo/indexed/DerivedIndexesTrigger.java
@@ -0,0 +1,164 @@
+/*

+ * Copyright 2007 Amazon Technologies, Inc. or its affiliates.

+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks

+ * of Amazon Technologies, Inc. or its affiliates.  All rights reserved.

+ *

+ * Licensed under the Apache License, Version 2.0 (the "License");

+ * you may not use this file except in compliance with the License.

+ * You may obtain a copy of the License at

+ *

+ *     http://www.apache.org/licenses/LICENSE-2.0

+ *

+ * Unless required by applicable law or agreed to in writing, software

+ * distributed under the License is distributed on an "AS IS" BASIS,

+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+ * See the License for the specific language governing permissions and

+ * limitations under the License.

+ */

+

+package com.amazon.carbonado.repo.indexed;

+

+import java.util.ArrayList;

+import java.util.List;

+

+import com.amazon.carbonado.Cursor;

+import com.amazon.carbonado.FetchException;

+import com.amazon.carbonado.PersistException;

+import com.amazon.carbonado.RepositoryException;

+import com.amazon.carbonado.Storable;

+import com.amazon.carbonado.Transaction;

+import com.amazon.carbonado.Trigger;

+

+import com.amazon.carbonado.info.ChainedProperty;

+

+/**

+ * Handles index updates for derived-to properties.

+ *

+ * @author Brian S O'Neill

+ */

+class DerivedIndexesTrigger<S extends Storable, D extends Storable> extends Trigger<S> {

+    private final DependentStorableFetcher<S, D> mFetcher;

+

+    /**

+     * @param derivedTo special chained property from StorableProperty.getDerivedToProperties

+     */

+    DerivedIndexesTrigger(IndexedRepository repository,

+                          Class<S> sType, ChainedProperty<D> derivedTo)

+        throws RepositoryException

+    {

+        this(new DependentStorableFetcher(repository, sType, derivedTo));

+    }

+

+    DerivedIndexesTrigger(DependentStorableFetcher<S, D> fetcher) {

+        mFetcher = fetcher;

+    }

+

+    @Override

+    public Object beforeInsert(S storable) throws PersistException {

+        return createDependentIndexEntries(storable);

+    }

+

+    @Override

+    public void afterInsert(S storable, Object state) throws PersistException {

+        updateValues(storable, state);

+    }

+

+    @Override

+    public Object beforeUpdate(S storable) throws PersistException {

+        return createDependentIndexEntries(storable);

+    }

+

+    @Override

+    public void afterUpdate(S storable, Object state) throws PersistException {

+        updateValues(storable, state);

+    }

+

+    @Override

+    public Object beforeDelete(S storable) throws PersistException {

+        try {

+            if (storable.copy().tryLoad()) {

+                return createDependentIndexEntries(storable);

+            }

+        } catch (FetchException e) {

+            throw e.toPersistException();

+        }

+        return null;

+    }

+

+    @Override

+    public void afterDelete(S storable, Object state) throws PersistException {

+        updateValues(storable, state);

+    }

+

+    @Override

+    public boolean equals(Object obj) {

+        if (this == obj) {

+            return true;

+        }

+        if (obj instanceof DerivedIndexesTrigger) {

+            DerivedIndexesTrigger other = (DerivedIndexesTrigger) obj;

+            return mFetcher.equals(other.mFetcher);

+        }

+        return false;

+    }

+

+    private List<Storable> createDependentIndexEntries(S storable) throws PersistException {

+        List<Storable> dependentIndexEntries = new ArrayList<Storable>();

+        createDependentIndexEntries(storable, dependentIndexEntries);

+        return dependentIndexEntries;

+    }

+

+    private void createDependentIndexEntries(S storable, List<Storable> dependentIndexEntries)

+        throws PersistException

+    {

+        try {

+            Transaction txn = mFetcher.enterTransaction();

+            try {

+                // Make sure write lock is acquired when reading dependencies

+                // since they might be updated later. Locks are held after this

+                // transaction exits since it is nested in the trigger's transaction.

+                txn.setForUpdate(true);

+

+                Cursor<D> dependencies = mFetcher.fetchDependenentStorables(storable);

+                try {

+                    while (dependencies.hasNext()) {

+                        mFetcher.createIndexEntries(dependencies.next(), dependentIndexEntries);

+                    }

+                } finally {

+                    dependencies.close();

+                }

+            } finally {

+                txn.exit();

+            }

+        } catch (FetchException e) {

+            throw e.toPersistException();

+        }

+    }

+

+    private void updateValues(S storable, Object state) throws PersistException {

+        if (state == null) {

+            return;

+        }

+

+        List<Storable> oldIndexEntries = (List<Storable>) state;

+        int size = oldIndexEntries.size();

+

+        List<Storable> newIndexEntries = new ArrayList<Storable>(size);

+        createDependentIndexEntries(storable, newIndexEntries);

+

+        if (size != newIndexEntries.size()) {

+            // This is not expected to happen.

+            throw new PersistException("Amount of affected dependent indexes changed: " +

+                                       size + " != " + newIndexEntries.size());

+        }

+

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

+            Storable oldIndexEntry = oldIndexEntries.get(i);

+            Storable newIndexEntry = newIndexEntries.get(i);

+            if (!oldIndexEntry.equalProperties(newIndexEntry)) {

+                oldIndexEntry.delete();

+                newIndexEntry.tryInsert();

+            }

+        }

+    }

+}

diff --git a/src/main/java/com/amazon/carbonado/repo/indexed/IndexAnalysis.java b/src/main/java/com/amazon/carbonado/repo/indexed/IndexAnalysis.java
new file mode 100644
index 0000000..d0e3405
--- /dev/null
+++ b/src/main/java/com/amazon/carbonado/repo/indexed/IndexAnalysis.java
@@ -0,0 +1,132 @@
+/*

+ * Copyright 2007 Amazon Technologies, Inc. or its affiliates.

+ * Amazon, Amazon.com and Carbonado are trademarks or registered trademarks

+ * of Amazon Technologies, Inc. or its affiliates.  All rights reserved.

+ *

+ * Licensed under the Apache License, Version 2.0 (the "License");

+ * you may not use this file except in compliance with the License.

+ * You may obtain a copy of the License at

+ *

+ *     http://www.apache.org/licenses/LICENSE-2.0

+ *

+ * Unless required by applicable law or agreed to in writing, software

+ * distributed under the License is distributed on an "AS IS" BASIS,

+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

+ * See the License for the specific language governing permissions and

+ * limitations under the License.

+ */

+

+package com.amazon.carbonado.repo.indexed;

+

+import java.util.Arrays;

+import java.util.HashSet;

+import java.util.Set;

+

+import com.amazon.carbonado.Storable;

+

+import com.amazon.carbonado.filter.Filter;

+import com.amazon.carbonado.filter.RelOp;

+

+import com.amazon.carbonado.info.ChainedProperty;

+import com.amazon.carbonado.info.Direction;

+import com.amazon.carbonado.info.StorableIndex;

+import com.amazon.carbonado.info.StorableInfo;

+import com.amazon.carbonado.info.StorableIntrospector;

+import com.amazon.carbonado.info.StorableProperty;

+

+import com.amazon.carbonado.qe.FilteringScore;

+

+import com.amazon.carbonado.spi.StorableIndexSet;

+

+/**

+ * Collection of static methods which perform index analysis.

+ *

+ * @author Brian S O'Neill

+ */

+class IndexAnalysis {

+    static <S extends Storable> StorableIndexSet<S> gatherDesiredIndexes(StorableInfo<S> info) {

+        StorableIndexSet<S> indexSet = new StorableIndexSet<S>();

+        indexSet.addIndexes(info);

+        indexSet.addAlternateKeys(info);

+

+        // If any join properties are used by indexed derived properties, make

+        // sure join internal properties are indexed.

+

+        for (StorableProperty<S> property : info.getAllProperties().values()) {

+            if (!isJoinAndUsedByIndexedDerivedProperty(property)) {

+                continue;

+            }

+

+            // Internal properties of join need to be indexed. Check if a

+            // suitable index exists before defining a new one.

+

+            Filter<S> filter = Filter.getOpenFilter(info.getStorableType());

+            for (int i=property.getJoinElementCount(); --i>=0; ) {

+                filter = filter.and(property.getInternalJoinElement(i).getName(), RelOp.EQ);

+            }

+

+            for (int i=info.getIndexCount(); --i>=0; ) {

+                FilteringScore<S> score = FilteringScore.evaluate(info.getIndex(i), filter);

+                if (score.getIdentityCount() == property.getJoinElementCount()) {

+                    // Suitable index already exists.

+                    continue;

+                }

+            }

+

+            Direction[] directions = new Direction[property.getJoinElementCount()];

+            Arrays.fill(directions, Direction.UNSPECIFIED);

+

+            StorableIndex<S> index =

+                new StorableIndex<S>(property.getInternalJoinElements(), directions);

+

+            indexSet.add(index);

+        }

+

+        return indexSet;

+    }

+

+    static boolean isUsedByIndex(StorableProperty<?> property) {

+        StorableInfo<?> info = StorableIntrospector.examine(property.getEnclosingType());

+        for (int i=info.getIndexCount(); --i>=0; ) {

+            StorableIndex<?> index = info.getIndex(i);

+            int propertyCount = index.getPropertyCount();

+            for (int j=0; j<propertyCount; j++) {

+                if (index.getProperty(j).equals(property)) {

+                    return true;

+                }

+            }

+        }

+        return false;

+    }

+

+    static boolean isJoinAndUsedByIndexedDerivedProperty(StorableProperty<?> property) {

+        if (property.isJoin()) {

+            for (ChainedProperty<?> derivedTo : property.getDerivedToProperties()) {

+                if (isUsedByIndex(derivedTo.getPrimeProperty())) {

+                    return true;

+                }

+            }

+        }

+        return false;

+    }

+

+    /**

+     * Returns derived-to properties in external storables that are used by indexes.

+     *

+     * @return null if none

+     */

+    static Set<ChainedProperty<?>> gatherDerivedToDependencies(StorableInfo<?> info) {

+        Set<ChainedProperty<?>> set = null;

+        for (StorableProperty<?> property : info.getAllProperties().values()) {

+            for (ChainedProperty<?> derivedTo : property.getDerivedToProperties()) {

+                if (derivedTo.getChainCount() > 0 && isUsedByIndex(derivedTo.getPrimeProperty())) {

+                    if (set == null) {

+                        set = new HashSet<ChainedProperty<?>>();

+                    }

+                    set.add(derivedTo);

+                }

+            }

+        }

+        return set;

+    }

+}

diff --git a/src/main/java/com/amazon/carbonado/repo/indexed/IndexEntryAccessor.java b/src/main/java/com/amazon/carbonado/repo/indexed/IndexEntryAccessor.java
index 0c1e6b8..5f27aa8 100644
--- a/src/main/java/com/amazon/carbonado/repo/indexed/IndexEntryAccessor.java
+++ b/src/main/java/com/amazon/carbonado/repo/indexed/IndexEntryAccessor.java
@@ -59,7 +59,7 @@ public interface IndexEntryAccessor<S extends Storable> extends IndexInfo {
     /**

      * Returns true if the properties of the given index entry match those

      * contained in the master, exluding any version property. This will always

-     * return true after a call to setAllProperties.

+     * return true after a call to copyFromMaster.

      *

      * @param indexEntry index entry whose properties will be tested

      * @param master source of property values

diff --git a/src/main/java/com/amazon/carbonado/repo/indexed/IndexedRepository.java b/src/main/java/com/amazon/carbonado/repo/indexed/IndexedRepository.java
index 097185a..6bea049 100644
--- a/src/main/java/com/amazon/carbonado/repo/indexed/IndexedRepository.java
+++ b/src/main/java/com/amazon/carbonado/repo/indexed/IndexedRepository.java
@@ -86,7 +86,7 @@ class IndexedRepository implements Repository,
 

                 if (Unindexed.class.isAssignableFrom(type)) {

                     // Verify no indexes.

-                    int indexCount = IndexedStorage

+                    int indexCount = IndexAnalysis

                         .gatherDesiredIndexes(StorableIntrospector.examine(type)).size();

                     if (indexCount > 0) {

                         throw new MalformedTypeException

@@ -152,7 +152,12 @@ class IndexedRepository implements Repository,
         getIndexEntryAccessors(Class<S> storableType)

         throws RepositoryException

     {

-        return ((IndexedStorage<S>) storageFor(storableType)).getIndexEntryAccessors();

+        Storage<S> storage = storageFor(storableType);

+        if (storage instanceof IndexedStorage) {

+            return ((IndexedStorage<S>) storage).getIndexEntryAccessors();

+        } else {

+            return new IndexEntryAccessor[0];

+        }

     }

 

     public String[] getUserStorableTypeNames() throws RepositoryException {

diff --git a/src/main/java/com/amazon/carbonado/repo/indexed/IndexedStorage.java b/src/main/java/com/amazon/carbonado/repo/indexed/IndexedStorage.java
index fe0cfe8..28a9d35 100644
--- a/src/main/java/com/amazon/carbonado/repo/indexed/IndexedStorage.java
+++ b/src/main/java/com/amazon/carbonado/repo/indexed/IndexedStorage.java
@@ -23,6 +23,7 @@ import java.util.Collection;
 import java.util.IdentityHashMap;

 import java.util.List;

 import java.util.Map;

+import java.util.Set;

 

 import org.apache.commons.logging.Log;

 import org.apache.commons.logging.LogFactory;

@@ -32,9 +33,11 @@ import com.amazon.carbonado.FetchException;
 import com.amazon.carbonado.IsolationLevel;

 import com.amazon.carbonado.PersistException;

 import com.amazon.carbonado.Query;

+import com.amazon.carbonado.Repository;

 import com.amazon.carbonado.RepositoryException;

 import com.amazon.carbonado.Storable;

 import com.amazon.carbonado.Storage;

+import com.amazon.carbonado.SupportException;

 import com.amazon.carbonado.Transaction;

 import com.amazon.carbonado.Trigger;

 import com.amazon.carbonado.capability.IndexInfo;

@@ -45,6 +48,7 @@ import com.amazon.carbonado.cursor.MergeSortBuffer;
 

 import com.amazon.carbonado.filter.Filter;

 

+import com.amazon.carbonado.info.ChainedProperty;

 import com.amazon.carbonado.info.Direction;

 import com.amazon.carbonado.info.StorableInfo;

 import com.amazon.carbonado.info.StorableIntrospector;

@@ -53,6 +57,7 @@ import com.amazon.carbonado.info.StorableIndex;
 import com.amazon.carbonado.cursor.SortBuffer;

 

 import com.amazon.carbonado.qe.BoundaryType;

+import com.amazon.carbonado.qe.FilteringScore;

 import com.amazon.carbonado.qe.QueryEngine;

 import com.amazon.carbonado.qe.QueryExecutorFactory;

 import com.amazon.carbonado.qe.StorageAccess;

@@ -69,13 +74,6 @@ import static com.amazon.carbonado.repo.indexed.ManagedIndex.*;
  * @author Brian S O'Neill

  */

 class IndexedStorage<S extends Storable> implements Storage<S>, StorageAccess<S> {

-    static <S extends Storable> StorableIndexSet<S> gatherDesiredIndexes(StorableInfo<S> info) {

-        StorableIndexSet<S> indexSet = new StorableIndexSet<S>();

-        indexSet.addIndexes(info);

-        indexSet.addAlternateKeys(info);

-        return indexSet;

-    }

-

     final IndexedRepository mRepository;

     final Storage<S> mMasterStorage;

 

@@ -102,7 +100,7 @@ class IndexedStorage<S extends Storable> implements Storage<S>, StorageAccess<S>
         // The set of indexes that the Storable defines, reduced.

         final StorableIndexSet<S> desiredIndexSet;

         {

-            desiredIndexSet = gatherDesiredIndexes(info);

+            desiredIndexSet = IndexAnalysis.gatherDesiredIndexes(info);

             desiredIndexSet.reduce(Direction.ASCENDING);

         }

 

@@ -299,6 +297,17 @@ class IndexedStorage<S extends Storable> implements Storage<S>, StorageAccess<S>
 

         mQueryableIndexSet = queryableIndexSet;

         mQueryEngine = new QueryEngine<S>(masterStorage.getStorableType(), repository);

+

+        // Install triggers to manage derived properties in external Storables.

+

+        Set<ChainedProperty<?>> derivedToDependencies =

+            IndexAnalysis.gatherDerivedToDependencies(info);

+

+        if (derivedToDependencies != null) {

+            for (ChainedProperty<?> derivedTo : derivedToDependencies) {

+                addTrigger(new DerivedIndexesTrigger(repository, getStorableType(), derivedTo));

+            }

+        }

     }

 

     public Class<S> getStorableType() {

diff --git a/src/main/java/com/amazon/carbonado/repo/indexed/ManagedIndex.java b/src/main/java/com/amazon/carbonado/repo/indexed/ManagedIndex.java
index 2e4cea3..b1e76cc 100644
--- a/src/main/java/com/amazon/carbonado/repo/indexed/ManagedIndex.java
+++ b/src/main/java/com/amazon/carbonado/repo/indexed/ManagedIndex.java
@@ -18,6 +18,8 @@
 

 package com.amazon.carbonado.repo.indexed;

 

+import java.lang.reflect.UndeclaredThrowableException;

+

 import java.util.Comparator;

 

 import org.apache.commons.logging.Log;

@@ -451,10 +453,23 @@ class ManagedIndex<S extends Storable> implements IndexEntryAccessor<S> {
         }

     }

 

-    private Storable makeIndexEntry(S userStorable) {

-        Storable indexEntry = mIndexEntryStorage.prepare();

-        mGenerator.copyFromMaster(indexEntry, userStorable);

-        return indexEntry;

+    private Storable makeIndexEntry(S userStorable) throws PersistException {

+        try {

+            Storable indexEntry = mIndexEntryStorage.prepare();

+            mGenerator.copyFromMaster(indexEntry, userStorable);

+            return indexEntry;

+        } catch (UndeclaredThrowableException e) {

+            Throwable cause = e.getCause();

+            if (cause instanceof PersistException) {

+                throw (PersistException) cause;

+            }

+            throw new PersistException(cause);

+        } catch (Exception e) {

+            if (e instanceof PersistException) {

+                throw (PersistException) e;

+            }

+            throw new PersistException(e);

+        }

     }

 

     /** Assumes caller is in a transaction */