org.metafacture.flowcontrol.StreamDeferrer Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of metafacture-flowcontrol Show documentation

Modules for controlling the data flow in a Metafacture pipeline

There is a newer version: 6.2.0

Show newest version

/*
 * Copyright 2016 Deutsche Nationalbibliothek
 *
 * Licensed under the Apache License, Version 2.0 the "License";
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.metafacture.flowcontrol;

import org.metafacture.framework.FluxCommand;
import org.metafacture.framework.StreamReceiver;
import org.metafacture.framework.annotations.Description;
import org.metafacture.framework.annotations.In;
import org.metafacture.framework.annotations.Out;
import org.metafacture.framework.helpers.DefaultStreamPipe;

/**
 * Defers all stream events until an end-record is received. Once the
 * event is received {@code StreamDeferrer} forwards all events it has received
 * before the end-record event to the next downstream module. The
 * end-record event is forwarded immediately.
 * 
 * The {@code StreamDeferrer} is useful when merging two or more streams of
 * events into one. The module is intended to be added at the end of each flow.
 * There it ensures that the events for each record are forwarded consecutively
 * to the merged flow without them being mixed with events belonging to a record
 * from another stream.
 *
 * @author Christoph Böhme
 */
@Description("Defers all stream events until an end-record event is received")
@FluxCommand("defer-stream")
@In(StreamReceiver.class)
@Out(StreamReceiver.class)
public class StreamDeferrer extends DefaultStreamPipe {

    private final StreamBuffer buffer = new StreamBuffer();

    /**
     * Creates an instance of {@link StreamDeferrer}.
     */
    public StreamDeferrer() {
    }

    @Override
    public void startRecord(final String identifier) {
        buffer.clear();
        buffer.startRecord(identifier);
    }

    @Override
    public void endRecord() {
        buffer.endRecord();
        buffer.replay();
    }

    @Override
    public void startEntity(final String name) {
        buffer.startEntity(name);
    }

    @Override
    public void endEntity() {
        buffer.endEntity();
    }

    @Override
    public void literal(final String name, final String value) {
        buffer.literal(name, value);
    }

    @Override
    protected void onSetReceiver() {
        buffer.setReceiver(getReceiver());
    }

    @Override
    protected void onResetStream() {
        buffer.clear();
    }

    @Override
    protected void onCloseStream() {
        buffer.clear();
    }

}