2 files changed, 186 insertions, 76 deletions
diff --git a/src/main/java/com/amazon/carbonado/synthetic/SyntheticStorableReferenceAccess.java b/src/main/java/com/amazon/carbonado/synthetic/SyntheticStorableReferenceAccess.java
new file mode 100644
index 0000000..778b4ac
--- /dev/null
+++ b/src/main/java/com/amazon/carbonado/synthetic/SyntheticStorableReferenceAccess.java
@@ -0,0 +1,152 @@
+/*
+ * Copyright 2008 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.synthetic;
+
+import java.lang.reflect.Method;
+import java.lang.reflect.UndeclaredThrowableException;
+
+import java.util.Comparator;
+import java.util.Iterator;
+
+import com.amazon.carbonado.Storable;
+
+import com.amazon.carbonado.cursor.SortedCursor;
+
+import com.amazon.carbonado.util.ThrowUnchecked;
+
+/**
+ * Provides access to the generated storable reference class and utility
+ * methods.
+ *
+ * @author Brian S O'Neill
+ * @see SyntheticStorableReferenceBuilder
+ * @since 1.2.1
+ */
+public class SyntheticStorableReferenceAccess<S extends Storable> {
+    private final Class<S> mMasterClass;
+    private final Class<? extends Storable> mReferenceClass;
+
+    private final Comparator<? extends Storable> mComparator;
+
+    private final Method mCopyFromMasterMethod;
+    private final Method mIsConsistentMethod;
+    private final Method mCopyToMasterPkMethod;
+
+    SyntheticStorableReferenceAccess(Class<S> masterClass,
+                                     Class<? extends Storable> referenceClass,
+                                     SyntheticStorableReferenceBuilder builder)
+    {
+        mMasterClass = masterClass;
+        mReferenceClass = referenceClass;
+
+        // We need a comparator which follows the same order as the generated
+        // storable.
+        SyntheticKey pk = builder.mPrimaryKey;
+        String[] orderBy = new String[pk.getPropertyCount()];
+        int i=0;
+        Iterator<String> it = pk.getProperties();
+        while (it.hasNext()) {
+            orderBy[i++] = it.next();
+        }
+        mComparator = SortedCursor.createComparator(referenceClass, orderBy);
+
+        try {
+            mCopyFromMasterMethod =
+                referenceClass.getMethod(builder.mCopyFromMasterMethodName, masterClass);
+
+            mIsConsistentMethod =
+                referenceClass.getMethod(builder.mIsConsistentMethodName, masterClass);
+
+            mCopyToMasterPkMethod =
+                referenceClass.getMethod(builder.mCopyToMasterPkMethodName, masterClass);
+        } catch (NoSuchMethodException e) {
+            throw new UndeclaredThrowableException(e);
+        }
+    }
+
+    /**
+     * Returns the storable class which is referenced.
+     */
+    public Class<S> getMasterClass() {
+        return mMasterClass;
+    }
+
+    /**
+     * Returns the generated storable reference class.
+     */
+    public Class<? extends Storable> getReferenceClass() {
+        return mReferenceClass;
+    }
+
+    /**
+     * Returns a comparator for ordering storable reference instances. This
+     * order matches the primary key of the master storable.
+     */
+    public Comparator<? extends Storable> getComparator() {
+        return mComparator;
+    }
+
+    /**
+     * Sets all the primary key properties of the given master, using the
+     * applicable properties of the given reference.
+     *
+     * @param reference source of property values
+     * @param master master whose primary key properties will be set
+     */
+    public void copyToMasterPrimaryKey(Storable reference, S master) {
+        try {
+            mCopyToMasterPkMethod.invoke(reference, master);
+        } catch (Exception e) {
+            ThrowUnchecked.fireFirstDeclaredCause(e);
+        }
+    }
+
+    /**
+     * Sets all the properties of the given reference, using the applicable
+     * properties of the given master.
+     *
+     * @param reference reference whose properties will be set
+     * @param master source of property values
+     */
+    public void copyFromMaster(Storable reference, S master) {
+        try {
+            mCopyFromMasterMethod.invoke(reference, master);
+        } catch (Exception e) {
+            ThrowUnchecked.fireFirstDeclaredCause(e);
+        }
+    }
+
+    /**
+     * Returns true if the properties of the given reference match those
+     * contained in the master, excluding any version property. This will
+     * always return true after a call to copyFromMaster.
+     *
+     * @param reference reference whose properties will be tested
+     * @param master source of property values
+     */
+    public boolean isConsistent(Storable reference, S master) {
+        try {
+            return (Boolean) mIsConsistentMethod.invoke(reference, master);
+        } catch (Exception e) {
+            ThrowUnchecked.fireFirstDeclaredCause(e);
+            // Not reached.
+            return false;
+        }
+    }
+}
diff --git a/src/main/java/com/amazon/carbonado/synthetic/SyntheticStorableReferenceBuilder.java b/src/main/java/com/amazon/carbonado/synthetic/SyntheticStorableReferenceBuilder.java
index 4fddcd5..a06c557 100644
--- a/src/main/java/com/amazon/carbonado/synthetic/SyntheticStorableReferenceBuilder.java
+++ b/src/main/java/com/amazon/carbonado/synthetic/SyntheticStorableReferenceBuilder.java
@@ -18,7 +18,6 @@
 package com.amazon.carbonado.synthetic;
 
 import java.lang.reflect.Method;
-import java.lang.reflect.UndeclaredThrowableException;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.Comparator;
@@ -29,13 +28,11 @@ import java.util.Set;
 
 import com.amazon.carbonado.Storable;
 import com.amazon.carbonado.SupportException;
-import com.amazon.carbonado.cursor.SortedCursor;
 import com.amazon.carbonado.info.Direction;
 import com.amazon.carbonado.info.StorableInfo;
 import com.amazon.carbonado.info.StorableIntrospector;
 import com.amazon.carbonado.info.StorableProperty;
 import com.amazon.carbonado.gen.CodeBuilderUtil;
-import com.amazon.carbonado.util.ThrowUnchecked;
 
 import org.cojen.classfile.ClassFile;
 import org.cojen.classfile.CodeBuilder;
@@ -80,7 +77,7 @@ public class SyntheticStorableReferenceBuilder<S extends Storable>
 
     // Information about the storable from which this one is derived
     // private StorableInfo<S> mBaseStorableInfo;
-    private Class mMasterStorableClass;
+    private Class<S> mMasterStorableClass;
 
     // Stashed copy of the results of calling StorableIntrospector.examine(...)
     // on the master storable class.
@@ -90,7 +87,7 @@ public class SyntheticStorableReferenceBuilder<S extends Storable>
     private SyntheticStorableBuilder mBuilder;
 
     // Primary key of generated storable.
-    private SyntheticKey mPrimaryKey;
+    SyntheticKey mPrimaryKey;
 
     // Elements added to primary key to ensure uniqueness
     private Set<String> mExtraPkProps;
@@ -99,9 +96,6 @@ public class SyntheticStorableReferenceBuilder<S extends Storable>
     // uniquely identify a unique instance of the referent.
     private boolean mIsUnique = true;
 
-    // The result of building
-    private Class<? extends Storable> mSyntheticClass;
-
     // The list of properties explicitly added to this reference builder
     private List<SyntheticProperty> mUserProps;
 
@@ -110,16 +104,12 @@ public class SyntheticStorableReferenceBuilder<S extends Storable>
     // are retrieved from the master.
     private List<StorableProperty> mCommonProps;
 
-    private String mCopyFromMasterMethodName;
-    private Method mCopyFromMasterMethod;
-
-    private String mIsConsistentMethodName;
-    private Method mIsConsistentMethod;
-
-    private String mCopyToMasterPkMethodName;
-    private Method mCopyToMasterPkMethod;
+    String mCopyFromMasterMethodName;
+    String mIsConsistentMethodName;
+    String mCopyToMasterPkMethodName;
 
-    private Comparator<? extends Storable> mComparator;
+    // The result of building.
+    private SyntheticStorableReferenceAccess mReferenceAccess;
 
     /**
      * @param storableClass
@@ -210,26 +200,27 @@ public class SyntheticStorableReferenceBuilder<S extends Storable>
         return cfg;
     }
 
+    /**
+     * Build and return access to the generated storable reference class.
+     *
+     * @since 1.2.1
+     */
+    public SyntheticStorableReferenceAccess getReferenceAccess() {
+        if (mReferenceAccess == null) {
+            Class<? extends Storable> referenceClass = mBuilder.getStorableClass();
+            mReferenceAccess = new SyntheticStorableReferenceAccess
+                (mMasterStorableClass, referenceClass, this);
+        }
+        return mReferenceAccess;
+    }
+
     /*
      * (non-Javadoc)
      *
      * @see com.amazon.carbonado.synthetic.SyntheticBuilder#getStorableClass()
      */
     public Class<? extends Storable> getStorableClass() throws IllegalStateException {
-        if (mSyntheticClass == null) {
-            mSyntheticClass = mBuilder.getStorableClass();
-
-            // We need a comparator which follows the same order as the generated
-            // storable. We can't construct it until we get here.
-            String[] orderBy = new String[mPrimaryKey.getPropertyCount()];
-            int i=0;
-            Iterator<String> it = mPrimaryKey.getProperties();
-            while (it.hasNext()) {
-                orderBy[i++] = it.next();
-            }
-            mComparator = SortedCursor.createComparator(mSyntheticClass, orderBy);
-        }
-        return mSyntheticClass;
+        return getReferenceAccess().getReferenceClass();
     }
 
     /*
@@ -356,22 +347,11 @@ public class SyntheticStorableReferenceBuilder<S extends Storable>
      *
      * @param indexEntry source of property values
      * @param master master whose primary key properties will be set
+     * @deprecated call getReferenceAccess
      */
+    @Deprecated
     public void copyToMasterPrimaryKey(Storable indexEntry, S master) {
-        if (mCopyToMasterPkMethod == null) {
-            try {
-                mCopyToMasterPkMethod =
-                    mSyntheticClass.getMethod(mCopyToMasterPkMethodName, mMasterStorableClass);
-            } catch (NoSuchMethodException e) {
-                throw new UndeclaredThrowableException(e);
-            }
-        }
-
-        try {
-            mCopyToMasterPkMethod.invoke(indexEntry, master);
-        } catch (Exception e) {
-            ThrowUnchecked.fireFirstDeclaredCause(e);
-        }
+        getReferenceAccess().copyToMasterPrimaryKey(indexEntry, master);
     }
 
     /**
@@ -380,22 +360,11 @@ public class SyntheticStorableReferenceBuilder<S extends Storable>
      *
      * @param indexEntry index entry whose properties will be set
      * @param master source of property values
+     * @deprecated call getReferenceAccess
      */
+    @Deprecated
     public void copyFromMaster(Storable indexEntry, S master) {
-        if (mCopyFromMasterMethod == null) {
-            try {
-                mCopyFromMasterMethod =
-                    mSyntheticClass.getMethod(mCopyFromMasterMethodName, mMasterStorableClass);
-            } catch (NoSuchMethodException e) {
-                throw new UndeclaredThrowableException(e);
-            }
-        }
-
-        try {
-            mCopyFromMasterMethod.invoke(indexEntry, master);
-        } catch (Exception e) {
-            ThrowUnchecked.fireFirstDeclaredCause(e);
-        }
+        getReferenceAccess().copyFromMaster(indexEntry, master);
     }
 
     /**
@@ -407,31 +376,20 @@ public class SyntheticStorableReferenceBuilder<S extends Storable>
      *            index entry whose properties will be tested
      * @param master
      *            source of property values
+     * @deprecated call getReferenceAccess
      */
+    @Deprecated
     public boolean isConsistent(Storable indexEntry, S master) {
-        if (mIsConsistentMethod == null) {
-            try {
-                mIsConsistentMethod =
-                    mSyntheticClass.getMethod(mIsConsistentMethodName, mMasterStorableClass);
-            } catch (NoSuchMethodException e) {
-                throw new UndeclaredThrowableException(e);
-            }
-        }
-
-        try {
-            return (Boolean) mIsConsistentMethod.invoke(indexEntry, master);
-        } catch (Exception e) {
-            ThrowUnchecked.fireFirstDeclaredCause(e);
-            // Not reached.
-            return false;
-        }
+        return getReferenceAccess().isConsistent(indexEntry, master);
     }
 
     /**
      * Returns a comparator for ordering index entries.
+     * @deprecated call getReferenceAccess
      */
+    @Deprecated
     public Comparator<? extends Storable> getComparator() {
-        return mComparator;
+        return getReferenceAccess().getComparator();
     }
 
     /**