switch (n.type) { case Node.LITERAL: addToList(new LiteralConverter<E>((String) n.getValue())); break; case Node.COMPOSITE_KEYWORD: CompositeNode cn = (CompositeNode) n; CompositeConverter<E> compositeConverter = createCompositeConverter(cn); if(compositeConverter == null) { addError("Failed to create converter for [%"+cn.getValue()+"] keyword"); addToList(new LiteralConverter<E>("%PARSER_ERROR["+cn.getValue()+"]")); break; Compiler<E> childCompiler = new Compiler<E>(cn.getChildNode(), converterMap); childCompiler.setContext(context); Converter<E> childConverter = childCompiler.compile(); compositeConverter.setChildConverter(childConverter); addToList(compositeConverter); break; case Node.SIMPLE_KEYWORD: SimpleKeywordNode kn = (SimpleKeywordNode) n; DynamicConverter<E> dynaConverter = createConverter(kn); if (dynaConverter != null) { dynaConverter.setFormattingInfo(kn.getFormatInfo()); dynaConverter.setOptionList(kn.getOptions()); addToList(dynaConverter); } else { addStatus(new ErrorStatus("[" + kn.getValue()
/** * When the parsing step is done, the Node list can be transformed into a * converter chain. * * @param top * @param converterMap * @return * @throws ScanException */ public Converter<E> compile(final Node top, Map converterMap) { Compiler<E> compiler = new Compiler<E>(top, converterMap); compiler.setContext(context); //compiler.setStatusManager(statusManager); return compiler.compile(); }
switch (n.type) { case Node.LITERAL: addToList(new LiteralConverter<E>((String) n.getValue())); break; case Node.COMPOSITE: CompositeConverter<E> compositeConverter = new CompositeConverter<E>(); compositeConverter.setFormattingInfo(cn.getFormatInfo()); Compiler<E> childCompiler = new Compiler<E>(cn.getChildNode(), converterMap); childCompiler.setContext(context); Converter<E> childConverter = childCompiler.compile(); compositeConverter.setChildConverter(childConverter); addToList(compositeConverter); break; case Node.KEYWORD: KeywordNode kn = (KeywordNode) n; DynamicConverter<E> dynaConverter = createConverter(kn); if (dynaConverter != null) { dynaConverter.setFormattingInfo(kn.getFormatInfo()); dynaConverter.setOptionList(kn.getOptions()); addToList(dynaConverter); } else { addStatus(new ErrorStatus("[" + kn.getValue() + "] is not a valid conversion word", this)); addToList(errConveter);
/** * Attempt to create a converter using the information found in * 'converterMap'. * * @param kn * @return */ @SuppressWarnings("unchecked") DynamicConverter<E> createConverter(SimpleKeywordNode kn) { String keyword = (String) kn.getValue(); String converterClassStr = (String) converterMap.get(keyword); if (converterClassStr != null) { try { return (DynamicConverter) OptionHelper.instantiateByClassName( converterClassStr, DynamicConverter.class, context); } catch (Exception e) { addError("Failed to instantiate converter class [" + converterClassStr + "] for keyword ["+keyword+"]", e); return null; } } else { addError("There is no conversion class registered for conversion word [" + keyword + "]"); return null; } }
/** * When the parsing step is done, the Node list can be transformed into a * converter chain. * * @param top the top node * @param converterMap converter map * @return the converter chain */ public Converter<E> compile(final Node top, Map<String, String> converterMap) { Compiler<E> compiler = new Compiler<E>(top, converterMap); compiler.setContext(context); //compiler.setStatusManager(statusManager); return compiler.compile(); }
/** * Attempt to create a converter using the information found in * 'compositeConverterMap'. * * @param cn * @return */ @SuppressWarnings("unchecked") CompositeConverter<E> createCompositeConverter(CompositeNode cn) { String keyword = (String) cn.getValue(); String converterClassStr = (String) converterMap.get(keyword); if (converterClassStr != null) { try { return (CompositeConverter) OptionHelper.instantiateByClassName( converterClassStr, CompositeConverter.class, context); } catch (Exception e) { addError("Failed to instantiate converter class [" + converterClassStr + "] as a composite converter for keyword ["+keyword+"]", e); return null; } } else { addError("There is no conversion class registered for composite conversion word [" + keyword + "]"); return null; } }
switch (n.type) { case Node.LITERAL: addToList(new LiteralConverter<E>((String) n.getValue())); break; case Node.COMPOSITE_KEYWORD: CompositeNode cn = (CompositeNode) n; CompositeConverter<E> compositeConverter = createCompositeConverter(cn); if(compositeConverter == null) { addError("Failed to create converter for [%"+cn.getValue()+"] keyword"); addToList(new LiteralConverter<E>("%PARSER_ERROR["+cn.getValue()+"]")); break; Compiler<E> childCompiler = new Compiler<E>(cn.getChildNode(), converterMap); childCompiler.setContext(context); Converter<E> childConverter = childCompiler.compile(); compositeConverter.setChildConverter(childConverter); addToList(compositeConverter); break; case Node.SIMPLE_KEYWORD: SimpleKeywordNode kn = (SimpleKeywordNode) n; DynamicConverter<E> dynaConverter = createConverter(kn); if (dynaConverter != null) { dynaConverter.setFormattingInfo(kn.getFormatInfo()); dynaConverter.setOptionList(kn.getOptions()); addToList(dynaConverter); } else { addStatus(new ErrorStatus("[" + kn.getValue()
/** * When the parsing step is done, the Node list can be transformed into a * converter chain. * * @param top * @param converterMap * @return * @throws ScanException */ public Converter<E> compile(final Node top, Map converterMap) { Compiler<E> compiler = new Compiler<E>(top, converterMap); compiler.setContext(context); // compiler.setStatusManager(statusManager); return compiler.compile(); }
/** * Attempt to create a converter using the information found in * 'converterMap'. * * @param kn * @return */ @SuppressWarnings("unchecked") DynamicConverter<E> createConverter(SimpleKeywordNode kn) { String keyword = (String) kn.getValue(); String converterClassStr = (String) converterMap.get(keyword); if (converterClassStr != null) { try { return (DynamicConverter) OptionHelper.instantiateByClassName(converterClassStr, DynamicConverter.class, context); } catch (Exception e) { addError("Failed to instantiate converter class [" + converterClassStr + "] for keyword [" + keyword + "]", e); return null; } } else { addError("There is no conversion class registered for conversion word [" + keyword + "]"); return null; } }
switch (n.type) { case Node.LITERAL: addToList(new LiteralConverter<E>((String) n.getValue())); break; case Node.COMPOSITE_KEYWORD: CompositeNode cn = (CompositeNode) n; CompositeConverter<E> compositeConverter = createCompositeConverter(cn); if (compositeConverter == null) { addError("Failed to create converter for [%" + cn.getValue() + "] keyword"); addToList(new LiteralConverter<E>("%PARSER_ERROR[" + cn.getValue() + "]")); break; Compiler<E> childCompiler = new Compiler<E>(cn.getChildNode(), converterMap); childCompiler.setContext(context); Converter<E> childConverter = childCompiler.compile(); compositeConverter.setChildConverter(childConverter); addToList(compositeConverter); break; case Node.SIMPLE_KEYWORD: SimpleKeywordNode kn = (SimpleKeywordNode) n; DynamicConverter<E> dynaConverter = createConverter(kn); if (dynaConverter != null) { dynaConverter.setFormattingInfo(kn.getFormatInfo()); dynaConverter.setOptionList(kn.getOptions()); addToList(dynaConverter); } else { addStatus(new ErrorStatus("[" + kn.getValue() + "] is not a valid conversion word", this)); addToList(errConveter);
/** * When the parsing step is done, the Node list can be transformed into a * converter chain. * * @param top * @param converterMap * @return * @throws ScanException */ public Converter<E> compile(final Node top, Map converterMap) { Compiler<E> compiler = new Compiler<E>(top, converterMap); compiler.setContext(context); //compiler.setStatusManager(statusManager); return compiler.compile(); }
/** * Attempt to create a converter using the information found in * 'compositeConverterMap'. * * @param cn * @return */ @SuppressWarnings("unchecked") CompositeConverter<E> createCompositeConverter(CompositeNode cn) { String keyword = (String) cn.getValue(); String converterClassStr = (String) converterMap.get(keyword); if (converterClassStr != null) { try { return (CompositeConverter<E>) OptionHelper.instantiateByClassName( converterClassStr, CompositeConverter.class, context); } catch (Exception e) { addError("Failed to instantiate converter class [" + converterClassStr + "] as a composite converter for keyword ["+keyword+"]", e); return null; } } else { addError("There is no conversion class registered for composite conversion word [" + keyword + "]"); return null; } }
switch (n.type) { case Node.LITERAL: addToList(new LiteralConverter<E>((String) n.getValue())); break; case Node.COMPOSITE_KEYWORD: CompositeNode cn = (CompositeNode) n; CompositeConverter<E> compositeConverter = createCompositeConverter(cn); if (compositeConverter == null) { addError("Failed to create converter for [%" + cn.getValue() + "] keyword"); addToList(new LiteralConverter<E>("%PARSER_ERROR[" + cn.getValue() + "]")); break; Compiler<E> childCompiler = new Compiler<E>(cn.getChildNode(), converterMap); childCompiler.setContext(context); Converter<E> childConverter = childCompiler.compile(); compositeConverter.setChildConverter(childConverter); addToList(compositeConverter); break; case Node.SIMPLE_KEYWORD: SimpleKeywordNode kn = (SimpleKeywordNode) n; DynamicConverter<E> dynaConverter = createConverter(kn); if (dynaConverter != null) { dynaConverter.setFormattingInfo(kn.getFormatInfo()); dynaConverter.setOptionList(kn.getOptions()); addToList(dynaConverter); } else { addStatus(new ErrorStatus("[" + kn.getValue() + "] is not a valid conversion word", this)); addToList(errConveter);
/** * When the parsing step is done, the Node list can be transformed into a * converter chain. * * @param top * @param converterMap * @return * @throws ScanException */ public Converter<E> compile(final Node top, Map converterMap) { Compiler<E> compiler = new Compiler<E>(top, converterMap); compiler.setContext(context); //compiler.setStatusManager(statusManager); return compiler.compile(); }
/** * Attempt to create a converter using the information found in * 'compositeConverterMap'. * * @param cn * @return */ @SuppressWarnings("unchecked") CompositeConverter<E> createCompositeConverter(CompositeNode cn) { String keyword = (String) cn.getValue(); String converterClassStr = (String) converterMap.get(keyword); if (converterClassStr != null) { try { return (CompositeConverter) OptionHelper.instantiateByClassName(converterClassStr, CompositeConverter.class, context); } catch (Exception e) { addError("Failed to instantiate converter class [" + converterClassStr + "] as a composite converter for keyword [" + keyword + "]", e); return null; } } else { addError("There is no conversion class registered for composite conversion word [" + keyword + "]"); return null; } }
switch (n.type) { case Node.LITERAL: addToList(new LiteralConverter<E>((String) n.getValue())); break; case Node.COMPOSITE_KEYWORD: CompositeNode cn = (CompositeNode) n; CompositeConverter<E> compositeConverter = createCompositeConverter(cn); if(compositeConverter == null) { addError("Failed to create converter for [%"+cn.getValue()+"] keyword"); addToList(new LiteralConverter<E>("%PARSER_ERROR["+cn.getValue()+"]")); break; Compiler<E> childCompiler = new Compiler<E>(cn.getChildNode(), converterMap); childCompiler.setContext(context); Converter<E> childConverter = childCompiler.compile(); compositeConverter.setChildConverter(childConverter); addToList(compositeConverter); break; case Node.SIMPLE_KEYWORD: SimpleKeywordNode kn = (SimpleKeywordNode) n; DynamicConverter<E> dynaConverter = createConverter(kn); if (dynaConverter != null) { dynaConverter.setFormattingInfo(kn.getFormatInfo()); dynaConverter.setOptionList(kn.getOptions()); addToList(dynaConverter); } else { addStatus(new ErrorStatus("[" + kn.getValue()
/** * When the parsing step is done, the Node list can be transformed into a * converter chain. * * @param top * @param converterMap * @return * @throws ScanException */ public Converter<E> compile(final Node top, Map converterMap) { Compiler<E> compiler = new Compiler<E>(top, converterMap); compiler.setContext(context); //compiler.setStatusManager(statusManager); return compiler.compile(); }
/** * Attempt to create a converter using the information found in * 'converterMap'. * * @param kn * @return */ @SuppressWarnings("unchecked") DynamicConverter<E> createConverter(SimpleKeywordNode kn) { String keyword = (String) kn.getValue(); String converterClassStr = (String) converterMap.get(keyword); if (converterClassStr != null) { try { return (DynamicConverter) OptionHelper.instantiateByClassName(converterClassStr, DynamicConverter.class, context); } catch (Exception e) { addError("Failed to instantiate converter class [" + converterClassStr + "] for keyword [" + keyword + "]", e); return null; } } else { addError("There is no conversion class registered for conversion word [" + keyword + "]"); return null; } }
switch (n.type) { case Node.LITERAL: addToList(new LiteralConverter<E>((String) n.getValue())); break; case Node.COMPOSITE_KEYWORD: CompositeNode cn = (CompositeNode) n; CompositeConverter<E> compositeConverter = createCompositeConverter(cn); if(compositeConverter == null) { addError("Failed to create converter for [%"+cn.getValue()+"] keyword"); addToList(new LiteralConverter<E>("%PARSER_ERROR["+cn.getValue()+"]")); break; Compiler<E> childCompiler = new Compiler<E>(cn.getChildNode(), converterMap); childCompiler.setContext(context); Converter<E> childConverter = childCompiler.compile(); compositeConverter.setChildConverter(childConverter); addToList(compositeConverter); break; case Node.SIMPLE_KEYWORD: SimpleKeywordNode kn = (SimpleKeywordNode) n; DynamicConverter<E> dynaConverter = createConverter(kn); if (dynaConverter != null) { dynaConverter.setFormattingInfo(kn.getFormatInfo()); dynaConverter.setOptionList(kn.getOptions()); addToList(dynaConverter); } else { addStatus(new ErrorStatus("[" + kn.getValue()
/** * When the parsing step is done, the Node list can be transformed into a * converter chain. * * @param top * @param converterMap * @return * @throws ScanException */ public Converter<E> compile(final Node top, Map converterMap) { Compiler<E> compiler = new Compiler<E>(top, converterMap); compiler.setContext(context); // compiler.setStatusManager(statusManager); return compiler.compile(); }