sun.tools.java.MemberDefinition Java Examples

/**
 * Create a new Member object.
 */
public Member(MemberDefinition member,
              String value,
              ContextStack stack,
              CompoundType enclosing) {
    this.member = member;
    this.value = value;
    forceTransient = false;
    innerClassDecl = member.getInnerClass() != null;

    // If we are not an inner class, finish initializing now.
    // Otherwise, wait until outer class is finished, then
    // call init to avoid potential recursion problems...

    if (!innerClassDecl) {
        init (stack,enclosing);
    }
}
 

private boolean updateExceptions (MemberDefinition implMethod, Method[] list,
                                  ContextStack stack, boolean quiet) {
    int length = list.length;
    String implMethodSig = implMethod.toString();

    for (int i = 0; i < length; i++) {
        Method existingMethod = list[i];
        MemberDefinition existing = existingMethod.getMemberDefinition();

        // Do we have a matching method?

        if (implMethodSig.equals(existing.toString())) {

            // Yes, so create exception list...

            try {
                ValueType[] implExcept = getMethodExceptions(implMethod,quiet,stack);
                existingMethod.setImplExceptions(implExcept);
            } catch (Exception e) {
                return false;
            }
        }
    }
    return true;
}
 

private boolean checkMethods(ClassDefinition theClass, Vector list,
                             ContextStack stack, boolean quiet) {

    // Convert vector to array...

    Method[] methods = new Method[list.size()];
    list.copyInto(methods);

    for (MemberDefinition member = theClass.getFirstMember();
         member != null;
         member = member.getNextMember()) {

        if (member.isMethod() && !member.isConstructor()
            && !member.isInitializer()) {

            // It's a method...

            if (!updateExceptions(member,methods,stack,quiet)) {
                return false;
            }
        }
    }
    return true;
}
 

/**
 * Create a new Member object.
 */
public Member(MemberDefinition member,
              String value,
              ContextStack stack,
              CompoundType enclosing) {
    this.member = member;
    this.value = value;
    forceTransient = false;
    innerClassDecl = member.getInnerClass() != null;

    // If we are not an inner class, finish initializing now.
    // Otherwise, wait until outer class is finished, then
    // call init to avoid potential recursion problems...

    if (!innerClassDecl) {
        init (stack,enclosing);
    }
}
 

private boolean checkMethods(ClassDefinition theClass, Vector list,
                             ContextStack stack, boolean quiet) {

    // Convert vector to array...

    Method[] methods = new Method[list.size()];
    list.copyInto(methods);

    for (MemberDefinition member = theClass.getFirstMember();
         member != null;
         member = member.getNextMember()) {

        if (member.isMethod() && !member.isConstructor()
            && !member.isInitializer()) {

            // It's a method...

            if (!updateExceptions(member,methods,stack,quiet)) {
                return false;
            }
        }
    }
    return true;
}
 

private boolean updateExceptions (MemberDefinition implMethod, Method[] list,
                                  ContextStack stack, boolean quiet) {
    int length = list.length;
    String implMethodSig = implMethod.toString();

    for (int i = 0; i < length; i++) {
        Method existingMethod = list[i];
        MemberDefinition existing = existingMethod.getMemberDefinition();

        // Do we have a matching method?

        if (implMethodSig.equals(existing.toString())) {

            // Yes, so create exception list...

            try {
                ValueType[] implExcept = getMethodExceptions(implMethod,quiet,stack);
                existingMethod.setImplExceptions(implExcept);
            } catch (Exception e) {
                return false;
            }
        }
    }
    return true;
}
 

private boolean checkMethods(ClassDefinition theClass, Vector list,
                             ContextStack stack, boolean quiet) {

    // Convert vector to array...

    Method[] methods = new Method[list.size()];
    list.copyInto(methods);

    for (MemberDefinition member = theClass.getFirstMember();
         member != null;
         member = member.getNextMember()) {

        if (member.isMethod() && !member.isConstructor()
            && !member.isInitializer()) {

            // It's a method...

            if (!updateExceptions(member,methods,stack,quiet)) {
                return false;
            }
        }
    }
    return true;
}
 

private boolean updateExceptions (MemberDefinition implMethod, Method[] list,
                                  ContextStack stack, boolean quiet) {
    int length = list.length;
    String implMethodSig = implMethod.toString();

    for (int i = 0; i < length; i++) {
        Method existingMethod = list[i];
        MemberDefinition existing = existingMethod.getMemberDefinition();

        // Do we have a matching method?

        if (implMethodSig.equals(existing.toString())) {

            // Yes, so create exception list...

            try {
                ValueType[] implExcept = getMethodExceptions(implMethod,quiet,stack);
                existingMethod.setImplExceptions(implExcept);
            } catch (Exception e) {
                return false;
            }
        }
    }
    return true;
}
 

private boolean updateExceptions (MemberDefinition implMethod, Method[] list,
                                  ContextStack stack, boolean quiet) {
    int length = list.length;
    String implMethodSig = implMethod.toString();

    for (int i = 0; i < length; i++) {
        Method existingMethod = list[i];
        MemberDefinition existing = existingMethod.getMemberDefinition();

        // Do we have a matching method?

        if (implMethodSig.equals(existing.toString())) {

            // Yes, so create exception list...

            try {
                ValueType[] implExcept = getMethodExceptions(implMethod,quiet,stack);
                existingMethod.setImplExceptions(implExcept);
            } catch (Exception e) {
                return false;
            }
        }
    }
    return true;
}
 

private boolean updateExceptions (MemberDefinition implMethod, Method[] list,
                                  ContextStack stack, boolean quiet) {
    int length = list.length;
    String implMethodSig = implMethod.toString();

    for (int i = 0; i < length; i++) {
        Method existingMethod = list[i];
        MemberDefinition existing = existingMethod.getMemberDefinition();

        // Do we have a matching method?

        if (implMethodSig.equals(existing.toString())) {

            // Yes, so create exception list...

            try {
                ValueType[] implExcept = getMethodExceptions(implMethod,quiet,stack);
                existingMethod.setImplExceptions(implExcept);
            } catch (Exception e) {
                return false;
            }
        }
    }
    return true;
}
 

private boolean checkMethods(ClassDefinition theClass, Vector list,
                             ContextStack stack, boolean quiet) {

    // Convert vector to array...

    Method[] methods = new Method[list.size()];
    list.copyInto(methods);

    for (MemberDefinition member = theClass.getFirstMember();
         member != null;
         member = member.getNextMember()) {

        if (member.isMethod() && !member.isConstructor()
            && !member.isInitializer()) {

            // It's a method...

            if (!updateExceptions(member,methods,stack,quiet)) {
                return false;
            }
        }
    }
    return true;
}
 

/**
 * Create a new Member object.
 */
public Member(MemberDefinition member,
              String value,
              ContextStack stack,
              CompoundType enclosing) {
    this.member = member;
    this.value = value;
    forceTransient = false;
    innerClassDecl = member.getInnerClass() != null;

    // If we are not an inner class, finish initializing now.
    // Otherwise, wait until outer class is finished, then
    // call init to avoid potential recursion problems...

    if (!innerClassDecl) {
        init (stack,enclosing);
    }
}
 

private boolean updateExceptions (MemberDefinition implMethod, Method[] list,
                                  ContextStack stack, boolean quiet) {
    int length = list.length;
    String implMethodSig = implMethod.toString();

    for (int i = 0; i < length; i++) {
        Method existingMethod = list[i];
        MemberDefinition existing = existingMethod.getMemberDefinition();

        // Do we have a matching method?

        if (implMethodSig.equals(existing.toString())) {

            // Yes, so create exception list...

            try {
                ValueType[] implExcept = getMethodExceptions(implMethod,quiet,stack);
                existingMethod.setImplExceptions(implExcept);
            } catch (Exception e) {
                return false;
            }
        }
    }
    return true;
}
 

private boolean checkMethods(ClassDefinition theClass, Vector list,
                             ContextStack stack, boolean quiet) {

    // Convert vector to array...

    Method[] methods = new Method[list.size()];
    list.copyInto(methods);

    for (MemberDefinition member = theClass.getFirstMember();
         member != null;
         member = member.getNextMember()) {

        if (member.isMethod() && !member.isConstructor()
            && !member.isInitializer()) {

            // It's a method...

            if (!updateExceptions(member,methods,stack,quiet)) {
                return false;
            }
        }
    }
    return true;
}
 

/**
 * Create a new Member object.
 */
public Member(MemberDefinition member,
              String value,
              ContextStack stack,
              CompoundType enclosing) {
    this.member = member;
    this.value = value;
    forceTransient = false;
    innerClassDecl = member.getInnerClass() != null;

    // If we are not an inner class, finish initializing now.
    // Otherwise, wait until outer class is finished, then
    // call init to avoid potential recursion problems...

    if (!innerClassDecl) {
        init (stack,enclosing);
    }
}
 

private boolean checkMethods(ClassDefinition theClass, Vector list,
                             ContextStack stack, boolean quiet) {

    // Convert vector to array...

    Method[] methods = new Method[list.size()];
    list.copyInto(methods);

    for (MemberDefinition member = theClass.getFirstMember();
         member != null;
         member = member.getNextMember()) {

        if (member.isMethod() && !member.isConstructor()
            && !member.isInitializer()) {

            // It's a method...

            if (!updateExceptions(member,methods,stack,quiet)) {
                return false;
            }
        }
    }
    return true;
}
 

/**
 * Create a new Member object.
 */
public Member(MemberDefinition member,
              String value,
              ContextStack stack,
              CompoundType enclosing) {
    this.member = member;
    this.value = value;
    forceTransient = false;
    innerClassDecl = member.getInnerClass() != null;

    // If we are not an inner class, finish initializing now.
    // Otherwise, wait until outer class is finished, then
    // call init to avoid potential recursion problems...

    if (!innerClassDecl) {
        init (stack,enclosing);
    }
}
 

/**
 * Write code to initialize the static fields for each method
 * using the Java Reflection API.
 */
private void writeMethodFieldInitializers(IndentingWriter p)
    throws IOException
{
    for (int i = 0; i < methodFieldNames.length; i++) {
        p.p(methodFieldNames[i] + " = ");
        /*
         * Here we look up the Method object in the arbitrary interface
         * that we find in the RemoteClass.Method object.
         * REMIND: Is this arbitrary choice OK?
         * REMIND: Should this access be part of RemoteClass.Method's
         * abstraction?
         */
        RemoteClass.Method method = remoteMethods[i];
        MemberDefinition def = method.getMemberDefinition();
        Identifier methodName = method.getName();
        Type methodType = method.getType();
        Type paramTypes[] = methodType.getArgumentTypes();

        p.p(def.getClassDefinition().getName() + ".class.getMethod(\"" +
            methodName + "\", new java.lang.Class[] {");
        for (int j = 0; j < paramTypes.length; j++) {
            if (j > 0)
                p.p(", ");
            p.p(paramTypes[j] + ".class");
        }
        p.pln("});");
    }
}
 

/**
 * Create a new Method object corresponding to the given
 * method definition.
 */
/*
 * Temporarily comment out the private modifier until
 * the VM allows outer class to access inner class's
 * private constructor
 */
/* private */ Method(MemberDefinition memberDef) {
    this.memberDef = memberDef;
    exceptions = memberDef.getExceptions(env);
    methodHash = computeMethodHash();
}
 

/**
 * Write code to initialize the static fields for each method
 * using the Java Reflection API.
 */
private void writeMethodFieldInitializers(IndentingWriter p)
    throws IOException
{
    for (int i = 0; i < methodFieldNames.length; i++) {
        p.p(methodFieldNames[i] + " = ");
        /*
         * Here we look up the Method object in the arbitrary interface
         * that we find in the RemoteClass.Method object.
         * REMIND: Is this arbitrary choice OK?
         * REMIND: Should this access be part of RemoteClass.Method's
         * abstraction?
         */
        RemoteClass.Method method = remoteMethods[i];
        MemberDefinition def = method.getMemberDefinition();
        Identifier methodName = method.getName();
        Type methodType = method.getType();
        Type paramTypes[] = methodType.getArgumentTypes();

        p.p(def.getClassDefinition().getName() + ".class.getMethod(\"" +
            methodName + "\", new java.lang.Class[] {");
        for (int j = 0; j < paramTypes.length; j++) {
            if (j > 0)
                p.p(", ");
            p.p(paramTypes[j] + ".class");
        }
        p.pln("});");
    }
}
 

/**
 * Write code to initialize the static fields for each method
 * using the Java Reflection API.
 */
private void writeMethodFieldInitializers(IndentingWriter p)
    throws IOException
{
    for (int i = 0; i < methodFieldNames.length; i++) {
        p.p(methodFieldNames[i] + " = ");
        /*
         * Here we look up the Method object in the arbitrary interface
         * that we find in the RemoteClass.Method object.
         * REMIND: Is this arbitrary choice OK?
         * REMIND: Should this access be part of RemoteClass.Method's
         * abstraction?
         */
        RemoteClass.Method method = remoteMethods[i];
        MemberDefinition def = method.getMemberDefinition();
        Identifier methodName = method.getName();
        Type methodType = method.getType();
        Type paramTypes[] = methodType.getArgumentTypes();

        p.p(def.getClassDefinition().getName() + ".class.getMethod(\"" +
            methodName + "\", new java.lang.Class[] {");
        for (int j = 0; j < paramTypes.length; j++) {
            if (j > 0)
                p.p(", ");
            p.p(paramTypes[j] + ".class");
        }
        p.pln("});");
    }
}
 

/**
 * Create a new Method object corresponding to the given
 * method definition.
 */
/*
 * Temporarily comment out the private modifier until
 * the VM allows outer class to access inner class's
 * private constructor
 */
/* private */ Method(MemberDefinition memberDef) {
    this.memberDef = memberDef;
    exceptions = memberDef.getExceptions(env);
    methodHash = computeMethodHash();
}
 

protected static String getVisibilityString (MemberDefinition member) {
    String vis = "";
    String prefix = "";

    if (member.isPublic()) {
        vis += "public";
        prefix = " ";
    } else if (member.isProtected()) {
        vis += "protected";
        prefix = " ";
    } else if (member.isPrivate()) {
        vis += "private";
        prefix = " ";
    }

    if (member.isStatic()) {
        vis += prefix;
        vis += "static";
        prefix = " ";
    }

    if (member.isFinal()) {
        vis += prefix;
        vis += "final";
        prefix = " ";
    }

    return vis;
}
 

protected static String getVisibilityString (MemberDefinition member) {
    String vis = "";
    String prefix = "";

    if (member.isPublic()) {
        vis += "public";
        prefix = " ";
    } else if (member.isProtected()) {
        vis += "protected";
        prefix = " ";
    } else if (member.isPrivate()) {
        vis += "private";
        prefix = " ";
    }

    if (member.isStatic()) {
        vis += prefix;
        vis += "static";
        prefix = " ";
    }

    if (member.isFinal()) {
        vis += prefix;
        vis += "final";
        prefix = " ";
    }

    return vis;
}
 

/**
 * Create a new Method object corresponding to the given
 * method definition.
 */
/*
 * Temporarily comment out the private modifier until
 * the VM allows outer class to access inner class's
 * private constructor
 */
/* private */ Method(MemberDefinition memberDef) {
    this.memberDef = memberDef;
    exceptions = memberDef.getExceptions(env);
    methodHash = computeMethodHash();
}
 

/**
 * Write code to initialize the static fields for each method
 * using the Java Reflection API.
 */
private void writeMethodFieldInitializers(IndentingWriter p)
    throws IOException
{
    for (int i = 0; i < methodFieldNames.length; i++) {
        p.p(methodFieldNames[i] + " = ");
        /*
         * Here we look up the Method object in the arbitrary interface
         * that we find in the RemoteClass.Method object.
         * REMIND: Is this arbitrary choice OK?
         * REMIND: Should this access be part of RemoteClass.Method's
         * abstraction?
         */
        RemoteClass.Method method = remoteMethods[i];
        MemberDefinition def = method.getMemberDefinition();
        Identifier methodName = method.getName();
        Type methodType = method.getType();
        Type paramTypes[] = methodType.getArgumentTypes();

        p.p(def.getClassDefinition().getName() + ".class.getMethod(\"" +
            methodName + "\", new java.lang.Class[] {");
        for (int j = 0; j < paramTypes.length; j++) {
            if (j > 0)
                p.p(", ");
            p.p(paramTypes[j] + ".class");
        }
        p.pln("});");
    }
}
 

/**
 * Create a new Method object corresponding to the given
 * method definition.
 */
/*
 * Temporarily comment out the private modifier until
 * the VM allows outer class to access inner class's
 * private constructor
 */
/* private */ Method(MemberDefinition memberDef) {
    this.memberDef = memberDef;
    exceptions = memberDef.getExceptions(env);
    methodHash = computeMethodHash();
}
 

protected static String getVisibilityString (MemberDefinition member) {
    String vis = "";
    String prefix = "";

    if (member.isPublic()) {
        vis += "public";
        prefix = " ";
    } else if (member.isProtected()) {
        vis += "protected";
        prefix = " ";
    } else if (member.isPrivate()) {
        vis += "private";
        prefix = " ";
    }

    if (member.isStatic()) {
        vis += prefix;
        vis += "static";
        prefix = " ";
    }

    if (member.isFinal()) {
        vis += prefix;
        vis += "final";
        prefix = " ";
    }

    return vis;
}
 

/**
 * Create a new Method object corresponding to the given
 * method definition.
 */
/*
 * Temporarily comment out the private modifier until
 * the VM allows outer class to access inner class's
 * private constructor
 */
/* private */ Method(MemberDefinition memberDef) {
    this.memberDef = memberDef;
    exceptions = memberDef.getExceptions(env);
    methodHash = computeMethodHash();
}
 

protected static String getVisibilityString (MemberDefinition member) {
    String vis = "";
    String prefix = "";

    if (member.isPublic()) {
        vis += "public";
        prefix = " ";
    } else if (member.isProtected()) {
        vis += "protected";
        prefix = " ";
    } else if (member.isPrivate()) {
        vis += "private";
        prefix = " ";
    }

    if (member.isStatic()) {
        vis += prefix;
        vis += "static";
        prefix = " ";
    }

    if (member.isFinal()) {
        vis += prefix;
        vis += "final";
        prefix = " ";
    }

    return vis;
}