libcore.reflect.GenericSignatureParser.expect java code examples

Common ways to obtain GenericSignatureParser

private void myMethod () {
 GenericSignatureParser g =Class klass;new GenericSignatureParser(klass.getClassLoader())
Method method;new GenericSignatureParser(method.getDeclaringClass().getClassLoader())
Constructor function Object() { [native code] };new GenericSignatureParser(function Object() { [native code] }.getDeclaringClass().getClassLoader())
Smart code suggestions by Tabnine
}

TypeVariableImpl<GenericDeclaration> parseTypeVariableSignature() {
  // TypeVariableSignature ::= "T" Ident ";".
  expect('T');
  scanIdentifier();
  expect(';');
  // Reference to type variable:
  // Note: we don't know the declaring GenericDeclaration yet.
  return new TypeVariableImpl<GenericDeclaration>(genericDecl, identifier);
}

Type parseClassTypeSignature() {
  // ClassTypeSignature ::= "L" {Ident "/"} Ident
  //         OptTypeArguments {"." Ident OptTypeArguments} ";".
  expect('L');
  StringBuilder qualIdent = new StringBuilder();
  scanIdentifier();
  while (symbol == '/') {
    scanSymbol();
    qualIdent.append(identifier).append(".");
    scanIdentifier();
  }
  qualIdent.append(this.identifier);
  ListOfTypes typeArgs = parseOptTypeArguments();
  ParameterizedTypeImpl parentType =
      new ParameterizedTypeImpl(null, qualIdent.toString(), typeArgs, loader);
  ParameterizedTypeImpl type = parentType;
  while (symbol == '.') {
    // Deal with Member Classes:
    scanSymbol();
    scanIdentifier();
    qualIdent.append("$").append(identifier); // FIXME: is "$" correct?
    typeArgs = parseOptTypeArguments();
    type = new ParameterizedTypeImpl(parentType, qualIdent.toString(), typeArgs,
        loader);
  }
  expect(';');
  return type;
}

ListOfTypes parseOptTypeArguments() {
  // OptTypeArguments ::= "<" TypeArgument {TypeArgument} ">".
  ListOfTypes typeArgs = new ListOfTypes(8);
  if (symbol == '<') {
    scanSymbol();
    typeArgs.add(parseTypeArgument());
    while ((symbol != '>') && (symbol > 0)) {
      typeArgs.add(parseTypeArgument());
    }
    expect('>');
  }
  return typeArgs;
}

TypeVariableImpl<GenericDeclaration> parseFormalTypeParameter() {
  // FormalTypeParameter ::= Ident ClassBound {InterfaceBound}.
  scanIdentifier();
  String name = identifier.intern(); // FIXME: is this o.k.?
  ListOfTypes bounds = new ListOfTypes(8);
  // ClassBound ::= ":" [FieldTypeSignature].
  expect(':');
  if (symbol == 'L' || symbol == '[' || symbol == 'T') {
    bounds.add(parseFieldTypeSignature());
  }
  while (symbol == ':') {
    // InterfaceBound ::= ":" FieldTypeSignature.
    scanSymbol();
    bounds.add(parseFieldTypeSignature());
  }
  return new TypeVariableImpl<GenericDeclaration>(genericDecl, name, bounds);
}

void parseOptFormalTypeParameters() {
  // OptFormalTypeParameters ::=
  // ["<" FormalTypeParameter {FormalTypeParameter} ">"].
  ListOfVariables typeParams = new ListOfVariables();
  if (symbol == '<') {
    scanSymbol();
    typeParams.add(parseFormalTypeParameter());
    while ((symbol != '>') && (symbol > 0)) {
      typeParams.add(parseFormalTypeParameter());
    }
    expect('>');
  }
  this.formalTypeParameters = typeParams.getArray();
}

expect('(');
while (symbol != ')' && (symbol > 0)) {
  parameterTypes.add(parseTypeSignature());
expect(')');

TypeVariableImpl<GenericDeclaration> parseTypeVariableSignature() {
  // TypeVariableSignature ::= "T" Ident ";".
  expect('T');
  scanIdentifier();
  expect(';');
  // Reference to type variable:
  // Note: we don't know the declaring GenericDeclaration yet.
  return new TypeVariableImpl<GenericDeclaration>(genericDecl, identifier);
}

TypeVariableImpl<GenericDeclaration> parseTypeVariableSignature() {
  // TypeVariableSignature ::= "T" Ident ";".
  expect('T');
  scanIdentifier();
  expect(';');
  // Reference to type variable:
  // Note: we don't know the declaring GenericDeclaration yet.
  return new TypeVariableImpl<GenericDeclaration>(genericDecl, identifier);
}

TypeVariableImpl<GenericDeclaration> parseTypeVariableSignature() {
  // TypeVariableSignature ::= "T" Ident ";".
  expect('T');
  scanIdentifier();
  expect(';');
  // Reference to type variable:
  // Note: we don't know the declaring GenericDeclaration yet.
  return new TypeVariableImpl<GenericDeclaration>(genericDecl, identifier);
}

TypeVariableImpl<GenericDeclaration> parseTypeVariableSignature() {
  // TypeVariableSignature ::= "T" Ident ";".
  expect('T');
  scanIdentifier();
  expect(';');
  // Reference to type variable:
  // Note: we don't know the declaring GenericDeclaration yet.
  return new TypeVariableImpl<GenericDeclaration>(genericDecl, identifier);
}

TypeVariableImpl<GenericDeclaration> parseTypeVariableSignature() {
  // TypeVariableSignature ::= "T" Ident ";".
  expect('T');
  scanIdentifier();
  expect(';');
  // Reference to type variable:
  // Note: we don't know the declaring GenericDeclaration yet.
  return new TypeVariableImpl<GenericDeclaration>(genericDecl, identifier);
}

TypeVariableImpl<GenericDeclaration> parseTypeVariableSignature() {
  // TypeVariableSignature ::= "T" Ident ";".
  expect('T');
  scanIdentifier();
  expect(';');
  // Reference to type variable:
  // Note: we don't know the declaring GenericDeclaration yet.
  return new TypeVariableImpl<GenericDeclaration>(genericDecl, identifier);
}

ListOfTypes parseOptTypeArguments() {
  // OptTypeArguments ::= "<" TypeArgument {TypeArgument} ">".
  ListOfTypes typeArgs = new ListOfTypes(8);
  if (symbol == '<') {
    scanSymbol();
    typeArgs.add(parseTypeArgument());
    while ((symbol != '>') && (symbol > 0)) {
      typeArgs.add(parseTypeArgument());
    }
    expect('>');
  }
  return typeArgs;
}

ListOfTypes parseOptTypeArguments() {
  // OptTypeArguments ::= "<" TypeArgument {TypeArgument} ">".
  ListOfTypes typeArgs = new ListOfTypes(8);
  if (symbol == '<') {
    scanSymbol();
    typeArgs.add(parseTypeArgument());
    while ((symbol != '>') && (symbol > 0)) {
      typeArgs.add(parseTypeArgument());
    }
    expect('>');
  }
  return typeArgs;
}

ListOfTypes parseOptTypeArguments() {
  // OptTypeArguments ::= "<" TypeArgument {TypeArgument} ">".
  ListOfTypes typeArgs = new ListOfTypes(8);
  if (symbol == '<') {
    scanSymbol();
    typeArgs.add(parseTypeArgument());
    while ((symbol != '>') && (symbol > 0)) {
      typeArgs.add(parseTypeArgument());
    }
    expect('>');
  }
  return typeArgs;
}

ListOfTypes parseOptTypeArguments() {
  // OptTypeArguments ::= "<" TypeArgument {TypeArgument} ">".
  ListOfTypes typeArgs = new ListOfTypes(8);
  if (symbol == '<') {
    scanSymbol();
    typeArgs.add(parseTypeArgument());
    while ((symbol != '>') && (symbol > 0)) {
      typeArgs.add(parseTypeArgument());
    }
    expect('>');
  }
  return typeArgs;
}

ListOfTypes parseOptTypeArguments() {
  // OptTypeArguments ::= "<" TypeArgument {TypeArgument} ">".
  ListOfTypes typeArgs = new ListOfTypes(8);
  if (symbol == '<') {
    scanSymbol();
    typeArgs.add(parseTypeArgument());
    while ((symbol != '>') && (symbol > 0)) {
      typeArgs.add(parseTypeArgument());
    }
    expect('>');
  }
  return typeArgs;
}

ListOfTypes parseOptTypeArguments() {
  // OptTypeArguments ::= "<" TypeArgument {TypeArgument} ">".
  ListOfTypes typeArgs = new ListOfTypes(8);
  if (symbol == '<') {
    scanSymbol();
    typeArgs.add(parseTypeArgument());
    while ((symbol != '>') && (symbol > 0)) {
      typeArgs.add(parseTypeArgument());
    }
    expect('>');
  }
  return typeArgs;
}

void parseOptFormalTypeParameters() {
  // OptFormalTypeParameters ::=
  // ["<" FormalTypeParameter {FormalTypeParameter} ">"].
  ListOfVariables typeParams = new ListOfVariables();
  if (symbol == '<') {
    scanSymbol();
    typeParams.add(parseFormalTypeParameter());
    while ((symbol != '>') && (symbol > 0)) {
      typeParams.add(parseFormalTypeParameter());
    }
    expect('>');
  }
  this.formalTypeParameters = typeParams.getArray();
}

void parseOptFormalTypeParameters() {
  // OptFormalTypeParameters ::=
  // ["<" FormalTypeParameter {FormalTypeParameter} ">"].
  ListOfVariables typeParams = new ListOfVariables();
  if (symbol == '<') {
    scanSymbol();
    typeParams.add(parseFormalTypeParameter());
    while ((symbol != '>') && (symbol > 0)) {
      typeParams.add(parseFormalTypeParameter());
    }
    expect('>');
  }
  this.formalTypeParameters = typeParams.getArray();
}

Popular methods of GenericSignatureParser

<init>
isStopSymbol
parseClassSignature
parseClassTypeSignature
parseFieldTypeSignature
parseForClass
Parses the generic signature of a class and creates the data structure representing the signature.
parseForConstructor
Parses the generic signature of a constructor and creates the data structure representing the signat
parseForField
Parses the generic signature of a field and creates the data structure representing the signature.
parseForMethod
Parses the generic signature of a method and creates the data structure representing the signature.
parseFormalTypeParameter
parseMethodTypeSignature
parseOptFormalTypeParameters

Popular in Java

Reactive rest calls using spring rest template
onRequestPermissionsResult (Fragment)
getSupportFragmentManager (FragmentActivity)
getExternalFilesDir (Context)
ObjectMapper (com.fasterxml.jackson.databind)
ObjectMapper provides functionality for reading and writing JSON, either to and from basic POJOs (Pl
BigInteger (java.math)
An immutable arbitrary-precision signed integer.FAST CRYPTOGRAPHY This implementation is efficient f
Time (java.sql)
Java representation of an SQL TIME value. Provides utilities to format and parse the time's represen
Executor (java.util.concurrent)
An object that executes submitted Runnable tasks. This interface provides a way of decoupling task s
ThreadPoolExecutor (java.util.concurrent)
An ExecutorService that executes each submitted task using one of possibly several pooled threads, n
IsNull (org.hamcrest.core)
Is the value null?
Sublime Text for Python

How to use expectmethodin libcore.reflect.GenericSignatureParser

Best Java code snippets using libcore.reflect.GenericSignatureParser.expect (Showing top 20 results out of 315)

How to use
expect
method
in
libcore.reflect.GenericSignatureParser