com.android.dx.rop.type.Prototype.withFirstParameter java code examples

Common ways to obtain Prototype

private void myMethod () {
 Prototype p =String descriptor;Prototype.intern(descriptor)
CstMethodRef ref;ref.getPrototype()
ConcreteMethod method;method.getEffectiveDescriptor()
Smart code suggestions by Tabnine
}

/**
 * Gets the prototype of this method as either a
 * {@code static} or instance method. In the case of a
 * {@code static} method, this is the same as the raw
 * prototype. In the case of an instance method, this has an
 * appropriately-typed {@code this} argument as the first
 * one.
 *
 * @param isStatic whether the method should be considered static
 * @return {@code non-null;} the method prototype
 */
public final Prototype getPrototype(boolean isStatic) {
  if (isStatic) {
    return prototype;
  } else {
    if (instancePrototype == null) {
      Type thisType = getDefiningClass().getClassType();
      instancePrototype = prototype.withFirstParameter(thisType);
    }
    return instancePrototype;
  }
}

/**
 * Gets the prototype of this method as either a
 * {@code static} or instance method. In the case of a
 * {@code static} method, this is the same as the raw
 * prototype. In the case of an instance method, this has an
 * appropriately-typed {@code this} argument as the first
 * one.
 *
 * @param isStatic whether the method should be considered static
 * @return {@code non-null;} the method prototype
 */
public final Prototype getPrototype(boolean isStatic) {
  if (isStatic) {
    return prototype;
  } else {
    if (instancePrototype == null) {
      Type thisType = getDefiningClass().getClassType();
      instancePrototype = prototype.withFirstParameter(thisType);
    }
    return instancePrototype;
  }
}

/**
 * Gets the prototype of this method as either a
 * {@code static} or instance method. In the case of a
 * {@code static} method, this is the same as the raw
 * prototype. In the case of an instance method, this has an
 * appropriately-typed {@code this} argument as the first
 * one.
 *
 * @param isStatic whether the method should be considered static
 * @return {@code non-null;} the method prototype
 */
public final Prototype getPrototype(boolean isStatic) {
  if (isStatic) {
    return prototype;
  } else {
    if (instancePrototype == null) {
      Type thisType = getDefiningClass().getClassType();
      instancePrototype = prototype.withFirstParameter(thisType);
    }
    return instancePrototype;
  }
}

/**
 * Interns an instance, adding to the descriptor as necessary based
 * on the given definer, name, and flags. For example, an init
 * method has an uninitialized object of type {@code definer}
 * as its first argument.
 *
 * @param descriptor {@code non-null;} the descriptor string
 * @param definer {@code non-null;} class the method is defined on
 * @param isStatic whether this is a static method
 * @param isInit whether this is an init method
 * @return {@code non-null;} the interned instance
 */
public static Prototype intern(String descriptor, Type definer,
    boolean isStatic, boolean isInit) {
  Prototype base = intern(descriptor);
  if (isStatic) {
    return base;
  }
  if (isInit) {
    definer = definer.asUninitialized(Integer.MAX_VALUE);
  }
  return base.withFirstParameter(definer);
}

/**
 * Interns an instance, adding to the descriptor as necessary based
 * on the given definer, name, and flags. For example, an init
 * method has an uninitialized object of type {@code definer}
 * as its first argument.
 *
 * @param descriptor {@code non-null;} the descriptor string
 * @param definer {@code non-null;} class the method is defined on
 * @param isStatic whether this is a static method
 * @param isInit whether this is an init method
 * @return {@code non-null;} the interned instance
 */
public static Prototype intern(String descriptor, Type definer,
    boolean isStatic, boolean isInit) {
  Prototype base = intern(descriptor);
  if (isStatic) {
    return base;
  }
  if (isInit) {
    definer = definer.asUninitialized(Integer.MAX_VALUE);
  }
  return base.withFirstParameter(definer);
}

/**
 * Gets the prototype of this method as either a
 * {@code static} or instance method. In the case of a
 * {@code static} method, this is the same as the raw
 * prototype. In the case of an instance method, this has an
 * appropriately-typed {@code this} argument as the first
 * one.
 *
 * @param isStatic whether the method should be considered static
 * @return {@code non-null;} the method prototype
 */
public final Prototype getPrototype(boolean isStatic) {
  if (isStatic) {
    return prototype;
  } else {
    if (instancePrototype == null) {
      Type thisType = getDefiningClass().getClassType();
      instancePrototype = prototype.withFirstParameter(thisType);
    }
    return instancePrototype;
  }
}

/**
 * Interns an instance, adding to the descriptor as necessary based
 * on the given definer, name, and flags. For example, an init
 * method has an uninitialized object of type {@code definer}
 * as its first argument.
 *
 * @param descriptor {@code non-null;} the descriptor string
 * @param definer {@code non-null;} class the method is defined on
 * @param isStatic whether this is a static method
 * @param isInit whether this is an init method
 * @return {@code non-null;} the interned instance
 */
public static Prototype intern(String descriptor, Type definer,
    boolean isStatic, boolean isInit) {
  Prototype base = intern(descriptor);
  if (isStatic) {
    return base;
  }
  if (isInit) {
    definer = definer.asUninitialized(Integer.MAX_VALUE);
  }
  return base.withFirstParameter(definer);
}

/**
 * Interns an instance, adding to the descriptor as necessary based
 * on the given definer, name, and flags. For example, an init
 * method has an uninitialized object of type {@code definer}
 * as its first argument.
 * 
 * @param descriptor {@code non-null;} the descriptor string
 * @param definer {@code non-null;} class the method is defined on
 * @param isStatic whether this is a static method
 * @param isInit whether this is an init method
 * @return {@code non-null;} the interned instance
 */
public static Prototype intern(String descriptor, Type definer,
    boolean isStatic, boolean isInit) {
  Prototype base = intern(descriptor);
  if (isStatic) {
    return base;
  }
  if (isInit) {
    definer = definer.asUninitialized(Integer.MAX_VALUE);
  }
  return base.withFirstParameter(definer);
}

/**
 * Gets the prototype of this method as either a
 * {@code static} or instance method. In the case of a
 * {@code static} method, this is the same as the raw
 * prototype. In the case of an instance method, this has an
 * appropriately-typed {@code this} argument as the first
 * one.
 *
 * @param isStatic whether the method should be considered static
 * @return {@code non-null;} the method prototype
 */
public final Prototype getPrototype(boolean isStatic) {
  if (isStatic) {
    return prototype;
  } else {
    if (instancePrototype == null) {
      Type thisType = getDefiningClass().getClassType();
      instancePrototype = prototype.withFirstParameter(thisType);
    }
    return instancePrototype;
  }
}

/**
 * Gets the prototype of this method as either a
 * {@code static} or instance method. In the case of a
 * {@code static} method, this is the same as the raw
 * prototype. In the case of an instance method, this has an
 * appropriately-typed {@code this} argument as the first
 * one.
 *
 * @param isStatic whether the method should be considered static
 * @return {@code non-null;} the method prototype
 */
public final Prototype getPrototype(boolean isStatic) {
  if (isStatic) {
    return prototype;
  } else {
    if (instancePrototype == null) {
      Type thisType = getDefiningClass().getClassType();
      instancePrototype = prototype.withFirstParameter(thisType);
    }
    return instancePrototype;
  }
}

/**
 * Gets the prototype of this method as either a
 * {@code static} or instance method. In the case of a
 * {@code static} method, this is the same as the raw
 * prototype. In the case of an instance method, this has an
 * appropriately-typed {@code this} argument as the first
 * one.
 *
 * @param isStatic whether the method should be considered static
 * @return {@code non-null;} the method prototype
 */
public final Prototype getPrototype(boolean isStatic) {
  if (isStatic) {
    return prototype;
  } else {
    if (instancePrototype == null) {
      Type thisType = getDefiningClass().getClassType();
      instancePrototype = prototype.withFirstParameter(thisType);
    }
    return instancePrototype;
  }
}

/**
 * Gets the prototype of this method as either a
 * {@code static} or instance method. In the case of a
 * {@code static} method, this is the same as the raw
 * prototype. In the case of an instance method, this has an
 * appropriately-typed {@code this} argument as the first
 * one.
 *
 * @param isStatic whether the method should be considered static
 * @return {@code non-null;} the method prototype
 */
public final Prototype getPrototype(boolean isStatic) {
  if (isStatic) {
    return prototype;
  } else {
    if (instancePrototype == null) {
      Type thisType = getDefiningClass().getClassType();
      instancePrototype = prototype.withFirstParameter(thisType);
    }
    return instancePrototype;
  }
}

/**
 * Interns an instance, adding to the descriptor as necessary based
 * on the given definer, name, and flags. For example, an init
 * method has an uninitialized object of type {@code definer}
 * as its first argument.
 *
 * @param descriptor {@code non-null;} the descriptor string
 * @param definer {@code non-null;} class the method is defined on
 * @param isStatic whether this is a static method
 * @param isInit whether this is an init method
 * @return {@code non-null;} the interned instance
 */
public static Prototype intern(String descriptor, Type definer,
    boolean isStatic, boolean isInit) {
  Prototype base = intern(descriptor);
  if (isStatic) {
    return base;
  }
  if (isInit) {
    definer = definer.asUninitialized(Integer.MAX_VALUE);
  }
  return base.withFirstParameter(definer);
}

/**
 * Interns an instance, adding to the descriptor as necessary based
 * on the given definer, name, and flags. For example, an init
 * method has an uninitialized object of type {@code definer}
 * as its first argument.
 *
 * @param descriptor {@code non-null;} the descriptor string
 * @param definer {@code non-null;} class the method is defined on
 * @param isStatic whether this is a static method
 * @param isInit whether this is an init method
 * @return {@code non-null;} the interned instance
 */
public static Prototype intern(String descriptor, Type definer,
    boolean isStatic, boolean isInit) {
  Prototype base = intern(descriptor);
  if (isStatic) {
    return base;
  }
  if (isInit) {
    definer = definer.asUninitialized(Integer.MAX_VALUE);
  }
  return base.withFirstParameter(definer);
}

/**
 * Interns an instance, adding to the descriptor as necessary based
 * on the given definer, name, and flags. For example, an init
 * method has an uninitialized object of type {@code definer}
 * as its first argument.
 *
 * @param descriptor {@code non-null;} the descriptor string
 * @param definer {@code non-null;} class the method is defined on
 * @param isStatic whether this is a static method
 * @param isInit whether this is an init method
 * @return {@code non-null;} the interned instance
 */
public static Prototype intern(String descriptor, Type definer,
    boolean isStatic, boolean isInit) {
  Prototype base = intern(descriptor);
  if (isStatic) {
    return base;
  }
  if (isInit) {
    definer = definer.asUninitialized(Integer.MAX_VALUE);
  }
  return base.withFirstParameter(definer);
}

/**
 * Interns an instance, adding to the descriptor as necessary based
 * on the given definer, name, and flags. For example, an init
 * method has an uninitialized object of type {@code definer}
 * as its first argument.
 *
 * @param descriptor {@code non-null;} the descriptor string
 * @param definer {@code non-null;} class the method is defined on
 * @param isStatic whether this is a static method
 * @param isInit whether this is an init method
 * @return {@code non-null;} the interned instance
 */
public static Prototype intern(String descriptor, Type definer,
    boolean isStatic, boolean isInit) {
  Prototype base = intern(descriptor);
  if (isStatic) {
    return base;
  }
  if (isInit) {
    definer = definer.asUninitialized(Integer.MAX_VALUE);
  }
  return base.withFirstParameter(definer);
}

Prototype meth = cstMeth.getPrototype();
CstType definer = cstMeth.getDefiningClass();
meth = meth.withFirstParameter(definer.getClassType());
return opInvokeVirtual(meth);
Prototype meth = cstMeth.getPrototype();
CstType definer = cstMeth.getDefiningClass();
meth = meth.withFirstParameter(definer.getClassType());
return opInvokeSuper(meth);
Prototype meth = cstMeth.getPrototype();
CstType definer = cstMeth.getDefiningClass();
meth = meth.withFirstParameter(definer.getClassType());
return opInvokeDirect(meth);
Prototype meth = cstMeth.getPrototype();
CstType definer = cstMeth.getDefiningClass();
meth = meth.withFirstParameter(definer.getClassType());
return opInvokeInterface(meth);
Prototype proto = cstMeth.getPrototype();
CstType definer = cstMeth.getDefiningClass();
Prototype meth = proto.withFirstParameter(definer.getClassType());
return opInvokePolymorphic(meth);

Prototype meth = cstMeth.getPrototype();
CstType definer = cstMeth.getDefiningClass();
meth = meth.withFirstParameter(definer.getClassType());
return opInvokeVirtual(meth);
Prototype meth = cstMeth.getPrototype();
CstType definer = cstMeth.getDefiningClass();
meth = meth.withFirstParameter(definer.getClassType());
return opInvokeSuper(meth);
Prototype meth = cstMeth.getPrototype();
CstType definer = cstMeth.getDefiningClass();
meth = meth.withFirstParameter(definer.getClassType());
return opInvokeDirect(meth);
Prototype meth = cstMeth.getPrototype();
CstType definer = cstMeth.getDefiningClass();
meth = meth.withFirstParameter(definer.getClassType());
return opInvokeInterface(meth);

Prototype meth = cstMeth.getPrototype();
CstType definer = cstMeth.getDefiningClass();
meth = meth.withFirstParameter(definer.getClassType());
return opInvokeVirtual(meth);
Prototype meth = cstMeth.getPrototype();
CstType definer = cstMeth.getDefiningClass();
meth = meth.withFirstParameter(definer.getClassType());
return opInvokeSuper(meth);
Prototype meth = cstMeth.getPrototype();
CstType definer = cstMeth.getDefiningClass();
meth = meth.withFirstParameter(definer.getClassType());
return opInvokeDirect(meth);
Prototype meth = cstMeth.getPrototype();
CstType definer = cstMeth.getDefiningClass();
meth = meth.withFirstParameter(definer.getClassType());
return opInvokeInterface(meth);

Prototype meth = cstMeth.getPrototype();
CstType definer = cstMeth.getDefiningClass();
meth = meth.withFirstParameter(definer.getClassType());
return opInvokeVirtual(meth);
Prototype meth = cstMeth.getPrototype();
CstType definer = cstMeth.getDefiningClass();
meth = meth.withFirstParameter(definer.getClassType());
return opInvokeSuper(meth);
Prototype meth = cstMeth.getPrototype();
CstType definer = cstMeth.getDefiningClass();
meth = meth.withFirstParameter(definer.getClassType());
return opInvokeDirect(meth);
Prototype meth = cstMeth.getPrototype();
CstType definer = cstMeth.getDefiningClass();
meth = meth.withFirstParameter(definer.getClassType());
return opInvokeInterface(meth);

Javadoc

Returns a new interned instance, which is the same as this instance, except that it has an additional parameter prepended to the original's argument list.

Popular methods of Prototype

intern
Interns an instance, adding to the descriptor as necessary based on the given definer, name, and fla
getParameterTypes
Gets the list of parameter types.
getReturnType
Gets the return type.
<init>
Constructs an instance. This is a private constructor; use one of the public static methods to get i
compareTo
getDescriptor
Gets the descriptor string.
getParameterFrameTypes
Gets the list of frame types corresponding to the list of parameter types. The difference between th
makeParameterArray
Helper for #intern which returns an empty array to populate with parsed parameter types, and which a
putIntern
Puts the given instance in the intern table if it's not already there. If a conflicting value is alr
internInts
Interns an instance which consists of the given number of ints along with the given return type
clearInternTable
equals

Popular in Java

Reactive rest calls using spring rest template
setRequestProperty (URLConnection)
getExternalFilesDir (Context)
onRequestPermissionsResult (Fragment)
Container (java.awt)
A generic Abstract Window Toolkit(AWT) container object is a component that can contain other AWT co
RandomAccessFile (java.io)
Allows reading from and writing to a file in a random-access manner. This is different from the uni-
TreeSet (java.util)
TreeSet is an implementation of SortedSet. All optional operations (adding and removing) are support
ExecutorService (java.util.concurrent)
An Executor that provides methods to manage termination and methods that can produce a Future for tr
Handler (java.util.logging)
A Handler object accepts a logging request and exports the desired messages to a target, for example
JCheckBox (javax.swing)
21 Best IntelliJ Plugins

How to use withFirstParametermethodin com.android.dx.rop.type.Prototype

Best Java code snippets using com.android.dx.rop.type.Prototype.withFirstParameter (Showing top 20 results out of 315)

How to use
withFirstParameter
method
in
com.android.dx.rop.type.Prototype