com.android.dx.rop.type.Prototype.intern 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 Codota
}

Prototype prototype(boolean includeThis) {
  return Prototype.intern(descriptor(includeThis));
}

private void addDependencies(DirectClassFile classFile) {
  for (Constant constant : classFile.getConstantPool().getEntries()) {
    if (constant instanceof CstType) {
      checkDescriptor(((CstType) constant).getClassType().getDescriptor());
    } else if (constant instanceof CstFieldRef) {
      checkDescriptor(((CstFieldRef) constant).getType().getDescriptor());
    } else if (constant instanceof CstBaseMethodRef) {
      checkPrototype(((CstBaseMethodRef) constant).getPrototype());
    }
  }
  FieldList fields = classFile.getFields();
  int nbField = fields.size();
  for (int i = 0; i < nbField; i++) {
   checkDescriptor(fields.get(i).getDescriptor().getString());
  }
  MethodList methods = classFile.getMethods();
  int nbMethods = methods.size();
  for (int i = 0; i < nbMethods; i++) {
   checkPrototype(Prototype.intern(methods.get(i).getDescriptor().getString()));
  }
}
private void checkPrototype(Prototype proto) {

Prototype prototype(boolean includeThis) {
  return Prototype.intern(descriptor(includeThis));
}

Prototype prototype(boolean includeThis) {
  return Prototype.intern(descriptor(includeThis));
}

Prototype prototype(boolean includeThis) {
  return Prototype.intern(descriptor(includeThis));
}

/**
 * Interns an instance which consists of the given number of
 * {@code int}s along with the given return type
 *
 * @param returnType {@code non-null;} the return type
 * @param count {@code > 0;} the number of elements in the prototype
 * @return {@code non-null;} the interned instance
 */
public static Prototype internInts(Type returnType, int count) {
  // Make the descriptor...
  StringBuffer sb = new StringBuffer(100);
  sb.append('(');
  for (int i = 0; i < count; i++) {
    sb.append('I');
  }
  sb.append(')');
  sb.append(returnType.getDescriptor());
  // ...and intern it.
  return intern(sb.toString());
}

/**
 * Interns an instance which consists of the given number of
 * {@code int}s along with the given return type
 *
 * @param returnType {@code non-null;} the return type
 * @param count {@code > 0;} the number of elements in the prototype
 * @return {@code non-null;} the interned instance
 */
public static Prototype internInts(Type returnType, int count) {
  // Make the descriptor...
  StringBuffer sb = new StringBuffer(100);
  sb.append('(');
  for (int i = 0; i < count; i++) {
    sb.append('I');
  }
  sb.append(')');
  sb.append(returnType.getDescriptor());
  // ...and intern it.
  return intern(sb.toString());
}

/**
 * Interns an instance which consists of the given number of
 * {@code int}s along with the given return type
 *
 * @param returnType {@code non-null;} the return type
 * @param count {@code > 0;} the number of elements in the prototype
 * @return {@code non-null;} the interned instance
 */
public static Prototype internInts(Type returnType, int count) {
  // Make the descriptor...
  StringBuffer sb = new StringBuffer(100);
  sb.append('(');
  for (int i = 0; i < count; i++) {
    sb.append('I');
  }
  sb.append(')');
  sb.append(returnType.getDescriptor());
  // ...and intern it.
  return intern(sb.toString());
}

/**
 * Constructs an instance.
 *
 * @param definingClass {@code non-null;} the type of the defining class
 * @param nat {@code non-null;} the name-and-type
 */
/*package*/ CstBaseMethodRef(CstType definingClass, CstNat nat) {
  super(definingClass, nat);
  String descriptor = getNat().getDescriptor().getString();
  this.prototype = Prototype.intern(descriptor);
  this.instancePrototype = null;
}

/**
 * Constructs an instance.
 *
 * @param definingClass {@code non-null;} the type of the defining class
 * @param nat {@code non-null;} the name-and-type
 */
/*package*/ CstBaseMethodRef(CstType definingClass, CstNat nat) {
  super(definingClass, nat);
  String descriptor = getNat().getDescriptor().getString();
  this.prototype = Prototype.intern(descriptor);
  this.instancePrototype = null;
}

/**
 * Constructs an instance.
 *
 * @param definingClass {@code non-null;} the type of the defining class
 * @param nat {@code non-null;} the name-and-type
 */
/*package*/ CstBaseMethodRef(CstType definingClass, CstNat nat) {
  super(definingClass, nat);
  String descriptor = getNat().getDescriptor().getString();
  this.prototype = Prototype.intern(descriptor);
  this.instancePrototype = null;
}

/**
 * Constructs an instance.
 *
 * @param definingClass {@code non-null;} the type of the defining class
 * @param nat {@code non-null;} the name-and-type
 */
/*package*/ CstBaseMethodRef(CstType definingClass, CstNat nat) {
  super(definingClass, nat);
  String descriptor = getNat().getDescriptor().getString();
  this.prototype = Prototype.intern(descriptor);
  this.instancePrototype = null;
}

/**
 * Constructs an instance.
 *
 * @param definingClass {@code non-null;} the type of the defining class
 * @param nat {@code non-null;} the name-and-type
 */
/*package*/ CstBaseMethodRef(CstType definingClass, CstNat nat) {
  super(definingClass, nat);
  String descriptor = getNat().getDescriptor().getString();
  this.prototype = Prototype.intern(descriptor);
  this.instancePrototype = null;
}

/**
 * Constructs an instance.
 *
 * @param definingClass {@code non-null;} the type of the defining class
 * @param nat {@code non-null;} the name-and-type
 */
/*package*/ CstBaseMethodRef(CstType definingClass, CstNat nat) {
  super(definingClass, nat);
  String descriptor = getNat().getDescriptor().getString();
  this.prototype = Prototype.intern(descriptor);
  this.instancePrototype = null;
}

/**
 * Constructs an instance.
 *
 * @param definingClass {@code non-null;} the defining class
 * @param accessFlags access flags
 * @param nat {@code non-null;} member name and type (descriptor)
 * @param attributes {@code non-null;} list of associated attributes
 */
public StdMethod(CstType definingClass, int accessFlags, CstNat nat,
    AttributeList attributes) {
  super(definingClass, accessFlags, nat, attributes);
  String descStr = getDescriptor().getString();
  effectiveDescriptor =
    Prototype.intern(descStr, definingClass.getClassType(),
                AccessFlags.isStatic(accessFlags),
                nat.isInstanceInit());
}

/**
 * Constructs an instance.
 *
 * @param definingClass {@code non-null;} the defining class
 * @param accessFlags access flags
 * @param nat {@code non-null;} member name and type (descriptor)
 * @param attributes {@code non-null;} list of associated attributes
 */
public StdMethod(CstType definingClass, int accessFlags, CstNat nat,
    AttributeList attributes) {
  super(definingClass, accessFlags, nat, attributes);
  String descStr = getDescriptor().getString();
  effectiveDescriptor =
    Prototype.intern(descStr, definingClass.getClassType(),
                AccessFlags.isStatic(accessFlags),
                nat.isInstanceInit());
}

/**
 * Constructs an instance.
 *
 * @param definingClass {@code non-null;} the defining class
 * @param accessFlags access flags
 * @param nat {@code non-null;} member name and type (descriptor)
 * @param attributes {@code non-null;} list of associated attributes
 */
public StdMethod(CstType definingClass, int accessFlags, CstNat nat,
    AttributeList attributes) {
  super(definingClass, accessFlags, nat, attributes);
  String descStr = getDescriptor().getString();
  effectiveDescriptor =
    Prototype.intern(descStr, definingClass.getClassType(),
                AccessFlags.isStatic(accessFlags),
                nat.isInstanceInit());
}

/**
 * Constructs an instance.
 *
 * @param definingClass {@code non-null;} the defining class
 * @param accessFlags access flags
 * @param nat {@code non-null;} member name and type (descriptor)
 * @param attributes {@code non-null;} list of associated attributes
 */
public StdMethod(CstType definingClass, int accessFlags, CstNat nat,
    AttributeList attributes) {
  super(definingClass, accessFlags, nat, attributes);
  String descStr = getDescriptor().getString();
  effectiveDescriptor =
    Prototype.intern(descStr, definingClass.getClassType(),
                AccessFlags.isStatic(accessFlags),
                nat.isInstanceInit());
}

/**
 * Constructs an instance.
 *
 * @param definingClass {@code non-null;} the defining class
 * @param accessFlags access flags
 * @param nat {@code non-null;} member name and type (descriptor)
 * @param attributes {@code non-null;} list of associated attributes
 */
public StdMethod(CstType definingClass, int accessFlags, CstNat nat,
    AttributeList attributes) {
  super(definingClass, accessFlags, nat, attributes);
  String descStr = getDescriptor().getString();
  effectiveDescriptor =
    Prototype.intern(descStr, definingClass.getClassType(),
                AccessFlags.isStatic(accessFlags),
                nat.isInstanceInit());
}

/**
 * Constructs an instance.
 * 
 * @param definingClass {@code non-null;} the defining class
 * @param accessFlags access flags
 * @param nat {@code non-null;} member name and type (descriptor)
 * @param attributes {@code non-null;} list of associated attributes
 */
public StdMethod(CstType definingClass, int accessFlags, CstNat nat,
    AttributeList attributes) {
  super(definingClass, accessFlags, nat, attributes);
  String descStr = getDescriptor().getString();
  effectiveDescriptor =
    Prototype.intern(descStr, definingClass.getClassType(),
                AccessFlags.isStatic(accessFlags),
                nat.isInstanceInit());
}

Javadoc

Returns the unique instance corresponding to the given method descriptor. See vmspec-2 sec4.3.3 for details on the field descriptor syntax.

Popular methods of Prototype

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
withFirstParameter
Returns a new interned instance, which is the same as this instance, except that it has an additiona
internInts
Interns an instance which consists of the given number of ints along with the given return type
clearInternTable
equals

Popular in Java

Reading from database using SQL prepared statement
setContentView (Activity)
startActivity (Activity)
onRequestPermissionsResult (Fragment)
ObjectMapper (com.fasterxml.jackson.databind)
This mapper (or, data binder, or codec) provides functionality for converting between Java objects (
Runnable (java.lang)
Represents a command that can be executed. Often used to run code in a different Thread.
Thread (java.lang)
A thread is a thread of execution in a program. The Java Virtual Machine allows an application to ha
LinkedHashMap (java.util)
Hash table and linked list implementation of the Map interface, with predictable iteration order. Th
LinkedList (java.util)
Doubly-linked list implementation of the List and Dequeinterfaces. Implements all optional list oper
UUID (java.util)
UUID is an immutable representation of a 128-bit universally unique identifier (UUID). There are mul

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

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

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