Java Clojure.var方法代码示例

import clojure.java.api.Clojure; //导入方法依赖的package包/类
@Override
public void onLoad() {
    Thread.currentThread().setContextClassLoader(this.getClass().getClassLoader());
    instance = this;
    logger = getLogger();
    try (InputStream stream = getResource("clojure.yml")) {
        clojureConfig = YamlConfiguration.loadConfiguration(stream);
        mainNs = clojureConfig.getString("clojure");
        if (mainNs == null) {
            setEnabled(false);
            throw new RuntimeException("The plugin couldn't be enabled due to Clojure ns missing.");
        }
        require.invoke(Clojure.read(mainNs));
    } catch (IOException e) {
        e.printStackTrace();
    }

    IFn setData = Clojure.var(mainNs, "setData");
    if (setData == null) {
        setEnabled(false);
        throw new RuntimeException("The clojure plugin couldn't be enabled due to missing setData method.");
    }
    setData.invoke(this, getDataFolder(), getConfig(), getDescription(), getServer(), getLogger());
    callIfExists("onLoad");
}
 

import clojure.java.api.Clojure; //导入方法依赖的package包/类
public static ArrayList<Symbol> importNsDeclarations(List<String> namespaces)
    throws ClassNotFoundException{
    ClassLoader loader = Thread.currentThread().getContextClassLoader();
    if (require == null)
        require = Clojure.var("clojure.core", "require");

    require.invoke(Clojure.read("coa.droid-test.internal.util"));
    if (getImports == null)
        getImports = Clojure.var("coa.droid-test.internal.util",
                                 "extract-imports");

    ArrayList<Symbol> namespaceSymbols = new ArrayList<Symbol>();
    for (String ns : TestRunner.getTestNamespaces()) {
        processNs(ns, loader, namespaceSymbols);
    }
    return namespaceSymbols;
}
 

import clojure.java.api.Clojure; //导入方法依赖的package包/类
@Test
public void expectationsRunner() {
    try {
        IFn require = Clojure.var("clojure.core", "require");
        require.invoke(Clojure.read("expectations"));
        IFn disableRun = Clojure.var("expectations", "disable-run-on-shutdown");
        disableRun.invoke();

        List<Symbol> namespaces = Util.importNsDeclarations(TestRunner.getTestNamespaces());
        Util.tryInitNeko();

        IFn runTests = Clojure.var("expectations", "run-all-tests");
        Object result = runTests.invoke();

        IFn shutdownAgents = Clojure.var("clojure.core", "shutdown-agents");
        shutdownAgents.invoke();
    } catch (Throwable t) {
        t.printStackTrace();
    }
}
 

import clojure.java.api.Clojure; //导入方法依赖的package包/类
@Test
public void specljRunner() {
    try {
        List<Symbol> namespaces = Util.importNsDeclarations(TestRunner.getTestNamespaces());
        Util.tryInitNeko();

        IFn require = Clojure.var("clojure.core", "require");

        require.invoke(Clojure.read("speclj.cli"));
        require.invoke(Clojure.read("speclj.run.standard"));

        IFn runSpecs = Clojure.var("speclj.run.standard", "run-specs");
        runSpecs.invoke();

        IFn shutdownAgents = Clojure.var("clojure.core", "shutdown-agents");
        shutdownAgents.invoke();
    } catch (Throwable t) {
        t.printStackTrace();
    }
}
 

import clojure.java.api.Clojure; //导入方法依赖的package包/类
@Test
public void nreplStarter() {
    try {
        Util.importNsDeclarations(TestRunner.getTestNamespaces());
        Util.tryInitNeko();

        IFn require = Clojure.var("clojure.core", "require");
        require.invoke(Clojure.read("clojure.tools.nrepl.server"));
        IFn startServer = Clojure.var("clojure.tools.nrepl.server",
                                      "start-server");
        startServer.invoke(Clojure.read(":port"), 8888);
        System.out.println("Started nREPL server on port " + 8888);
    } catch (Throwable t) {
        t.printStackTrace();
    }
}
 

import clojure.java.api.Clojure; //导入方法依赖的package包/类
@Override
public Object reduce(Object o, Iterator<Object> objectIterator) {

    if(fn == null) {
        IFn require = Clojure.var("clojure.core", "require");
        require.invoke(Clojure.read(ns));
        fn = Clojure.var(ns, sym);
    }

    Object result = seed;
    while(objectIterator.hasNext()){
        Object x = objectIterator.next();
        result = fn.invoke(o, result, x);
    }
    return result;
}
 

import clojure.java.api.Clojure; //导入方法依赖的package包/类
public void map(Object key, Object value, Collector<Object, Object> collector){

        if(fn == null) {
            IFn require = Clojure.var("clojure.core", "require");
            require.invoke(Clojure.read(ns));
            fn = Clojure.var(ns, sym);
        }

        for (Object o : (Iterable)fn.invoke(key, value)){
            Seqable s = (Seqable)o;
            ISeq seq = s.seq();
            Object k = seq.first();
            Object v = seq.next().first();
            collector.emit(k, v);
        }
    }
 

import clojure.java.api.Clojure; //导入方法依赖的package包/类
private static void loadClojureFn() {
    ClassLoader previous = Thread.currentThread().getContextClassLoader();
    Thread.currentThread().setContextClassLoader(IcepickProcessor.class.getClassLoader());
    try {
        Object ns = Clojure.read("icepick.processor");
        IFn require = Clojure.var("clojure.core", "require");
        require.invoke(ns);
        PROCESS = Clojure.var("icepick.processor", "process");
    } finally {
        Thread.currentThread().setContextClassLoader(previous);
    }
}
 

import clojure.java.api.Clojure; //导入方法依赖的package包/类
public void callIfExists(String namespace, String name, Object... args) {
    require.invoke(namespace);
    IFn method = Clojure.var(namespace, name);
    if (method != null) {
        if (args != null && args.length != 0) {
            method.invoke(args);
        } else {
            method.invoke();
        }
    }
}
 

import clojure.java.api.Clojure; //导入方法依赖的package包/类
public static <T> T invoke(String namespace, String name, Object... args) {
    if (!"clojure.core".equals(namespace)) {
        IFn symbol = Clojure.var("clojure.core", "symbol");
        IFn require = Clojure.var("clojure.core", "require");

        Object sym = symbol.invoke(namespace);
        require.invoke(sym);
    }

    IFn apply = Clojure.var("clojure.core", "apply");
    return (T) apply.invoke(Clojure.var(namespace, name), args);
}
 

import clojure.java.api.Clojure; //导入方法依赖的package包/类
public static NamespaceSelector selectNamespace(String namespace) {
    IFn symbol = Clojure.var("clojure.core", "symbol");
    IFn require = Clojure.var("clojure.core", "require");
    IFn findNs = Clojure.var("clojure.core", "find-ns");

    Object sym = symbol.invoke(namespace);
    require.invoke(sym);

    Namespace ns = (Namespace) findNs.invoke(sym);

    return new NamespaceSelector(ns);
}
 

import clojure.java.api.Clojure; //导入方法依赖的package包/类
public static void callClojureFn(String fn, Object... args) {
  Symbol var = (Symbol)Clojure.read(fn);
  IFn require = Clojure.var("clojure.core", "require");
  require.invoke(Symbol.create(var.getNamespace()));
  ISeq argsSeq = ArraySeq.create(args);
  Clojure.var(var.getNamespace(), var.getName()).applyTo(argsSeq);
}
 

import clojure.java.api.Clojure; //导入方法依赖的package包/类
@Test
public void cloverageRunner() {
    try {
        List<Symbol> namespaces = Util.importNsDeclarations(TestRunner.getTestNamespaces());
        Util.tryInitNeko();
        ArrayList<String> cloverageArgs = new ArrayList<String>();

        for (Symbol ns : namespaces) {
            cloverageArgs.add("-x");
            cloverageArgs.add(ns.getName());
        }
        cloverageArgs.addAll(TestRunner.getSourceNamespaces());

        IFn require = Clojure.var("clojure.core", "require");
        require.invoke(Clojure.read("cloverage.coverage"));

        IFn coverage = Clojure.var("cloverage.coverage", "-main");
        IFn apply = Clojure.var("clojure.core", "apply");
        IFn concat = Clojure.var("clojure.core", "concat");
        apply.invoke(coverage, "--coveralls", cloverageArgs);

        IFn shutdownAgents = Clojure.var("clojure.core", "shutdown-agents");
        shutdownAgents.invoke();
    } catch (Throwable t) {
        t.printStackTrace();
    }
}
 

import clojure.java.api.Clojure; //导入方法依赖的package包/类
/**
 * Passes the contents as an info level message to the log.
 * @param message An object containing an info level message to be passed to the log
 */
public static void info(Object message){
    IFn requireFn = Clojure.var(CORE, Require);
    requireFn.invoke(Clojure.read(TIMBRE));
    IFn messageFn = Clojure.var(TIMBRE, MessageFn);
    messageFn.invoke(message);
}
 

import clojure.java.api.Clojure; //导入方法依赖的package包/类
/**
 * Passes the contents as a debug level message to the log.
 * @param message An object containing a debug level message to be passed to the log
 */
public static void debug(Object message){
    IFn requireFn = Clojure.var(CORE, Require);
    requireFn.invoke(Clojure.read(TIMBRE));
    IFn debugFn = Clojure.var(TIMBRE, DebugFn);
    debugFn.invoke(message);
}