Uses of Class

Packages that use Class JML Specifications for the corresponding types in the Java Developement Kit (JDK). 
java.lang JML Specifications for the corresponding types in the Java Developement Kit (JDK). 
java.lang.reflect JML Specifications for the corresponding types in the Java Developement Kit (JDK). JML Specifications for the corresponding types in the Java Developement Kit (JDK). JML Specifications for the corresponding types in the Java Developement Kit (JDK). 
org.jmlspecs.jmlrac.runtime Classes for use during runtime assertion checking for code compiled with JML's runtime assertion checking compiler (jmlc). 
org.jmlspecs.jmlspec A tool that can generate or compare specification skeletons from Java source or class files. 
org.multijava.mjc Implements mjc, a MultiJava compiler. 
org.multijava.util.testing Provides JUnit testing utilities for all of the parts of MultiJava and the Java Modeling Language

Uses of Class in

Methods in that return Class
private  Class ObjectInputStream.readClass(boolean)
protected  Class ObjectInputStream.resolveClass(ObjectStreamClass)
protected  Class ObjectInputStream.resolveProxyClass(String[])

Methods in with parameters of type Class
private static boolean ObjectInputStream.auditSubclass(Class)

Uses of Class in java.lang

Fields in java.lang declared as Class
static Class Byte.TYPE
static Class Short.TYPE
static Class Integer.TYPE
static Class Double.TYPE
static Class Float.TYPE
static Class Long.TYPE
static Class Character.TYPE
static Class Boolean.TYPE

Methods in java.lang that return Class
 Class Object.getClass()
static Class Class.forName(String className)
static Class Class.forName(String name, boolean initialize, ClassLoader loader)
 Class Class.getSuperclass()
 Class[] Class.getInterfaces()
 Class Class.getComponentType()
 Class Class.getDeclaringClass()
 Class[] Class.getClasses()
 Class[] Class.getDeclaredClasses()
(package private) static Class Class.getPrimitiveClass(String name)
protected  Class ClassLoader.defineClass(byte[], int, int)
private  Class ClassLoader.findBootstrapClass(String)
private  Class ClassLoader.findBootstrapClass0(String)
protected  Class ClassLoader.findClass(String)
protected  Class ClassLoader.findLoadedClass(String)
private  Class ClassLoader.findLoadedClass0(String)
protected  Class ClassLoader.findSystemClass(String)
 Class ClassLoader.loadClass(String)
private  Class ClassLoader.loadClassInternal(String)
protected  Class ClassLoader.loadClass(String, boolean)
protected  Class ClassLoader.defineClass(String, byte[], int, int)
protected  Class ClassLoader.defineClass(String, byte[], int, int, ProtectionDomain)
private  Class ClassLoader.defineClass0(String, byte[], int, int, ProtectionDomain)
protected  Class[] SecurityManager.getClassContext()
protected  Class SecurityManager.currentLoadedClass()
(package private) static Class System.getCallerClass()

Methods in java.lang with parameters of type Class
 boolean Class.isAssignableFrom(Class cls)
 Method Class.getMethod(String name, Class[] parameterTypes)
 Constructor Class.getConstructor(Class[] parameterTypes)
 Method Class.getDeclaredMethod(String name, Class[] parameterTypes)
 Constructor Class.getDeclaredConstructor(Class[] parameterTypes)
(package private)  void ClassLoader.addClass(Class)
protected  void ClassLoader.resolveClass(Class)
private  void ClassLoader.resolveClass0(Class)
private static boolean ClassLoader.loadLibrary0(Class, File)
protected  void ClassLoader.setSigners(Class, Object[])
(package private) static void ClassLoader.loadLibrary(Class, String, boolean)
private  void ClassLoader.checkPackageAccess(Class, ProtectionDomain)
(package private) static Package Package.getPackage(Class c)
 void SecurityManager.checkMemberAccess(Class clazz, int which)

Uses of Class in java.lang.reflect

Fields in java.lang.reflect declared as Class
(package private)  Class AccessibleObject.securityCheckCache

Methods in java.lang.reflect that return Class
 Class Method.getDeclaringClass()
 Class Method.getReturnType()
 Class[] Method.getParameterTypes()
 Class[] Method.getExceptionTypes()
(package private) static Class[] Method.copy(Class[] in)
abstract  Class Member.getDeclaringClass()
 Class Field.getDeclaringClass()
 Class Field.getType()
 Class Constructor.getDeclaringClass()
 Class[] Constructor.getParameterTypes()
 Class[] Constructor.getExceptionTypes()

Methods in java.lang.reflect with parameters of type Class
(package private) static Class[] Method.copy(Class[] in)
(package private) static String Field.getTypeName(Class type)
static Object Array.newInstance(Class Param0, int Param1)
static Object Array.newInstance(Class Param0, int[] Param1)

Constructors in java.lang.reflect with parameters of type Class
Method(Class declaringClass, String name, Class[] parameterTypes, Class returnType, Class[] checkedExceptions, int modifiers, int slot)
Field(Class declaringClass, String name, Class type, int modifiers, int slot)
Constructor(Class declaringClass, Class[] parameterTypes, Class[] checkedExceptions, int modifiers, int slot)

Uses of Class in

Methods in with parameters of type Class
 Object URL.getContent(Class[] classes)
 Object URLConnection.getContent(Class[])

Uses of Class in

Methods in with parameters of type Class
 AlgorithmParameterSpec AlgorithmParameters.getParameterSpec(Class)

Uses of Class in javax.crypto

Methods in javax.crypto with parameters of type Class
 KeySpec SecretKeyFactory.getKeySpec(SecretKey key, Class keySpec)
protected abstract  KeySpec SecretKeyFactorySpi.engineGetKeySpec(SecretKey, Class)

Uses of Class in org.jmlspecs.jmlrac.runtime

Fields in org.jmlspecs.jmlrac.runtime declared as Class
(package private)  Class JMLSurrogate.MapKey.clazz
(package private)  Class[] JMLSurrogate.MapKey.types

Methods in org.jmlspecs.jmlrac.runtime that return Class
private static Class JMLChecker.getRacClass(Class clazz)
          Returns the runtime assertion checker class of the given class, clazz.

Methods in org.jmlspecs.jmlrac.runtime with parameters of type Class
static boolean JMLChecker.isRACCompiled(Class clazz)
          Returns true only if the given class, clazz, is compiled with runtime assertion check code.
static void JMLChecker.setLevel(Class clazz, int l)
          Sets the runtime assertion check level of the class, clazz, to the level, l.
private static Class JMLChecker.getRacClass(Class clazz)
          Returns the runtime assertion checker class of the given class, clazz.
static boolean JMLChecker.inheritedFrom(Class clazz, String name, Class[] params)
          Returns true if a method named name with the formal parameter types, params, can be inherited from the type, class, or its supertypes.
static int JMLChecker.getLevel(Class clazz)
          Returns the current runtime assertion check level of the given class, clazz.
static Object JMLChecker.getSurrogate(String name, Class clazz, Object thisObj)
          Returns a surrogate object, an instance of the given surrogate class clazz, that is suitable for statically calling JML access methods on the object thisObj.
protected static Object JMLSurrogate.getReceiver(Class clazz, Object thisObj)
          Returns the receiver object for dynamic calls to methods of the class clazz from the object thisObj.
static Method JMLSurrogate.getMethod(Class clazz, String name, Class[] types)
          Returns a method object that reflects the specified public member method of the class or interface, clazz.
static Method JMLSurrogate.getAccessor(Class clazz, String name)
          Returns the accessor (getter) method of a ghost field or a model field, name, declared in the type, clazz.
static Method JMLSurrogate.getSetter(Class clazz, String name, Class type)
          Returns the setter method of the ghost field, name, of type type, declared in class, clazz.
static JMLSurrogate.MapKey JMLSurrogate.MapKey.create(Class clazz, String name, Class[] types)
          Returns a new key for a method named name with formal parameter types, types, declared in the class, clazz.
static boolean JMLRacUtil.matchCause(Class c, JMLAssertionError e)
static boolean JMLRacUtil.checkErr(Class c, JMLAssertionError e)
          Under the old semantics, ensure that e is an instance of c.

Constructors in org.jmlspecs.jmlrac.runtime with parameters of type Class
JMLSurrogate.MapKey(Class clazz, String name, Class[] types)
          Constructs a new key for a method named name with formal parameter types, types, declared in the class, clazz.

Uses of Class in org.jmlspecs.jmlspec

Methods in org.jmlspecs.jmlspec with parameters of type Class
 String JspComparator.compareTypes(JTypeDeclarationType[] types, Class[] jtypes, String filename, String jfilename)
 String JspComparator.compareType(JTypeDeclarationType ty, Class cc, String filename, String jfilename)
 String JspComparator.compareMethods(JMethodDeclarationType[] methods, Member[] jmethods, String filename, String jfilename, long modsToignore, Class cc)
 boolean JspComparator.checkInheritance(JMethodDeclarationType m, Class cc)
 String JspComparator.compareExceptions(CClassType[] exc, Class[] jexc, String method, String filename, String jfilename, String token)
 String JspComparator.toString(Class c)

Uses of Class in org.jmlspecs.racwrap.runner

Methods in org.jmlspecs.racwrap.runner that return Class
 Class ChxClassLoader.loadClass(String name)
          Alias for loadClass(name, null);
 Class ChxClassLoader.loadClass(String name, boolean resolve)
          This classloader does *not* follow the Java ClassLoader delegation model.
private  Class ChxClassLoader.loadClassFromTree(String name)
          Given the name of a class, this method will find the location of the class (if it knows about it), and load it.

Uses of Class in org.jmlspecs.util

Methods in org.jmlspecs.util with parameters of type Class
 void RacRunTestCase.checkJmlErr(Class c, JMLAssertionError e)

Uses of Class in org.multijava.mjc

Fields in org.multijava.mjc declared as Class
private static Class[] FunctionalTestSuite.TestCase.STRING_ARRAY

Uses of Class in org.multijava.relaxed.runtime

Fields in org.multijava.relaxed.runtime declared as Class
private  Class[] RMJSignature._staticTypes

Methods in org.multijava.relaxed.runtime that return Class
 Class RMJClassLoader.loadClass(String name)
protected  Class RMJClassLoader.loadUserClass(String name)
protected  Class RMJClassLoader.loadSystemClass(String name)
(package private)  Class RMJClassLoader.lookupClass(String className)
 Class RMJPreloader.loadClass(String name)
 Class[] RMJSignature.staticTypes()
 Class[] RMJErrorSignature.errorSpecializers()

Methods in org.multijava.relaxed.runtime with parameters of type Class
protected  void RMJClassLoader.runProgram(Class cls, String[] args)
protected  void RMJClassLoader.registerSystemLoadAncestors(Class cls)
protected  void RMJClassLoader.registerSystemLoad(Class cls)
protected  void RMJClassLoader.processLoadedClass(Class cls, RMJAnnotation anno)
protected  void RMJClassLoader.registerClass(Class cls, RMJAnnotation anno)
protected  void RMJClassLoader.registerWithAbstractAncestors(Class cls)
protected  void RMJClassLoader.registerWithAbstractAncestorsOf(Class cls, Class of, List alreadyVisited)
protected  void RMJClassLoader.registerWithAbstractClassOrInterface(Class cls, Class abs)
protected  void RMJClassLoader.verifyCompleteness(Class cls, RMJAnnotation anno)
protected  void RMJClassLoader.verifyCompletenessOfTopConcreteClass(Class cls)
protected  void RMJClassLoader.collectAbstractSignaturesAbove(Class cls, HashSet asigs)
protected  void RMJClassLoader.collectAbstractSignaturesOf(Class cls, HashSet asigs)
protected  void RMJClassLoader.verifyCompletenessOfAbstractSignature(RMJSignature asig, Class cls)
protected  void RMJClassLoader.verifyCompletenessOfTopConcreteTuples(List tuples, RMJSignature asig, Class cls)
(package private)  Collection RMJClassLoader.computeIntersection(Class cls1, Class cls2)
protected  boolean RMJClassLoader.isInterface(Class cls)
protected  boolean RMJClassLoader.isAbstractClassOrInterface(Class cls)
protected  boolean RMJClassLoader.isAbstractClass(Class cls)
protected  boolean RMJClassLoader.isConcreteClass(Class cls)
protected  boolean RMJClassLoader.isTopConcreteClass(Class cls)
protected  void RMJPreloader.runProgram(Class mainCls, String[] args)
protected  void RMJPreloader.traverseClass(Class cls)

Uses of Class in org.multijava.util

Methods in org.multijava.util with parameters of type Class
static Object[] Utils.vectorToArray(Vector vect, Class type)
          Creates a typed array from a vector.

Uses of Class in org.multijava.util.testing

Methods in org.multijava.util.testing with parameters of type Class
static String Utils.executeCompile(Class cls, String[] args)
static String Utils.executeMethod(Class cls, String methodname, String[] args)
          Finds and executes the method with the given name in the given class; the method must have a single argument of type String[].


JML is Copyright (C) 1998-2002 by Iowa State University and is distributed under the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This release depends on code from the MultiJava project and is based in part on the Kopi project Copyright (C) 1990-99 DMS Decision Management Systems Ges.m.b.H.