ObjectWrapped<Object> getObject(String qualifiedName, ParserRuleContext ctx) { try { logger.debug("Load ing {} with {}", qualifiedName, classLoader); Class<?> objectClass = classLoader.loadClass(qualifiedName); AbstractBuilder<?> builder = AbstractBuilder.resolve(objectClass); return new ObjectWrapped<Object>(builder != null ? builder: objectClass.newInstance()); } catch (ClassNotFoundException e) { throw new RecognitionException("Unknown class " + qualifiedName, parser, stream, ctx); } catch (InstantiationException | IllegalAccessException e) { throw new RecognitionException("Unsuable class " + qualifiedName, parser, stream, ctx); } }
/** * We use a general RecognitionException with a particular text to signal to * the error strategy what type of issue we found. * * @param text * Label to indicate error type * @param parser * @return The recognition exception */ private RecognitionException getException(String text, Parser parser) { return new RecognitionException(text, parser, parser.getInputStream(), parser.getRuleContext()); }
/** * throws RecognitionException to handle in parser's catch block */ public Token recoverInline(Parser recognizer) throws RecognitionException { throw new RecognitionException(recognizer, recognizer.getInputStream(), recognizer.getContext()); }
/** * We use a general RecognitionException with a particular text to signal to * the error strategy what type of issue we found. * * @param text * Label to indicate error type * @param parser * @return The recognition exception */ private RecognitionException getException(String text, Parser parser) { return new RecognitionException(text, parser, parser.getInputStream(), parser.getRuleContext()); }
@Override public void exitProperty(PropertyContext ctx) { Object value = stack.pop(); String key = ctx.propertyName().getText(); // Avoid reprocess already processed properties if (!lockedProperties.contains(key)) { properties.put(key, value); } else { throw new RecognitionException("redefined property", parser, stream, ctx); } }
/** * throws RecognitionException to handle in parser's catch block */ public Token recoverInline(Parser recognizer) throws RecognitionException { throw new RecognitionException(recognizer, recognizer.getInputStream(), recognizer.getContext()); }
@Override public void exitOutput(OutputContext ctx) { PipeRefName piperef; @SuppressWarnings("unchecked") List<ObjectWrapped<Sender>> senders = (List<ObjectWrapped<Sender>>) stack.pop(); if(stack.peek() != null && stack.peek() instanceof PipeRefName) { piperef = (PipeRefName) stack.pop(); } else { // if no pipe name given, take events from the main pipe piperef = new PipeRefName("main"); } if (outputPipelines.contains(piperef.piperef)) { throw new RecognitionException("already sent pipeline " + piperef.piperef, parser, stream, ctx); } outputPipelines.add(piperef.piperef); Output output = new Output(senders, piperef.piperef); outputs.add(output); logger.debug("adding new output {}", output); }
private void doBean(String beanName, ObjectWrapped<Object> beanValue, ParserRuleContext ctx) { ObjectWrapped<Object> beanObject = stack.peekTyped(); assert (beanName != null); assert (beanValue != null); try { if (beanObject.wrapped instanceof AbstractBuilder) { @SuppressWarnings("unchecked") AbstractBuilder<Object> builder = (AbstractBuilder<Object>) beanObject.wrapped; builder.set(beanName, beanValue.wrapped); } else { BeansManager.beanSetter(beanObject.wrapped, beanName, beanValue.wrapped); } } catch (IntrospectionException | InvocationTargetException e) { throw new RecognitionException(Helpers.resolveThrowableException(e), parser, stream, ctx); } }
@SuppressWarnings("unchecked") @Override public void exitMap(MapContext ctx) { if (ctx.source() == null) { Map<Object, Object> map = new HashMap<>(); Object o; while((o = stack.pop()) != StackMarker.Map) { Object value; if (o instanceof ObjectWrapped) { value = ((ObjectWrapped<Object>) o).wrapped; } else { value = o.getClass(); } ObjectWrapped<Object> key = (ObjectWrapped<Object>) stack.pop(); map.put(key.wrapped, value); }; stack.push(new ObjectWrapped<Map<?, ?>>(map)); } else { Object o = stack.pop(); assert o == ConfigListener.StackMarker.Map; // Don't forget to remove the initial % String sourceName = ctx.source().getText().substring(1); if (! sources.containsKey(sourceName)) { throw new RecognitionException("Undefined source " + sourceName, parser, stream, ctx); } Source s = sources.get(sourceName).source; stack.push(new ObjectWrapped<Source>(s)); } }
@SuppressWarnings("unchecked") @Override public void exitFire(FireContext ctx) { FireEvent fire = new FireEvent(); Map<String[], String> fields = new HashMap<>(); int count = ctx.eventVariable().size() - 1; while(! StackMarker.Fire.equals(stack.peek()) ) { Object o = stack.pop(); if(o instanceof ObjectWrapped) { String[] lvalue = convertEventVariable(ctx.eventVariable().get(count--)); fields.put(lvalue, ((ObjectWrapped<String>) o).wrapped); } else if (o instanceof PipeRefName){ PipeRefName name = (PipeRefName) o; fire.setDestination(name.piperef); } else { throw new RecognitionException("invalid fire argument: " + o.toString(), parser, stream, ctx); } } fire.setFields(fields); stack.pop(); stack.push(new ObjectWrapped<FireEvent>(fire)); }
private void resolveSources(ConfigurationContext tree, ConfigListener conflistener) throws ConfigException { for (SourcesContext sc: tree.sources()) { for (SourcedefContext sdc: sc.sourcedef()) { String name = sdc.identifier().getText(); if (! conflistener.sources.containsKey("name")) { String className = sdc.object().QualifiedIdentifier().getText(); // Pre-create source object ConfigListener.SourceProvider sp = new ConfigListener.SourceProvider(); sp.source = (Source) conflistener.getObject(className, sdc).wrapped; conflistener.sources.put(name, sp); } else { throw new RecognitionException("Source redifined", conflistener.parser, conflistener.stream, sdc); } } } }
public void sync(Parser recognizer) throws RecognitionException { ATNState s = recognizer.getInterpreter().atn.states.get(recognizer.getState()); if (!this.inErrorRecoveryMode(recognizer)) { TokenStream tokens = recognizer.getInputStream(); int la = tokens.LA(1); if (!recognizer.getATN().nextTokens(s).contains(la) && la != -1) { if (!recognizer.isExpectedToken(la)) { switch (s.getStateType()) { case 3: case 4: case 5: case 10: throw new RecognitionException(recognizer, tokens, recognizer.getContext()); case 9: case 11: //added this.reportUnwantedToken(recognizer); throw new RecognitionException(recognizer, tokens, recognizer.getContext()); case 6: case 7: case 8: default: } } } } }
public void sync(Parser recognizer) throws RecognitionException { ATNState s = recognizer.getInterpreter().atn.states.get(recognizer.getState()); if (!this.inErrorRecoveryMode(recognizer)) { TokenStream tokens = recognizer.getInputStream(); int la = tokens.LA(1); if (!recognizer.getATN().nextTokens(s).contains(la) && la != -1) { if (!recognizer.isExpectedToken(la)) { switch (s.getStateType()) { case 3: case 4: case 5: case 10: throw new RecognitionException(recognizer, tokens, recognizer.getContext()); case 9: case 11: //added this.reportUnwantedToken(recognizer); throw new RecognitionException(recognizer, tokens, recognizer.getContext()); case 6: case 7: case 8: default: } } } } }
throw new RecognitionException("Context can't be a lvalue for " + ctx.getText(), parser, stream, ctx); throw new RecognitionException("invalid operator " + ctx.op.getText(), parser, stream, ctx);