Java IFn类代码示例

import clojure.lang.IFn; //导入依赖的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.lang.IFn; //导入依赖的package包/类
@Override
public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
    IFn command = commands.get(cmd);
    if (command == null) {
        return true;
    }
    try {
        command.invoke(sender, command, label, args);
    } catch (Exception ex) {
        //noinspection ConstantConditions
        if (ex instanceof Return) {
            return true;
        }
        sender.sendMessage(ChatColor.RED + "An error occurred within the code. Ask an admin about the stacktrace.");
        getLogger().log(Level.SEVERE, "An error occurred!", ex);
    }
    return true;
}
 

import clojure.lang.IFn; //导入依赖的package包/类
@Override
public Consumer<String> pipe( String command, PrintStream out, PrintStream err ) {
    @Nullable Object fn = runCommand( command, out, err );

    if ( fn instanceof IFn ) {
        return ( line ) -> {
            @Nullable Object result = ( ( IFn ) fn ).invoke( line );
            if ( result != null ) {
                out.println( result );
            }
        };
    }

    throw new RuntimeException( "When used in a pipeline, the Clojure script must return a " +
            "lambda that takes one text line of the input at a time.\n" +
            "Example:\nsome-command | clj (fn [line] (str \"- \" line))" );
}
 

import clojure.lang.IFn; //导入依赖的package包/类
@EventHandler
public void onPreInitialization(FMLPreInitializationEvent event) {
	logger = event.getModLog();
	
	String path = "./mods/cljsh-mods/";
	File directory = new File(path);
	File[] fileListing = directory.listFiles();
	for (File file : fileListing) {
		if (file.isFile() && file.getName().endsWith(".mod.clj")) {
			String contents = "";
			try {
				contents = new String(Files.readAllBytes(Paths.get(file.getAbsolutePath())));
			} catch (IOException e1) {
				// TODO Auto-generated catch block
				e1.printStackTrace();
			}

			IFn mainFunction = (IFn) execute(contents);

			mainFunction.invoke(this);
			
			logger.info("Cljsh sucsessfully loaded " + file.getName());
		}
	}
}
 

import clojure.lang.IFn; //导入依赖的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.lang.IFn; //导入依赖的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.lang.IFn; //导入依赖的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.lang.IFn; //导入依赖的package包/类
@Override
public void prepare(final Map stormConf, final TopologyContext context, final OutputCollector collector) {
    IFn hof = Utils.loadClojureFn(_fnSpec.get(0), _fnSpec.get(1));
    try {
        IFn preparer = (IFn) hof.applyTo(RT.seq(_params));
        final Map<Keyword,Object> collectorMap = new PersistentArrayMap( new Object[] {
            Keyword.intern(Symbol.create("output-collector")), collector,
            Keyword.intern(Symbol.create("context")), context});
        List<Object> args = new ArrayList<Object>() {{
            add(stormConf);
            add(context);
            add(collectorMap);
        }};
        
        _bolt = (IBolt) preparer.applyTo(RT.seq(args));
        //this is kind of unnecessary for clojure
        try {
            _bolt.prepare(stormConf, context, collector);
        } catch(AbstractMethodError ame) {
            
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

import clojure.lang.IFn; //导入依赖的package包/类
@Override
public void open(final Map conf, final TopologyContext context, final SpoutOutputCollector collector) {
    IFn hof = Utils.loadClojureFn(_fnSpec.get(0), _fnSpec.get(1));
    try {
        IFn preparer = (IFn) hof.applyTo(RT.seq(_params));
        final Map<Keyword,Object> collectorMap = new PersistentArrayMap( new Object[] {
            Keyword.intern(Symbol.create("output-collector")), collector,
            Keyword.intern(Symbol.create("context")), context});
        List<Object> args = new ArrayList<Object>() {{
            add(conf);
            add(context);
            add(collectorMap);
        }};
        
        _spout = (ISpout) preparer.applyTo(RT.seq(args));
        //this is kind of unnecessary for clojure
        try {
            _spout.open(conf, context, collector);
        } catch(AbstractMethodError ame) {
            
        }
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}
 

import clojure.lang.IFn; //导入依赖的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.lang.IFn; //导入依赖的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.lang.IFn; //导入依赖的package包/类
public boolean serverClose(int status) {
    if (!unsafe.compareAndSwapInt(this, closedRanOffset, 0, 1)) {
        return false; // already closed
    }
    if (isWebSocket()) {
        server.tryWrite(key, WsEncode(OPCODE_CLOSE, ByteBuffer.allocate(2)
                .putShort((short) status).array()));
    } else {
        server.tryWrite(key, ByteBuffer.wrap(finalChunkBytes));
    }
    IFn f = closeHandler;
    if (f != null) {
        f.invoke(readable(0)); // server close is 0
    }
    return true;
}
 

import clojure.lang.IFn; //导入依赖的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.lang.IFn; //导入依赖的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.lang.IFn; //导入依赖的package包/类
@SuppressWarnings({"WeakerAccess", "SameParameterValue"})
public void registerEvent(final Class<? extends Event> event, final EventPriority priority, final IFn method, final boolean ignoreCancelled) {
    Set<IFn> methods = events.getOrDefault(event, new HashSet<>());
    methods.add(method);
    events.put(event, methods);
    getServer().getPluginManager().registerEvent(event, new Listener() {
    }, priority, executor, this, ignoreCancelled);
}