Don't implement byte transfer as a facet.

Author: tgregg

src/main/java/com/amazon/ion/impl/IonReaderContinuableTopLevelBinary.java

@@ -45,7 +45,7 @@
  * stream's values risk exceeding the available memory, then continuable reading must not be used.
  * </p>
  */
-final class IonReaderContinuableTopLevelBinary extends IonReaderContinuableApplicationBinary implements IonReader, _Private_ReaderWriter {
+final class IonReaderContinuableTopLevelBinary extends IonReaderContinuableApplicationBinary implements IonReader, _Private_ReaderWriter, _Private_ByteTransferReader {
 
     // True if continuable reading is disabled.
     private final boolean isNonContinuable;
@@ -316,12 +316,13 @@ public void hoist(Span span) {
         }
     }
 
-    private class ByteTransferReaderFacet implements _Private_ByteTransferReader {
-
-        @Override
-        public void transferCurrentValue(_Private_ByteTransferSink writer) throws IOException {
-            writer.writeBytes(buffer, (int) valuePreHeaderIndex, (int) (valueMarker.endIndex - valuePreHeaderIndex));
+    @Override
+    public boolean transferCurrentValue(_Private_ByteTransferSink writer) throws IOException {
+        if (hasAnnotations || !isByteBacked() || isInStruct()) {
+            return false;
         }
+        writer.writeBytes(buffer, (int) valuePreHeaderIndex, (int) (valueMarker.endIndex - valuePreHeaderIndex));
+        return true;
     }
 
     @Override
@@ -343,11 +344,6 @@ public <T> T asFacet(Class<T> facetType) {
             if (facetType == RawValueSpanProvider.class) {
                 return facetType.cast(new RawValueSpanProviderFacet());
             }
-            if (facetType == _Private_ByteTransferReader.class) {
-                if (!hasAnnotations && !isInStruct()) {
-                    return facetType.cast(new ByteTransferReaderFacet());
-                }
-            }
         }
         return null;
     }

src/main/java/com/amazon/ion/impl/_Private_ByteTransferReader.java

@@ -24,6 +24,12 @@
  */
 public interface _Private_ByteTransferReader
 {
-    public void transferCurrentValue(_Private_ByteTransferSink writer)
+    /**
+     * Copies the raw bytes representing the current value, excluding any field name or annotations, if possible.
+     * @param writer the sink for the bytes
+     * @return true if the byte transfer occurred; false if it was not possible.
+     * @throws IOException if thrown by the sink during transfer.
+     */
+    public boolean transferCurrentValue(_Private_ByteTransferSink writer)
         throws IOException;
 }

src/main/java/com/amazon/ion/impl/bin/AbstractIonWriter.java

@@ -54,18 +54,15 @@ public final void writeValue(final IonReader reader) throws IOException
     {
         final IonType type = reader.getType();
 
-        if (isStreamCopyOptimized())
+        if (isStreamCopyOptimized() && reader instanceof _Private_ByteTransferReader)
         {
-            final _Private_ByteTransferReader transferReader =
-                reader.asFacet(_Private_ByteTransferReader.class);
-
-            if (transferReader != null
-                && (_Private_Utils.isNonSymbolScalar(type)
-                 || symtabExtendsCache.symtabsCompat(getSymbolTable(), reader.getSymbolTable())))
+            if (_Private_Utils.isNonSymbolScalar(type)
+                || symtabExtendsCache.symtabsCompat(getSymbolTable(), reader.getSymbolTable()))
             {
                 // we have something we can pipe over
-                transferReader.transferCurrentValue(this);
-                return;
+                if (((_Private_ByteTransferReader) reader).transferCurrentValue(this)) {
+                    return;
+                }
             }
         }
 

src/test/java/com/amazon/ion/impl/OptimizedBinaryWriterTestCase.java

@@ -46,7 +46,7 @@ public abstract class OptimizedBinaryWriterTestCase
 
     /**
      * Denotes whether the
-     * {@link _Private_ByteTransferReader#transferCurrentValue(IonWriterSystemBinary)}
+     * {@link _Private_ByteTransferReader#transferCurrentValue(_Private_ByteTransferSink)}
      * has been called after an {@link IonWriter#writeValue(IonReader)}.
      */
     private boolean isTransferCurrentValueInvoked = false;
@@ -107,60 +107,28 @@ protected byte[] outputByteArray()
         return bytes;
     }
 
-    private class TransferCurrentValueWatchingReader
-        implements _Private_ByteTransferReader
-    {
-        private final _Private_ByteTransferReader myDelegate;
-
-        TransferCurrentValueWatchingReader(_Private_ByteTransferReader byteTransferReader)
-        {
-            myDelegate = byteTransferReader;
-        }
-
-        public void transferCurrentValue(_Private_ByteTransferSink sink)
-            throws IOException
-        {
-            OptimizedBinaryWriterTestCase.this.isTransferCurrentValueInvoked = true;
-            myDelegate.transferCurrentValue(sink);
-        }
-    }
-
     /**
      * Obtains a dynamic proxy of {@link IonReader} over the passed in byte[],
      * with an invocation handler hook over {@link _Private_ByteTransferReader} facet,
-     * so as to verify whether the transferCurrentValue() method is actually
+     * to verify whether the transferCurrentValue() method is actually
      * being called.
-     *
-     * @see TransferCurrentValueWatchingReader
      */
     protected IonReader makeReaderProxy(byte[] bytes)
     {
         final IonReader reader = system().newReader(bytes);
 
-        InvocationHandler handler = new InvocationHandler()
-        {
-            public Object invoke(Object proxy, Method method, Object[] args)
-                throws Throwable
+        InvocationHandler handler = (proxy, method, args) -> {
+            if (method.getName().equals("transferCurrentValue"))
             {
-                if (method.getName().equals("asFacet") &&
-                    args.length == 1 &&
-                    args[0] == _Private_ByteTransferReader.class)
-                {
-                    _Private_ByteTransferReader transferReader =
-                        (_Private_ByteTransferReader) method.invoke(reader, args);
-
-                    if (transferReader == null)
-                        return null;
-
-                    return new TransferCurrentValueWatchingReader(transferReader);
-                }
-
+                OptimizedBinaryWriterTestCase.this.isTransferCurrentValueInvoked = (boolean) method.invoke(reader, args);
+                return isTransferCurrentValueInvoked;
+            } else {
                 return method.invoke(reader, args);
             }
         };
 
         return (IonReader) newProxyInstance(reader.getClass().getClassLoader(),
-                                            new Class[] { IonReader.class },
+                                            new Class[] { IonReader.class, _Private_ByteTransferReader.class },
                                             handler);
     }