jersey.repackaged.org.objectweb.asm.ClassWriter.getCommonSuperClass java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 OutputStreamWriter o =OutputStream out;new OutputStreamWriter(out)
OutputStream out;String charsetName;new OutputStreamWriter(out, charsetName)
HttpURLConnection connection;new OutputStreamWriter(connection.getOutputStream())
Smart code suggestions by Tabnine
}

/**
 * Returns the index of the common super type of the two given types. This
 * method calls {@link #getCommonSuperClass} and caches the result in the
 * {@link #items} hash table to speedup future calls with the same
 * parameters.
 *
 * @param type1
 *            index of an internal name in {@link #typeTable}.
 * @param type2
 *            index of an internal name in {@link #typeTable}.
 * @return the index of the common super type of the two given types.
 */
int getMergedType(final int type1, final int type2) {
  key2.type = TYPE_MERGED;
  key2.longVal = type1 | (((long) type2) << 32);
  key2.hashCode = 0x7FFFFFFF & (TYPE_MERGED + type1 + type2);
  Item result = get(key2);
  if (result == null) {
    String t = typeTable[type1].strVal1;
    String u = typeTable[type2].strVal1;
    key2.intVal = addType(getCommonSuperClass(t, u));
    result = new Item((short) 0, key2);
    put(result);
  }
  return result.intVal;
}

/**
 * Returns the index of the common super type of the two given types. This
 * method calls {@link #getCommonSuperClass} and caches the result in the
 * {@link #items} hash table to speedup future calls with the same
 * parameters.
 *
 * @param type1
 *            index of an internal name in {@link #typeTable}.
 * @param type2
 *            index of an internal name in {@link #typeTable}.
 * @return the index of the common super type of the two given types.
 */
int getMergedType(final int type1, final int type2) {
  key2.type = TYPE_MERGED;
  key2.longVal = type1 | (((long) type2) << 32);
  key2.hashCode = 0x7FFFFFFF & (TYPE_MERGED + type1 + type2);
  Item result = get(key2);
  if (result == null) {
    String t = typeTable[type1].strVal1;
    String u = typeTable[type2].strVal1;
    key2.intVal = addType(getCommonSuperClass(t, u));
    result = new Item((short) 0, key2);
    put(result);
  }
  return result.intVal;
}

/**
 * Returns the index of the common super type of the two given types. This
 * method calls {@link #getCommonSuperClass} and caches the result in the
 * {@link #items} hash table to speedup future calls with the same
 * parameters.
 *
 * @param type1
 *            index of an internal name in {@link #typeTable}.
 * @param type2
 *            index of an internal name in {@link #typeTable}.
 * @return the index of the common super type of the two given types.
 */
int getMergedType(final int type1, final int type2) {
  key2.type = TYPE_MERGED;
  key2.longVal = type1 | (((long) type2) << 32);
  key2.hashCode = 0x7FFFFFFF & (TYPE_MERGED + type1 + type2);
  Item result = get(key2);
  if (result == null) {
    String t = typeTable[type1].strVal1;
    String u = typeTable[type2].strVal1;
    key2.intVal = addType(getCommonSuperClass(t, u));
    result = new Item((short) 0, key2);
    put(result);
  }
  return result.intVal;
}

/**
 * Returns the index of the common super type of the two given types. This
 * method calls {@link #getCommonSuperClass} and caches the result in the
 * {@link #items} hash table to speedup future calls with the same
 * parameters.
 *
 * @param type1
 *            index of an internal name in {@link #typeTable}.
 * @param type2
 *            index of an internal name in {@link #typeTable}.
 * @return the index of the common super type of the two given types.
 */
int getMergedType(final int type1, final int type2) {
  key2.type = TYPE_MERGED;
  key2.longVal = type1 | (((long) type2) << 32);
  key2.hashCode = 0x7FFFFFFF & (TYPE_MERGED + type1 + type2);
  Item result = get(key2);
  if (result == null) {
    String t = typeTable[type1].strVal1;
    String u = typeTable[type2].strVal1;
    key2.intVal = addType(getCommonSuperClass(t, u));
    result = new Item((short) 0, key2);
    put(result);
  }
  return result.intVal;
}

/**
 * Returns the index of the common super type of the two given types. This
 * method calls {@link #getCommonSuperClass} and caches the result in the
 * {@link #items} hash table to speedup future calls with the same
 * parameters.
 *
 * @param type1
 *            index of an internal name in {@link #typeTable}.
 * @param type2
 *            index of an internal name in {@link #typeTable}.
 * @return the index of the common super type of the two given types.
 */
int getMergedType(final int type1, final int type2) {
  key2.type = TYPE_MERGED;
  key2.longVal = type1 | (((long) type2) << 32);
  key2.hashCode = 0x7FFFFFFF & (TYPE_MERGED + type1 + type2);
  Item result = get(key2);
  if (result == null) {
    String t = typeTable[type1].strVal1;
    String u = typeTable[type2].strVal1;
    key2.intVal = addType(getCommonSuperClass(t, u));
    result = new Item((short) 0, key2);
    put(result);
  }
  return result.intVal;
}

/**
 * Returns the index of the common super type of the two given types. This
 * method calls {@link #getCommonSuperClass} and caches the result in the
 * {@link #items} hash table to speedup future calls with the same
 * parameters.
 *
 * @param type1
 *            index of an internal name in {@link #typeTable}.
 * @param type2
 *            index of an internal name in {@link #typeTable}.
 * @return the index of the common super type of the two given types.
 */
int getMergedType(final int type1, final int type2) {
  key2.type = TYPE_MERGED;
  key2.longVal = type1 | (((long) type2) << 32);
  key2.hashCode = 0x7FFFFFFF & (TYPE_MERGED + type1 + type2);
  Item result = get(key2);
  if (result == null) {
    String t = typeTable[type1].strVal1;
    String u = typeTable[type2].strVal1;
    key2.intVal = addType(getCommonSuperClass(t, u));
    result = new Item((short) 0, key2);
    put(result);
  }
  return result.intVal;
}

/**
 * Returns the index of the common super type of the two given types. This
 * method calls {@link #getCommonSuperClass} and caches the result in the
 * {@link #items} hash table to speedup future calls with the same
 * parameters.
 *
 * @param type1
 *            index of an internal name in {@link #typeTable}.
 * @param type2
 *            index of an internal name in {@link #typeTable}.
 * @return the index of the common super type of the two given types.
 */
int getMergedType(final int type1, final int type2) {
  key2.type = TYPE_MERGED;
  key2.longVal = type1 | (((long) type2) << 32);
  key2.hashCode = 0x7FFFFFFF & (TYPE_MERGED + type1 + type2);
  Item result = get(key2);
  if (result == null) {
    String t = typeTable[type1].strVal1;
    String u = typeTable[type2].strVal1;
    key2.intVal = addType(getCommonSuperClass(t, u));
    result = new Item((short) 0, key2);
    put(result);
  }
  return result.intVal;
}

Javadoc

Returns the common super type of the two given types. The default implementation of this method loads the two given classes and uses the java.lang.Class methods to find the common super class. It can be overridden to compute this common super type in other ways, in particular without actually loading any class, or to take into account the class that is currently being generated by this ClassWriter, which can of course not be loaded since it is under construction.

Popular methods of ClassWriter

toByteArray
Returns the bytecode of the class that was build with this class writer.
addType
Adds the given Item to #typeTable.
addUninitializedType
Adds the given "uninitialized" type to #typeTable and returns its index. This method is used for UNI
get
Returns the constant pool's hash table item which is equal to the given item.
getMergedType
Returns the index of the common super type of the two given types. This method calls #getCommonSuper
newClass
Adds a class reference to the constant pool of the class being build. Does nothing if the constant p
newClassItem
Adds a class reference to the constant pool of the class being build. Does nothing if the constant p
newConst
Adds a number or string constant to the constant pool of the class being build. Does nothing if the
newConstItem
Adds a number or string constant to the constant pool of the class being build. Does nothing if the
newDouble
Adds a double to the constant pool of the class being build. Does nothing if the constant pool alrea
newField
Adds a field reference to the constant pool of the class being build. Does nothing if the constant p
newFieldItem
Adds a field reference to the constant pool of the class being build. Does nothing if the constant p

Popular in Java

Making http requests using okhttp
getContentResolver (Context)
putExtra (Intent)
getSupportFragmentManager (FragmentActivity)
FileInputStream (java.io)
An input stream that reads bytes from a file. File file = ...finally if (in != null) in.clos
IOException (java.io)
Signals a general, I/O-related error. Error details may be specified when calling the constructor, a
URLEncoder (java.net)
This class is used to encode a string using the format required by application/x-www-form-urlencoded
Path (java.nio.file)
ResultSet (java.sql)
An interface for an object which represents a database table entry, returned as the result of the qu
FileUtils (org.apache.commons.io)
General file manipulation utilities. Facilities are provided in the following areas: * writing to a
Top 17 PhpStorm Plugins

How to use getCommonSuperClassmethodin jersey.repackaged.org.objectweb.asm.ClassWriter

Best Java code snippets using jersey.repackaged.org.objectweb.asm.ClassWriter.getCommonSuperClass (Showing top 7 results out of 315)

How to use
getCommonSuperClass
method
in
jersey.repackaged.org.objectweb.asm.ClassWriter