package com.google.common.reflect;

import com.google.common.annotations.Beta;
import com.google.common.base.Preconditions;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableList.Builder;
import java.lang.annotation.Annotation;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Constructor;
import java.lang.reflect.GenericDeclaration;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.Arrays;
import javax.annotation.Nullable;
import rj;
import rm;

@Beta
public abstract class Invokable<T, R>
  extends rj
  implements GenericDeclaration
{
  <M extends AccessibleObject,  extends Member> Invokable(M paramM)
  {
    super(paramM);
  }
  
  public static <T> Invokable<T, T> from(Constructor<T> paramConstructor)
  {
    return new a(paramConstructor);
  }
  
  public static Invokable<?, Object> from(Method paramMethod)
  {
    return new b(paramMethod);
  }
  
  abstract Object a(@Nullable Object paramObject, Object[] paramArrayOfObject)
    throws InvocationTargetException, IllegalAccessException;
  
  abstract Type[] a();
  
  abstract Type[] b();
  
  abstract Annotation[][] c();
  
  abstract Type d();
  
  public final Class<? super T> getDeclaringClass()
  {
    return super.getDeclaringClass();
  }
  
  public final ImmutableList<TypeToken<? extends Throwable>> getExceptionTypes()
  {
    ImmutableList.Builder localBuilder = ImmutableList.builder();
    Type[] arrayOfType = b();
    int j = arrayOfType.length;
    int i = 0;
    while (i < j)
    {
      localBuilder.add(TypeToken.of(arrayOfType[i]));
      i += 1;
    }
    return localBuilder.build();
  }
  
  public TypeToken<T> getOwnerType()
  {
    return TypeToken.of(getDeclaringClass());
  }
  
  public final ImmutableList<Parameter> getParameters()
  {
    Type[] arrayOfType = a();
    Annotation[][] arrayOfAnnotation = c();
    ImmutableList.Builder localBuilder = ImmutableList.builder();
    int i = 0;
    while (i < arrayOfType.length)
    {
      localBuilder.add(new Parameter(this, i, TypeToken.of(arrayOfType[i]), arrayOfAnnotation[i]));
      i += 1;
    }
    return localBuilder.build();
  }
  
  public final TypeToken<? extends R> getReturnType()
  {
    return TypeToken.of(d());
  }
  
  public final R invoke(@Nullable T paramT, Object... paramVarArgs)
    throws InvocationTargetException, IllegalAccessException
  {
    return (R)a(paramT, (Object[])Preconditions.checkNotNull(paramVarArgs));
  }
  
  public abstract boolean isOverridable();
  
  public abstract boolean isVarArgs();
  
  public final <R1 extends R> Invokable<T, R1> returning(TypeToken<R1> paramTypeToken)
  {
    if (!paramTypeToken.isAssignableFrom(getReturnType()))
    {
      String str = String.valueOf(String.valueOf(getReturnType()));
      paramTypeToken = String.valueOf(String.valueOf(paramTypeToken));
      throw new IllegalArgumentException(str.length() + 35 + paramTypeToken.length() + "Invokable is known to return " + str + ", not " + paramTypeToken);
    }
    return this;
  }
  
  public final <R1 extends R> Invokable<T, R1> returning(Class<R1> paramClass)
  {
    return returning(TypeToken.of(paramClass));
  }
  
  static class a<T>
    extends Invokable<T, T>
  {
    final Constructor<?> a;
    
    a(Constructor<?> paramConstructor)
    {
      super();
      this.a = paramConstructor;
    }
    
    final Object a(@Nullable Object paramObject, Object[] paramArrayOfObject)
      throws InvocationTargetException, IllegalAccessException
    {
      try
      {
        paramObject = this.a.newInstance(paramArrayOfObject);
        return paramObject;
      }
      catch (InstantiationException paramObject)
      {
        paramArrayOfObject = String.valueOf(String.valueOf(this.a));
        throw new RuntimeException(paramArrayOfObject.length() + 8 + paramArrayOfObject + " failed.", (Throwable)paramObject);
      }
    }
    
    Type[] a()
    {
      Type[] arrayOfType = this.a.getGenericParameterTypes();
      Object localObject1 = arrayOfType;
      int i;
      if (arrayOfType.length > 0)
      {
        localObject1 = this.a.getDeclaringClass();
        if (((Class)localObject1).getEnclosingConstructor() == null) {
          break label86;
        }
        i = 1;
      }
      for (;;)
      {
        localObject1 = arrayOfType;
        if (i != 0)
        {
          localObject2 = this.a.getParameterTypes();
          localObject1 = arrayOfType;
          if (arrayOfType.length == localObject2.length)
          {
            localObject1 = arrayOfType;
            if (localObject2[0] == getDeclaringClass().getEnclosingClass()) {
              localObject1 = (Type[])Arrays.copyOfRange(arrayOfType, 1, arrayOfType.length);
            }
          }
        }
        return (Type[])localObject1;
        label86:
        Object localObject2 = ((Class)localObject1).getEnclosingMethod();
        if (localObject2 != null)
        {
          if (!Modifier.isStatic(((Method)localObject2).getModifiers())) {
            i = 1;
          } else {
            i = 0;
          }
        }
        else if ((((Class)localObject1).getEnclosingClass() != null) && (!Modifier.isStatic(((Class)localObject1).getModifiers()))) {
          i = 1;
        } else {
          i = 0;
        }
      }
    }
    
    Type[] b()
    {
      return this.a.getGenericExceptionTypes();
    }
    
    final Annotation[][] c()
    {
      return this.a.getParameterAnnotations();
    }
    
    Type d()
    {
      Class localClass = getDeclaringClass();
      TypeVariable[] arrayOfTypeVariable = localClass.getTypeParameters();
      Object localObject = localClass;
      if (arrayOfTypeVariable.length > 0) {
        localObject = rm.a(localClass, arrayOfTypeVariable);
      }
      return (Type)localObject;
    }
    
    public final TypeVariable<?>[] getTypeParameters()
    {
      TypeVariable[] arrayOfTypeVariable1 = getDeclaringClass().getTypeParameters();
      TypeVariable[] arrayOfTypeVariable2 = this.a.getTypeParameters();
      TypeVariable[] arrayOfTypeVariable3 = new TypeVariable[arrayOfTypeVariable1.length + arrayOfTypeVariable2.length];
      System.arraycopy(arrayOfTypeVariable1, 0, arrayOfTypeVariable3, 0, arrayOfTypeVariable1.length);
      System.arraycopy(arrayOfTypeVariable2, 0, arrayOfTypeVariable3, arrayOfTypeVariable1.length, arrayOfTypeVariable2.length);
      return arrayOfTypeVariable3;
    }
    
    public final boolean isOverridable()
    {
      return false;
    }
    
    public final boolean isVarArgs()
    {
      return this.a.isVarArgs();
    }
  }
  
  static class b<T>
    extends Invokable<T, Object>
  {
    final Method a;
    
    b(Method paramMethod)
    {
      super();
      this.a = paramMethod;
    }
    
    final Object a(@Nullable Object paramObject, Object[] paramArrayOfObject)
      throws InvocationTargetException, IllegalAccessException
    {
      return this.a.invoke(paramObject, paramArrayOfObject);
    }
    
    Type[] a()
    {
      return this.a.getGenericParameterTypes();
    }
    
    Type[] b()
    {
      return this.a.getGenericExceptionTypes();
    }
    
    final Annotation[][] c()
    {
      return this.a.getParameterAnnotations();
    }
    
    Type d()
    {
      return this.a.getGenericReturnType();
    }
    
    public final TypeVariable<?>[] getTypeParameters()
    {
      return this.a.getTypeParameters();
    }
    
    public final boolean isOverridable()
    {
      return (!isFinal()) && (!isPrivate()) && (!isStatic()) && (!Modifier.isFinal(getDeclaringClass().getModifiers()));
    }
    
    public final boolean isVarArgs()
    {
      return this.a.isVarArgs();
    }
  }
}


/* Location:              /home/merong/decompile/hackery-dex2jar.jar!/com/google/common/reflect/Invokable.class
 * Java compiler version: 6 (50.0)
 * JD-Core Version:       0.7.1
 */