private Keyword makeKeyword(String name) { return Keyword.intern(Symbol.create(name)); }
private final Keyword makeKeyword(String name) { return Keyword.intern(Symbol.create(name)); }
@SuppressWarnings("unchecked") @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 ignored) { } } catch (Exception e) { throw new RuntimeException(e); } }
@SuppressWarnings("unchecked") @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 ignored) { } } catch (Exception e) { throw new RuntimeException(e); } }
@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); } }
@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); } }
@Override public Object eval(Reader reader, ScriptContext context) throws ScriptException { try { // Get engine bindings and send them to Clojure Bindings engineBindings = context.getBindings(ScriptContext.ENGINE_SCOPE); engineBindings.entrySet().forEach((entry) -> Var.intern(Namespace.findOrCreate(NAMESPACE_SYMBOL), Symbol.create(entry.getKey().intern()), entry.getValue(), true)); Var.pushThreadBindings( RT.map(RT.CURRENT_NS, RT.CURRENT_NS.deref(), RT.IN, new LineNumberingPushbackReader(context.getReader()), RT.OUT, context.getWriter(), RT.ERR, context.getErrorWriter())); Object result = Compiler.load(reader); return result; } catch (Exception e) { throw new ScriptException(e); } finally { Namespace.remove(NAMESPACE_SYMBOL); } }
@Override public Symbol mapMethod(String namespace, Method method) { FunctionName annotation = method.getAnnotation(FunctionName.class); if (annotation == null) { return null; } String name = annotation.value(); if (name.contains("/")) { return Symbol.create(name); } return Symbol.create(namespace, name); } }
private Symbol mapMethodName(String namespace, String name) { return Symbol.create(namespace, transformName(name)); }
private final Keyword makeKeyword(String name) { return Keyword.intern(Symbol.create(name)); }
private Keyword makeKeyword(String name) { return Keyword.intern(Symbol.create(name)); }
private final Keyword makeKeyword(String name) { return Keyword.intern(Symbol.create(name)); }
public void write(Writer writer, Map<String, Object> stringObjectMap, Model model) throws IOException { try { final Var REQUIRE = Var.intern(RT.CLOJURE_NS, Symbol.create("require")); final Symbol REFLECTOR = Symbol.create("org.sonatype.maven.polyglot.clojure.dsl.writer"); REQUIRE.invoke(REFLECTOR); final Var WRITER = Var.intern(Namespace.findOrCreate(REFLECTOR), Symbol.create("write-model")); WRITER.invoke(model, writer); } catch (Exception e) { e.printStackTrace(); // Don't use new IOException(e) because it doesn't exist in Java 5 throw (IOException) new IOException(e.toString()).initCause(e); } }
protected Var var(String namespacedFunction) { ClassLoader origLoader = preInvoke(); try { Var var = (Var)this.resolve.invoke(Symbol.create(namespacedFunction)); if (var == null) { String[] parts = namespacedFunction.split("/"); this.require.invoke(Symbol.create(parts[0])); var = RT.var(parts[0], parts[1]); } return var; } catch (Exception e) { throw new RuntimeException( "Failed to load Var " + namespacedFunction, e ); } finally { postInvoke( origLoader ); } }
protected Var var(String namespacedFunction) { ClassLoader origLoader = preInvoke(); try { Var var = (Var)this.resolve.invoke(Symbol.create(namespacedFunction)); if (var == null) { String[] parts = namespacedFunction.split("/"); this.require.invoke(Symbol.create(parts[0])); var = RT.var(parts[0], parts[1]); } return var; } catch (Exception e) { throw new RuntimeException( "Failed to load Var " + namespacedFunction, e ); } finally { postInvoke( origLoader ); } }
private Associative applyBindings(final Map<String, Object> bindings, Associative mappings) { if (bindings != null) { final Set<Entry<String, Object>> entrySet = bindings.entrySet(); for (final Entry<String, Object> entry : entrySet) { final Symbol symbol = Symbol.intern(entry.getKey()); final Namespace userNs = Namespace.findOrCreate(Symbol.create("user".intern())); final Var var = Var.intern(userNs, symbol); var.setDynamic(true); mappings = mappings.assoc(var, entry.getValue()); } } return mappings; }
@Override public void require(String... namespaces) { ClassLoader origLoader = preInvoke(); try { for (String ns : namespaces) { this.require.invoke(Symbol.create(ns)); } } finally { postInvoke(origLoader); } }
private Associative applyBindings(final Map<String, Object> bindings, Associative mappings) { if (bindings != null) { final Set<Entry<String, Object>> entrySet = bindings.entrySet(); for (final Entry<String, Object> entry : entrySet) { final Symbol symbol = Symbol.intern(entry.getKey()); final Namespace userNs = Namespace.findOrCreate(Symbol .create("user".intern())); final Var var = Var.intern(userNs, symbol); mappings = mappings.assoc(var, entry.getValue()); } } return mappings; }
@Override public void require(String... namespaces) { ClassLoader origLoader = preInvoke(); try { for (String ns : namespaces) { this.require.invoke(Symbol.create(ns)); } } finally { postInvoke(origLoader); } }
public static void importClojure(String name, Type t) { Var cv=Clojure.var(name); if (cv==null) throw new IllegalArgumentException("Can't import Clojure var: "+name); Object value=cv.deref(); if (t instanceof AFunctionType) { value=new WrappedFn((IFn)value,(AFunctionType)t); } ENVIRONMENT=ENVIRONMENT.define(Symbol.create(name), Constant.create(t, value)); }