Java Code Examples for org.osgl.util.C#newList()

@Override
public List<Integer> load(Map<String, Object> options, BeanSpec container, Genie genie) {
    int max = toInt(options.get("max"));
    int n1 = 1, n2 = 1, f;
    List<Integer> list = C.newList();
    list.add(n1);
    list.add(n2);
    for (;;) {
        f = n1 + n2;
        n1 = n2;
        n2 = f;
        if (f < max) {
            list.add(f);
        } else {
            break;
        }
    }
    return list;
}
 

@Provides
public static TypedElementLoader typedElementLoader() {
    return new TypedElementLoader() {
        @Override
        protected List<Class> load(Class type, boolean loadNonPublic, boolean loadAbstract, boolean loadRoot) {
            if (type == Base.class) {
                List<Class> list = (List) C.newList(Derived.class);
                if (loadNonPublic) {
                    list.add(NonPublicDerived.class);
                }
                if (loadAbstract) {
                    list.add(AbstractDerived.class);
                }
                if (loadRoot) {
                    list.add(Base.class);
                }
                return list;
            }
            return C.list();
        }
    };
}
 

public void process() {
    List<String> lines = new ArrayList<>();
    for (String chapter : processor.chapters()) {
        File src = new File(base, chapter);
        List<String> fileLines = IO.readLines(src);
        C.List<String> processedFileLines = C.newList();
        for (String line : fileLines) {
            if ("[返回目录](index.md)".equals(line.trim())) {
                continue;
            }
            line = processor.processTag(line);
            processedFileLines.add(line);
        }
        if (!lines.isEmpty()) {
            processedFileLines.add("\\newpage");
        }
        lines.addAll(processedFileLines);
    }
    File target = new File(processor.workspace(), "act_doc-" + lang + ".md");
    IO.write(S.join(lines).by("\n").get()).to(target);
}
 

private static Set<List<Class>> permutationOf(List<List<Class>> candidates, int workingColumnId) {
    if (workingColumnId == 0) {
        Set<List<Class>> permutations = new HashSet<>();
        for (Class c : candidates.get(0)) {
            permutations.add(C.newList(c));
        }
        return permutations;
    } else {
        Set<List<Class>> prefixPermutations = permutationOf(candidates, workingColumnId - 1);
        List<Class> currentCandidates = candidates.get(workingColumnId);
        Set<List<Class>> retSet = new HashSet<>();
        for (List<Class> argList : prefixPermutations) {
            for (Class type : currentCandidates) {
                List<Class> merged = C.newList(argList);
                merged.add(type);
                retSet.add(merged);
            }
        }
        return retSet;
    }
}
 

protected Map<String, Object> prepareJsonData(List<$.T2<String, Object>> params) {
    Map<String, Object> map = C.newMap();
    if (null != params) {
        for ($.T2<String, Object> pair : params) {
            String key = pair._1;
            Object val = pair._2;
            if (map.containsKey(key)) {
                List list;
                Object x = map.get(key);
                if (x instanceof List) {
                    list = $.cast(x);
                } else {
                    list = C.newList(x);
                    map.put(key, list);
                }
                list.add(val);
            } else {
                map.put(key, val);
            }
        }
    }
    return map;
}
 

private static List<String> loadWords() {
    URL url = Act.getResource("act_zen.txt");
    List<String> words = C.newList(defaultWords());
    if (null != url) {
        try {
            List<String> myWords = IO.readLines(url.openStream());
            if (!myWords.isEmpty()) {
                words = myWords;
            }
        } catch (Exception e) {
            // ignore it
        }
    }
    List<String> retVal = new ArrayList<>(words.size());
    for (String s : words) {
        if (s.contains("\n")) {
            s = s.replaceAll("\n", "\n          ");
        } else if (s.contains("\\n")) {
            s = s.replaceAll("\\\\n", "\n          ");
        }
        retVal.add(s);
    }
    return retVal;
}
 

private static C.List<FilterInfo> filters(Genie genie, BeanSpec spec) {
    C.List<FilterInfo> list = C.newList();
    Set<Annotation> annotations = spec.filters();
    for (Annotation anno : annotations) {
        Class<? extends Annotation> annoClass = anno.annotationType();
        Filter filterTag = (Filter.class == annoClass) ? (Filter) anno : annoClass.getAnnotation(Filter.class);
        ElementFilter loader = genie.get(filterTag.value());
        list.add(new FilterInfo(loader, filterTag.reverse(), anno, spec));
    }
    return list;
}
 

@Override
public List<Integer> get() {
    List<Integer> list = C.newList();
    for (int i = 0; i < 10; ++i) {
        list.add(N.randInt(100));
    }
    return list;
}
 

@Test
public void test() {
    List<Foo> foos = C.newList();
    foos.add(new Bar());
    foos.add(new Zee());

    C.List<Foo> l = C.list(foos);
    yes(l.size() == 2);
    yes(l.is(C.Feature.READONLY));
}
 

private static List<String> tokenOf(Class<?> entryClass) {
    C.List<String> tokens = C.newList();
    tokens.addAll(classNameTokensReversed(entryClass));
    Class<?> enclosingClass = entryClass.getEnclosingClass();
    while (null != enclosingClass) {
        tokens.addAll(classNameTokensReversed(enclosingClass));
        enclosingClass = entryClass.getEnclosingClass();
    }
    String pkgName = JavaNames.packageNameOf(entryClass);
    tokens.append(S.fastSplit(pkgName, ".").reverse());
    return tokens.reverse();
}
 

public List<Cookie> retrieveCsrfToken($.Var<String> csrf) throws IOException {
    url("/csrf");
    List<Cookie> cookies = cookies();
    List<Cookie> returnCookies = C.newList();
    for (Cookie cookie : cookies) {
        if ("xsrf-token".equalsIgnoreCase(cookie.name())) {
            csrf.set(cookie.value());
        } else {
            returnCookies.add(cookie);
        }
    }
    return returnCookies;
}
 

public void putListAttribute(String name, Object val) {
    List<Object> vals = listAttributes.get(name);
    if (null == vals) {
        vals = C.newList(val);
        listAttributes.put(name, vals);
    } else {
        vals.add(val);
    }
}
 

private List<String> commands0(boolean sys, boolean app, boolean withShortcut) {
    C.List<String> list = C.newList();
    Act.Mode mode = Act.mode();
    boolean all = !sys && !app;
    for (Keyword keyword : registry.keySet()) {
        String s = rawNameRepo.get(keyword);
        boolean isSysCmd = s.startsWith("act.");
        if (isSysCmd && !sys && !all) {
            continue;
        }
        if (!isSysCmd && !app && !all) {
            continue;
        }
        CliHandler h = registry.get(keyword);
        if (h.appliedIn(mode)) {
            if (withShortcut) {
                List<String> shortcuts = shortCuts(h);
                if (null != shortcuts && !shortcuts.isEmpty()) {
                    s = s + " | " + shortcuts.get(0);
                }
            }
            list.add(s);
        }
    }
    return list.sorted(new $.Comparator<String>() {
        @Override
        public int compare(String o1, String o2) {
            boolean b1 = (o1.startsWith("act."));
            boolean b2 = (o2.startsWith("act."));
            if (b1 & !b2) {
                return -1;
            }
            if (!b1 & b2) {
                return 1;
            }
            return o1.compareTo(o2);
        }
    });
}
 

static public void main(String[] args) throws Exception {
    System.out.println(System.getenv("TERM"));

    List<Integer> sizedColl = C.newList();
    for (int i = 0; i < 10000; ++i) {
        sizedColl.add(i);
    }

    for (Integer x : ProgressBar.wrap(sizedColl, "Traverse")) {
        Thread.sleep(2);
    }
}
 

public void addBar(Bar bar) {
    if (barList == null) {
        barList = C.newList();
    }
    barList.add(bar);
}
 

public SimpleTreeNode(String id, String label, List<TreeNode> children) {
    this.id = id;
    this.label = label;
    this.children = null == children ? C.<TreeNode>newList() : C.newList(children);
}
 

public SimpleTreeNode(String id, String label) {
    this(id, label, C.<TreeNode>newList());
}
 

@Override
public List<MODEL_TYPE> findAllAsList() {
    return C.newList(findAll());
}
 

public CatchMethodMetaInfo exceptionClasses(List<String> list) {
    targetExceptionClassNames = C.newList(list);
    return this;
}
 

@Override
public C.List<?> get() {
    return C.newList();
}