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.impl.CameraMetadataNative;
  import android.hardware.camera2.utils.TypeReference;
  
  import java.util.ArrayList;
  import java.util.HashMap;
  import java.util.List;
  
  /**
   * Registry of supported marshalers; add new query-able marshalers or lookup existing ones.</p>
   */
  public class MarshalRegistry {
  
      /**
       * Register a marshal queryable for the managed type {@code T}.
       *
       * <p>Multiple marshal queryables for the same managed type {@code T} may be registered;
       * this is desirable if they support different native types (e.g. marshaler 1 supports
       * {@code Integer <-> TYPE_INT32}, marshaler 2 supports {@code Integer <-> TYPE_BYTE}.</p>
       *
       * @param queryable a non-{@code null} marshal queryable that supports marshaling {@code T}
       */
      public static <T> void registerMarshalQueryable(MarshalQueryable<T> queryable) {
          synchronized(sMarshalLock) {
              sRegisteredMarshalQueryables.add(queryable);
          }
      }
  
      /**
       * Lookup a marshaler between {@code T} and {@code nativeType}.
       *
       * <p>Marshalers are looked up in the order they were registered; earlier registered
       * marshal queriers get priority.</p>
       *
       * @param typeToken The compile-time type reference for {@code T}
       * @param nativeType The native type, e.g. {@link CameraMetadataNative#TYPE_BYTE TYPE_BYTE}
       * @return marshaler a non-{@code null} marshaler that supports marshaling the type combo
       *
       * @throws UnsupportedOperationException If no marshaler matching the args could be found
       */
      @SuppressWarnings("unchecked")
      public static <T> Marshaler<T> getMarshaler(TypeReference<T> typeToken, int nativeType) {
          synchronized(sMarshalLock) {
              // TODO: can avoid making a new token each time by code-genning
              // the list of type tokens and native types from the keys (at the call sites)
              MarshalToken<T> marshalToken = new MarshalToken<T>(typeToken, nativeType);
  
              /*
               * Marshalers are instantiated lazily once they are looked up; successive lookups
               * will not instantiate new marshalers.
               */
              Marshaler<T> marshaler =
                      (Marshaler<T>) sMarshalerMap.get(marshalToken);
  
              if (marshaler == null) {
  
                  if (sRegisteredMarshalQueryables.size() == 0) {
                      throw new AssertionError("No available query marshalers registered");
                  }
  
                  // Query each marshaler to see if they support the native/managed type combination
                  for (MarshalQueryable<?> potentialMarshaler : sRegisteredMarshalQueryables) {
  
                      MarshalQueryable<T> castedPotential =
                              (MarshalQueryable<T>)potentialMarshaler;
  
                      if (castedPotential.isTypeMappingSupported(typeToken, nativeType)) {
                          marshaler = castedPotential.createMarshaler(typeToken, nativeType);
                          break;
                      }
                  }
  
                  if (marshaler == null) {
                      throw new UnsupportedOperationException(
                          "Could not find marshaler that matches the requested " +
                          "combination of type reference " +
                          typeToken + " and native type " +
                          MarshalHelpers.toStringNativeType(nativeType));
                  }
  
                  // Only put when no cached version exists to avoid +0.5ms lookup per call.
                  sMarshalerMap.put(marshalToken, marshaler);
              }
  
              return marshaler;
          }
      }
  
      private static class MarshalToken<T> {
          public MarshalToken(TypeReference<T> typeReference, int nativeType) {
              this.typeReference = typeReference;
              this.nativeType = nativeType;
              this.hash = typeReference.hashCode() ^ nativeType;
          }
  
          final TypeReference<T> typeReference;
          final int nativeType;
          private final int hash;
  
          @Override
          public boolean equals(Object other) {
              if (other instanceof MarshalToken<?>) {
                  MarshalToken<?> otherToken = (MarshalToken<?>)other;
                  return typeReference.equals(otherToken.typeReference) &&
                          nativeType == otherToken.nativeType;
              }
  
              return false;
          }
  
          @Override
          public int hashCode() {
              return hash;
          }
      }
  
      // Control access to the static data structures below
      private static final Object sMarshalLock = new Object();
  
      private static final List<MarshalQueryable<?>> sRegisteredMarshalQueryables =
              new ArrayList<MarshalQueryable<?>>();
      private static final HashMap<MarshalToken<?>, Marshaler<?>> sMarshalerMap =
              new HashMap<MarshalToken<?>, Marshaler<?>>();
  
      private MarshalRegistry() {
          throw new AssertionError();
      }
  }
  