Java Examples for org.yaml.snakeyaml.events.Event

/*
	 * (non-Javadoc)
	 * @see org.xml.sax.XMLReader#parse(org.xml.sax.InputSource)
	 */
public void parse(InputSource yamlInputSource) throws IOException, SAXException {
    if (contentHandler == null) {
        throw new IllegalStateException("'contentHandler' not set.  Cannot parse YAML stream.");
    }
    if (executionContext == null) {
        throw new IllegalStateException("Smooks container 'executionContext' not set.  Cannot parse YAML stream.");
    }
    try {
        // Get a reader for the YAML source...
        Reader yamlStreamReader = yamlInputSource.getCharacterStream();
        if (yamlStreamReader == null) {
            throw new SmooksException("The InputSource doesn't provide a Reader character stream. Make sure that you supply a reader to the Smooks.filterSource method.");
        }
        YamlToSaxHandler yamlToSaxHandler = new YamlToSaxHandler(contentHandler, anchorAttributeName, aliasAttributeName, indent);
        EventHandler eventHandler;
        if (aliasStrategy == AliasStrategy.REFER) {
            eventHandler = new AliasReferencingEventHandler(yamlToSaxHandler);
        } else {
            eventHandler = new AliasResolvingEventHandler(yamlEventStreamParser, yamlToSaxHandler, aliasStrategy == AliasStrategy.REFER_RESOLVE);
        }
        if (logger.isTraceEnabled()) {
            logger.trace("Starting YAML parsing");
        }
        Iterable<Event> yamlEventStream = yaml.parse(yamlStreamReader);
        // Start the document and add the root  element...
        contentHandler.startDocument();
        yamlToSaxHandler.startElementStructure(rootName, null, false);
        yamlEventStreamParser.handle(eventHandler, yamlEventStream);
        yamlToSaxHandler.endElementStructure(rootName);
        contentHandler.endDocument();
    } finally {
        contentHandler = null;
        executionContext = null;
    }
}

private boolean needMoreEvents() {
    if (events.isEmpty()) {
        return true;
    }
    Event event = events.peek();
    if (event instanceof DocumentStartEvent) {
        return needEvents(1);
    } else if (event instanceof SequenceStartEvent) {
        return needEvents(2);
    } else if (event instanceof MappingStartEvent) {
        return needEvents(3);
    } else {
        return false;
    }
}

/**
     * Validate the passed style
     * @param input Reader for the style
     * @return List of {@link MarkedYAMLException} representing any errors, or an empty list if the style is valid
     * @throws IOException
     */
public List<MarkedYAMLException> validate(Reader input) throws IOException {
    YsldValidateContext context = new YsldValidateContext();
    context.zCtxtFinders = this.zCtxtFinders;
    context.push(new RootValidator());
    try {
        Yaml yaml = new Yaml();
        for (Event evt : yaml.parse(input)) {
            YsldValidateHandler h = context.peek();
            if (evt instanceof MappingStartEvent) {
                h.mapping((MappingStartEvent) evt, context);
            } else if (evt instanceof MappingEndEvent) {
                h.endMapping((MappingEndEvent) evt, context);
            } else if (evt instanceof SequenceStartEvent) {
                h.sequence((SequenceStartEvent) evt, context);
            } else if (evt instanceof SequenceEndEvent) {
                h.endSequence((SequenceEndEvent) evt, context);
            } else if (evt instanceof ScalarEvent) {
                h.scalar((ScalarEvent) evt, context);
            } else if (evt instanceof AliasEvent) {
                h.alias((AliasEvent) evt, context);
            }
        }
        ;
    } catch (MarkedYAMLException e) {
        context.error(e);
    } catch (EmptyStackException e) {
        throw new RuntimeException("Error parsing CQL expression", e);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
    return context.errors();
}

/**
     * Configuration from a YAML reader.
     */
public static Map<String, String> yamlAsConfiguration(BufferedReader reader) {
    Map<String, String> configuration = new LinkedHashMap<String, String>();
    Iterable<Event> events = YAML.parse(reader);
    List<String> keyFragments = new ArrayList<String>();
    List<String> composants = new ArrayList<String>();
    String keyFragment = null;
    for (Event event : events) {
        if (event instanceof ScalarEvent) {
            String value = ((ScalarEvent) event).getValue();
            if (keyFragment == null) {
                keyFragment = value;
                if (!keyFragments.isEmpty()) {
                    String lastFragment = last(keyFragments);
                    if (isAComponentList(lastFragment)) {
                        composants.add(keyFragment);
                    }
                }
            } else {
                String dottedKey = Joiner.on(".").join(keyFragments) + '.' + keyFragment;
                configuration.put(dottedKey, value);
                keyFragment = null;
            }
        } else if (event instanceof MappingStartEvent) {
            if (keyFragment != null) {
                keyFragments.add(keyFragment);
                keyFragment = null;
            }
        } else if (event instanceof MappingEndEvent) {
            if (!keyFragments.isEmpty()) {
                String lastFragment = last(keyFragments);
                if (isAComponentList(lastFragment)) {
                    String dottedKey = Joiner.on(".").join(keyFragments);
                    String value = Joiner.on(' ').join(composants);
                    configuration.put(dottedKey, value);
                    composants.clear();
                }
                keyFragments.remove(keyFragments.size() - 1);
            }
        }
    }
    return configuration;
}

private boolean needMoreEvents() {
    if (events.isEmpty()) {
        return true;
    }
    Event event = events.peek();
    if (event instanceof DocumentStartEvent) {
        return needEvents(1);
    } else if (event instanceof SequenceStartEvent) {
        return needEvents(2);
    } else if (event instanceof MappingStartEvent) {
        return needEvents(3);
    } else {
        return false;
    }
}

private boolean needMoreEvents() {
    if (events.isEmpty()) {
        return true;
    }
    Event event = events.peek();
    if (event instanceof DocumentStartEvent) {
        return needEvents(1);
    } else if (event instanceof SequenceStartEvent) {
        return needEvents(2);
    } else if (event instanceof MappingStartEvent) {
        return needEvents(3);
    } else {
        return false;
    }
}

private void writeClassReaders(ModelClass modelClass, JClass jClass, boolean rootElement) {
    JavaClassMetadata javaClassMetadata = (JavaClassMetadata) modelClass.getMetadata(JavaClassMetadata.class.getName());
    // Skip abstract classes, no way to parse them out into objects
    if (javaClassMetadata.isAbstract()) {
        return;
    }
    XmlClassMetadata xmlClassMetadata = (XmlClassMetadata) modelClass.getMetadata(XmlClassMetadata.ID);
    if (!rootElement && !xmlClassMetadata.isStandaloneRead()) {
        return;
    }
    String className = modelClass.getName();
    String capClassName = capitalise(className);
    String readerMethodName = "read";
    if (!rootElement) {
        readerMethodName += capClassName;
    }
    // ----------------------------------------------------------------------
    // Write the read(Parser) method which will do the unmarshalling.
    // ----------------------------------------------------------------------
    JMethod unmarshall = new JMethod(readerMethodName, new JClass(className), null);
    unmarshall.getModifiers().makePrivate();
    unmarshall.addParameter(new JParameter(new JClass("Parser"), "parser"));
    unmarshall.addParameter(new JParameter(JClass.BOOLEAN, "strict"));
    addTrackingParameters(unmarshall);
    unmarshall.addException(new JClass("IOException"));
    JSourceCode sc = unmarshall.getSourceCode();
    String variableName = uncapitalise(className);
    sc.add("Event event;");
    sc.add("if ( !( event = parser.getEvent() ).is( Event.ID.StreamStart ) )");
    sc.add("{");
    sc.addIndented("throw new ParserException( \"Expected Stream Start event\", event.getStartMark(), \"\", null );");
    sc.add("}");
    sc.add("if ( !( event = parser.getEvent() ).is( Event.ID.DocumentStart ) )");
    sc.add("{");
    sc.addIndented("throw new ParserException( \"Expected Document Start event\", event.getStartMark(), \"\", null );");
    sc.add("}");
    sc.add("");
    sc.add(className + ' ' + variableName + " = parse" + capClassName + "( parser, strict" + trackingArgs + " );");
    if (rootElement) {
    // TODO
    // sc.add( variableName + ".setModelEncoding( parser.getInputEncoding() );" );
    }
    sc.add("");
    sc.add("if ( !( event = parser.getEvent() ).is( Event.ID.DocumentEnd ) )");
    sc.add("{");
    sc.addIndented("throw new ParserException( \"Expected Document End event\", event.getStartMark(), \"\", null );");
    sc.add("}");
    sc.add("if ( !( event = parser.getEvent() ).is( Event.ID.StreamEnd ) )");
    sc.add("{");
    sc.addIndented("throw new ParserException( \"Expected Stream End event\", event.getStartMark(), \"\", null );");
    sc.add("}");
    sc.add("");
    sc.add("return " + variableName + ';');
    jClass.addMethod(unmarshall);
    // ----------------------------------------------------------------------
    // Write the read(Reader[,boolean]) methods which will do the unmarshalling.
    // ----------------------------------------------------------------------
    unmarshall = new JMethod(readerMethodName, new JClass(className), null);
    unmarshall.addParameter(new JParameter(new JClass("Reader"), "reader"));
    unmarshall.addParameter(new JParameter(JClass.BOOLEAN, "strict"));
    addTrackingParameters(unmarshall);
    unmarshall.addException(new JClass("IOException"));
    sc = unmarshall.getSourceCode();
    sc.add("Parser parser = new ParserImpl( new StreamReader( reader ) );");
    sc.add("return " + readerMethodName + "( parser, strict );");
    jClass.addMethod(unmarshall);
    unmarshall = new JMethod(readerMethodName, new JClass(className), null);
    unmarshall.addParameter(new JParameter(new JClass("Reader"), "reader"));
    unmarshall.addException(new JClass("IOException"));
    sc = unmarshall.getSourceCode();
    sc.add("return " + readerMethodName + "( reader, true );");
    jClass.addMethod(unmarshall);
    // ----------------------------------------------------------------------
    // Write the read(InputStream[,boolean]) methods which will do the unmarshalling.
    // ----------------------------------------------------------------------
    unmarshall = new JMethod(readerMethodName, new JClass(className), null);
    unmarshall.addParameter(new JParameter(new JClass("InputStream"), "in"));
    unmarshall.addParameter(new JParameter(JClass.BOOLEAN, "strict"));
    addTrackingParameters(unmarshall);
    unmarshall.addException(new JClass("IOException"));
    sc = unmarshall.getSourceCode();
    sc.add("return " + readerMethodName + "( new InputStreamReader( in ), strict" + trackingArgs + " );");
    jClass.addMethod(unmarshall);
    unmarshall = new JMethod(readerMethodName, new JClass(className), null);
    unmarshall.addParameter(new JParameter(new JClass("InputStream"), "in"));
    unmarshall.addException(new JClass("IOException"));
    sc = unmarshall.getSourceCode();
    sc.add("return " + readerMethodName + "( in, true );");
    jClass.addMethod(unmarshall);
// --------------------------------------------------------------------
}

private boolean needMoreEvents() {
    if (events.isEmpty()) {
        return true;
    }
    Event event = events.peek();
    if (event instanceof DocumentStartEvent) {
        return needEvents(1);
    } else if (event instanceof SequenceStartEvent) {
        return needEvents(2);
    } else if (event instanceof MappingStartEvent) {
        return needEvents(3);
    } else {
        return false;
    }
}

private boolean needMoreEvents() {
    if (events.isEmpty()) {
        return true;
    }
    Event event = events.peek();
    if (event instanceof DocumentStartEvent) {
        return needEvents(1);
    } else if (event instanceof SequenceStartEvent) {
        return needEvents(2);
    } else if (event instanceof MappingStartEvent) {
        return needEvents(3);
    } else {
        return false;
    }
}

/**
	 * Serialize the representation tree into Events.
	 * 
	 * @see <a href="http://yaml.org/spec/1.1/#id859333">Processing Overview</a>
	 * @param data
	 *            representation tree
	 * @return Event list
	 */
public List<Event> serialize(Node data) {
    SilentEmitter emitter = new SilentEmitter();
    @SuppressWarnings("deprecation") Serializer serializer = new Serializer(emitter, resolver, dumperOptions, dumperOptions.getExplicitRoot());
    try {
        serializer.open();
        serializer.serialize(data);
        serializer.close();
    } catch (java.io.IOException e) {
        throw new YAMLException(e);
    }
    return emitter.getEvents();
}

private boolean needMoreEvents() {
    if (events.isEmpty()) {
        return true;
    }
    Event event = events.peek();
    if (event instanceof DocumentStartEvent) {
        return needEvents(1);
    } else if (event instanceof SequenceStartEvent) {
        return needEvents(2);
    } else if (event instanceof MappingStartEvent) {
        return needEvents(3);
    } else {
        return false;
    }
}

private boolean needMoreEvents() {
    if (events.isEmpty()) {
        return true;
    }
    Event event = events.peek();
    if (event instanceof DocumentStartEvent) {
        return needEvents(1);
    } else if (event instanceof SequenceStartEvent) {
        return needEvents(2);
    } else if (event instanceof MappingStartEvent) {
        return needEvents(3);
    } else {
        return false;
    }
}

private boolean needMoreEvents() {
    if (this.events.isEmpty()) {
        return true;
    }
    Event event = this.events.peek();
    if (event instanceof DocumentStartEvent) {
        return this.needEvents(1);
    } else if (event instanceof SequenceStartEvent) {
        return this.needEvents(2);
    } else if (event instanceof MappingStartEvent) {
        return this.needEvents(3);
    } else {
        return false;
    }
}