Java Code Examples for com.sun.tools.javac.util.List#toArray()

/**
 * Let doclet check that all options are OK. Returning true means
 * options are OK.  If method does not exist, assume true.
 */
public boolean validOptions(List<String[]> optlist) {
    Object retVal;
    String options[][] = optlist.toArray(new String[optlist.length()][]);
    String methodName = "validOptions";
    DocErrorReporter reporter = messager;
    Class<?>[] paramTypes = { String[][].class, DocErrorReporter.class };
    Object[] params = { options, reporter };
    try {
        retVal = invoke(methodName, Boolean.TRUE, paramTypes, params);
    } catch (DocletInvokeException exc) {
        return false;
    }
    if (retVal instanceof Boolean) {
        return ((Boolean)retVal).booleanValue();
    } else {
        messager.error(Messager.NOPOS, "main.must_return_boolean",
                       docletClassName, methodName);
        return false;
    }
}
 

void test(List<String> list, String[] array) {
    String[] result = list.toArray(array);

    if (result.length < list.size()) {
        error("returned array is too small; expected: " + list.size() + ", found: " + result.length);
        return;
    }

    if (list.size() <= array.length && result != array)
        error("new array wrongly created");

    int i = 0;
    for (String s: list)
        check(result, i++, s);

    if (i < result.length)
        check(result, i, null);
}
 

/**
 * Let doclet check that all options are OK. Returning true means
 * options are OK.  If method does not exist, assume true.
 */
public boolean validOptions(List<String[]> optlist) {
    Object retVal;
    String options[][] = optlist.toArray(new String[optlist.length()][]);
    String methodName = "validOptions";
    DocErrorReporter reporter = messager;
    Class<?>[] paramTypes = { String[][].class, DocErrorReporter.class };
    Object[] params = { options, reporter };
    try {
        retVal = invoke(methodName, Boolean.TRUE, paramTypes, params);
    } catch (DocletInvokeException exc) {
        return false;
    }
    if (retVal instanceof Boolean) {
        return ((Boolean)retVal).booleanValue();
    } else {
        messager.error(Messager.NOPOS, "main.must_return_boolean",
                       docletClassName, methodName);
        return false;
    }
}
 

void test(List<String> list, String[] array) {
    String[] result = list.toArray(array);

    if (result.length < list.size()) {
        error("returned array is too small; expected: " + list.size() + ", found: " + result.length);
        return;
    }

    if (list.size() <= array.length && result != array)
        error("new array wrongly created");

    int i = 0;
    for (String s: list)
        check(result, i++, s);

    if (i < result.length)
        check(result, i, null);
}
 

void test(List<String> list, String[] array) {
    String[] result = list.toArray(array);

    if (result.length < list.size()) {
        error("returned array is too small; expected: " + list.size() + ", found: " + result.length);
        return;
    }

    if (list.size() <= array.length && result != array)
        error("new array wrongly created");

    int i = 0;
    for (String s: list)
        check(result, i++, s);

    if (i < result.length)
        check(result, i, null);
}
 

/**
 * Let doclet check that all options are OK. Returning true means
 * options are OK.  If method does not exist, assume true.
 */
public boolean validOptions(List<String[]> optlist) {
    Object retVal;
    String options[][] = optlist.toArray(new String[optlist.length()][]);
    String methodName = "validOptions";
    DocErrorReporter reporter = messager;
    Class<?>[] paramTypes = { String[][].class, DocErrorReporter.class };
    Object[] params = { options, reporter };
    try {
        retVal = invoke(methodName, Boolean.TRUE, paramTypes, params);
    } catch (DocletInvokeException exc) {
        return false;
    }
    if (retVal instanceof Boolean) {
        return ((Boolean)retVal).booleanValue();
    } else {
        messager.error(Messager.NOPOS, "main.must_return_boolean",
                       docletClassName, methodName);
        return false;
    }
}
 

void test(List<String> list, String[] array) {
    String[] result = list.toArray(array);

    if (result.length < list.size()) {
        error("returned array is too small; expected: " + list.size() + ", found: " + result.length);
        return;
    }

    if (list.size() <= array.length && result != array)
        error("new array wrongly created");

    int i = 0;
    for (String s: list)
        check(result, i++, s);

    if (i < result.length)
        check(result, i, null);
}
 

/**
 * Let doclet check that all options are OK. Returning true means
 * options are OK.  If method does not exist, assume true.
 */
public boolean validOptions(List<String[]> optlist) {
    Object retVal;
    String options[][] = optlist.toArray(new String[optlist.length()][]);
    String methodName = "validOptions";
    DocErrorReporter reporter = messager;
    Class<?>[] paramTypes = { String[][].class, DocErrorReporter.class };
    Object[] params = { options, reporter };
    try {
        retVal = invoke(methodName, Boolean.TRUE, paramTypes, params);
    } catch (DocletInvokeException exc) {
        return false;
    }
    if (retVal instanceof Boolean) {
        return ((Boolean)retVal).booleanValue();
    } else {
        messager.error(Messager.NOPOS, "main.must_return_boolean",
                       docletClassName, methodName);
        return false;
    }
}
 

/**
 * Let doclet check that all options are OK. Returning true means
 * options are OK.  If method does not exist, assume true.
 */
public boolean validOptions(List<String[]> optlist) {
    Object retVal;
    String options[][] = optlist.toArray(new String[optlist.length()][]);
    String methodName = "validOptions";
    DocErrorReporter reporter = messager;
    Class<?>[] paramTypes = { String[][].class, DocErrorReporter.class };
    Object[] params = { options, reporter };
    try {
        retVal = invoke(methodName, Boolean.TRUE, paramTypes, params);
    } catch (DocletInvokeException exc) {
        return false;
    }
    if (retVal instanceof Boolean) {
        return ((Boolean)retVal).booleanValue();
    } else {
        messager.error(Messager.NOPOS, "main.must_return_boolean",
                       docletClassName, methodName);
        return false;
    }
}
 

void test(List<String> list, String[] array) {
    String[] result = list.toArray(array);

    if (result.length < list.size()) {
        error("returned array is too small; expected: " + list.size() + ", found: " + result.length);
        return;
    }

    if (list.size() <= array.length && result != array)
        error("new array wrongly created");

    int i = 0;
    for (String s: list)
        check(result, i++, s);

    if (i < result.length)
        check(result, i, null);
}
 

/**
 * Let doclet check that all options are OK. Returning true means
 * options are OK.  If method does not exist, assume true.
 */
public boolean validOptions(List<String[]> optlist) {
    Object retVal;
    String options[][] = optlist.toArray(new String[optlist.length()][]);
    String methodName = "validOptions";
    DocErrorReporter reporter = messager;
    Class<?>[] paramTypes = { String[][].class, DocErrorReporter.class };
    Object[] params = { options, reporter };
    try {
        retVal = invoke(methodName, Boolean.TRUE, paramTypes, params);
    } catch (DocletInvokeException exc) {
        return false;
    }
    if (retVal instanceof Boolean) {
        return ((Boolean)retVal);
    } else {
        messager.error(Messager.NOPOS, "main.must_return_boolean",
                       docletClassName, methodName);
        return false;
    }
}
 

/**
 * Let doclet check that all options are OK. Returning true means
 * options are OK.  If method does not exist, assume true.
 */
public boolean validOptions(List<String[]> optlist) {
    Object retVal;
    String options[][] = optlist.toArray(new String[optlist.length()][]);
    String methodName = "validOptions";
    DocErrorReporter reporter = messager;
    Class<?>[] paramTypes = { String[][].class, DocErrorReporter.class };
    Object[] params = { options, reporter };
    try {
        retVal = invoke(methodName, Boolean.TRUE, paramTypes, params);
    } catch (DocletInvokeException exc) {
        return false;
    }
    if (retVal instanceof Boolean) {
        return ((Boolean)retVal).booleanValue();
    } else {
        messager.error(Messager.NOPOS, "main.must_return_boolean",
                       docletClassName, methodName);
        return false;
    }
}
 

/**
 * Generate an indy method call with given name, type and static bootstrap
 * arguments types
 */
private JCExpression makeIndyCall(DiagnosticPosition pos, Type site, Name bsmName,
        List<Object> staticArgs, MethodType indyType, List<JCExpression> indyArgs,
        Name methName) {
    int prevPos = make.pos;
    try {
        make.at(pos);
        List<Type> bsm_staticArgs = List.of(syms.methodHandleLookupType,
                syms.stringType,
                syms.methodTypeType).appendList(bsmStaticArgToTypes(staticArgs));

        Symbol bsm = rs.resolveInternalMethod(pos, attrEnv, site,
                bsmName, bsm_staticArgs, List.nil());

        DynamicMethodSymbol dynSym =
                new DynamicMethodSymbol(methName,
                                        syms.noSymbol,
                                        bsm.isStatic() ?
                                            ClassFile.REF_invokeStatic :
                                            ClassFile.REF_invokeVirtual,
                                        (MethodSymbol)bsm,
                                        indyType,
                                        staticArgs.toArray());

        JCFieldAccess qualifier = make.Select(make.QualIdent(site.tsym), bsmName);
        qualifier.sym = dynSym;
        qualifier.type = indyType.getReturnType();

        JCMethodInvocation proxyCall = make.Apply(List.nil(), qualifier, indyArgs);
        proxyCall.type = indyType.getReturnType();
        return proxyCall;
    } finally {
        make.at(prevPos);
    }
}
 

/**
 * Get all classes (including Exceptions and Errors)
 * and interfaces.
 * @since J2SE1.4.
 *
 * @return all classes and interfaces in this package, filtered to include
 * only the included classes if filter==true.
 */
public ClassDoc[] allClasses(boolean filter) {
    List<ClassDocImpl> classes = getClasses(filter);
    return classes.toArray(new ClassDocImpl[classes.length()]);
}
 

/**
 * Get all classes (including Exceptions and Errors)
 * and interfaces.
 * @since J2SE1.4.
 *
 * @return all classes and interfaces in this package, filtered to include
 * only the included classes if filter==true.
 */
public ClassDoc[] allClasses(boolean filter) {
    List<ClassDocImpl> classes = getClasses(filter);
    return classes.toArray(new ClassDocImpl[classes.length()]);
}
 

/**
 * Get all classes (including Exceptions and Errors)
 * and interfaces.
 * @since J2SE1.4.
 *
 * @return all classes and interfaces in this package, filtered to include
 * only the included classes if filter==true.
 */
public ClassDoc[] allClasses(boolean filter) {
    List<ClassDocImpl> classes = getClasses(filter);
    return classes.toArray(new ClassDocImpl[classes.length()]);
}
 

/**
 * Get all classes (including Exceptions and Errors)
 * and interfaces.
 * @since J2SE1.4.
 *
 * @return all classes and interfaces in this package, filtered to include
 * only the included classes if filter==true.
 */
public ClassDoc[] allClasses(boolean filter) {
    List<ClassDocImpl> classes = getClasses(filter);
    return classes.toArray(new ClassDocImpl[classes.length()]);
}
 

/**
 * Get all classes (including Exceptions and Errors)
 * and interfaces.
 * @since J2SE1.4.
 *
 * @return all classes and interfaces in this package, filtered to include
 * only the included classes if filter==true.
 */
public ClassDoc[] allClasses(boolean filter) {
    List<ClassDocImpl> classes = getClasses(filter);
    return classes.toArray(new ClassDocImpl[classes.length()]);
}
 

/**
 * Get all classes (including Exceptions and Errors)
 * and interfaces.
 * @since J2SE1.4.
 *
 * @return all classes and interfaces in this package, filtered to include
 * only the included classes if filter==true.
 */
public ClassDoc[] allClasses(boolean filter) {
    List<ClassDocImpl> classes = getClasses(filter);
    return classes.toArray(new ClassDocImpl[classes.length()]);
}
 

/**
 * Get all classes (including Exceptions and Errors)
 * and interfaces.
 * @since J2SE1.4.
 *
 * @return all classes and interfaces in this package, filtered to include
 * only the included classes if filter==true.
 */
public ClassDoc[] allClasses(boolean filter) {
    List<ClassDocImpl> classes = getClasses(filter);
    return classes.toArray(new ClassDocImpl[classes.length()]);
}