content: /*
   * Copyright (C) 2014 The Android Open Source Project
   *
   * 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 android.hardware.camera2.marshal;
  
  import android.hardware.camera2.utils.TypeReference;
  
  import java.nio.ByteBuffer;
  
  import static android.hardware.camera2.marshal.MarshalHelpers.*;
  import static com.android.internal.util.Preconditions.*;
  
  /**
   * Base class to marshal data to/from managed/native metadata byte buffers.
   *
   * <p>This class should not be created directly; an instance of it can be obtained
   * using {@link MarshalQueryable#createMarshaler} for the same type {@code T} if the native type
   * mapping for {@code T} {@link MarshalQueryable#isTypeMappingSupported supported}.</p>
   *
   * @param <T> the compile-time managed type
   */
  public abstract class Marshaler<T> {
  
      protected final TypeReference<T> mTypeReference;
      protected final int mNativeType;
  
      /**
       * Instantiate a marshaler between a single managed/native type combination.
       *
       * <p>This particular managed/native type combination must be supported by
       * {@link #isTypeMappingSupported}.</p>
       *
       * @param query an instance of {@link MarshalQueryable}
       * @param typeReference the managed type reference
       *        Must be one for which {@link #isTypeMappingSupported} returns {@code true}
       * @param nativeType the native type, e.g.
       *        {@link android.hardware.camera2.impl.CameraMetadataNative#TYPE_BYTE TYPE_BYTE}.
       *        Must be one for which {@link #isTypeMappingSupported} returns {@code true}.
       *
       * @throws NullPointerException if any args were {@code null}
       * @throws UnsupportedOperationException if the type mapping was not supported
       */
      protected Marshaler(
              MarshalQueryable<T> query, TypeReference<T> typeReference, int nativeType) {
          mTypeReference = checkNotNull(typeReference, "typeReference must not be null");
          mNativeType = checkNativeType(nativeType);
  
          if (!query.isTypeMappingSupported(typeReference, nativeType)) {
              throw new UnsupportedOperationException(
                      "Unsupported type marshaling for managed type "
                              + typeReference + " and native type "
                              + MarshalHelpers.toStringNativeType(nativeType));
          }
      }
  
      /**
       * Marshal the specified object instance (value) into a byte buffer.
       *
       * <p>Upon completion, the {@link ByteBuffer#position()} will have advanced by
       * the {@link #calculateMarshalSize marshal size} of {@code value}.</p>
       *
       * @param value the value of type T that we wish to write into the byte buffer
       * @param buffer the byte buffer into which the marshaled object will be written
       */
      public abstract void marshal(T value, ByteBuffer buffer);
  
      /**
       * Get the size in bytes for how much space would be required to write this {@code value}
       * into a byte buffer using the given {@code nativeType}.
       *
       * <p>If the size of this {@code T} instance when serialized into a buffer is always constant,
       * then this method will always return the same value (and particularly, it will return
       * an equivalent value to {@link #getNativeSize()}.</p>
       *
       * <p>Overriding this method is a must when the size is {@link NATIVE_SIZE_DYNAMIC dynamic}.</p>
       *
       * @param value the value of type T that we wish to write into the byte buffer
       * @return the size that would need to be written to the byte buffer
       */
      public int calculateMarshalSize(T value) {
          int nativeSize = getNativeSize();
  
          if (nativeSize == NATIVE_SIZE_DYNAMIC) {
              throw new AssertionError("Override this function for dynamically-sized objects");
          }
  
          return nativeSize;
      }
  
      /**
       * Unmarshal a new object instance from the byte buffer into its managed type.
       *
       * <p>Upon completion, the {@link ByteBuffer#position()} will have advanced by
       * the {@link #calculateMarshalSize marshal size} of the returned {@code T} instance.</p>
       *
       * @param buffer the byte buffer, from which we will read the object
       * @return a new instance of type T read from the byte buffer
       */
      public abstract T unmarshal(ByteBuffer buffer);
  
      /**
       * Used to denote variable-length data structures.
       *
       * <p>If the size is dynamic then we can't know ahead of time how big of a data structure
       * to preallocate for e.g. arrays, so one object must be unmarshaled at a time.</p>
       */
      public static int NATIVE_SIZE_DYNAMIC = -1;
  
      /**
       * How many bytes a single instance of {@code T} will take up if marshalled to/from
       * {@code nativeType}.
       *
       * <p>When unmarshaling data from native to managed, the instance {@code T} is not yet
       * available. If the native size is always a fixed mapping regardless of the instance of
       * {@code T} (e.g. if the type is not a container of some sort), it can be used to preallocate
       * containers for {@code T} to avoid resizing them.</p>
       *
       * <p>In particular, the array marshaler takes advantage of this (when size is not dynamic)
       * to preallocate arrays of the right length when unmarshaling an array {@code T[]}.</p>
       *
       * @return a size in bytes, or {@link #NATIVE_SIZE_DYNAMIC} if the size is dynamic
       */
      public abstract int getNativeSize();
  
      /**
       * The type reference for {@code T} for the managed type side of this marshaler.
       */
      public TypeReference<T> getTypeReference() {
          return mTypeReference;
      }
  
      /** The native type corresponding to this marshaler for the native side of this marshaler.*/
      public int getNativeType() {
          return mNativeType;
      }
  }
  