Java Code Examples for io.vavr.collection.Vector#empty()

@Override
public Writer<CsvEvent, String> writer() {
    return new Writer<CsvEvent, String>() {
        @Override
        public Seq<CsvEvent> apply(String value) {
            if (value.isEmpty()) {
                return Vector.empty();
            } else {
                return Vector.of(CsvEvent.text(value));
            }
        }

        @Override
        public Seq<CsvEvent> reset() {
            return Vector.empty();
        }
    };
}
 

@Override
public Writer<CsvEvent, T> writer() {
    Writer<CsvEvent, T> innerWriter = inner.writer();
    
    return new Writer<CsvEvent, T>() {
        boolean first = true;
        
        @Override
        public Seq<CsvEvent> apply(T value) {
            Seq<CsvEvent> events =
                (first) ? Vector.of(CsvEvent.text(name), CsvEvent.endValue(), CsvEvent.endRecord()) : Vector.empty();
            first = false;
            return events.appendAll(innerWriter.apply(value)).append(CsvEvent.endValue()).append(CsvEvent.endRecord());
        }

        @Override
        public Seq<CsvEvent> reset() {
            if (first) {
                first = false;
                return Vector.of(CsvEvent.text(name), CsvEvent.endValue(), CsvEvent.endRecord());
            } else {
                return Vector.empty();
            }
        }
    };
}
 

/**
 * Returns a writer that emits an event for every element, the event being the element itself.
 */
public static <E, T extends E> Writer<E,T> identity() {
    return new Writer<E,T>() {
        @Override
        public Seq<E> apply(T value) {
            return Vector.of(value);
        }
        
        @Override
        public Seq<E> reset() {
            return Vector.empty();
        }
    };
}
 

/**
 * Returns a Writer that calls the given function for apply(), and nothing for reset().
 */
public static <E,T> Writer<E,T> of (Function<T,Seq<E>> f) {
    return new Writer<E, T>() {
        @Override
        public Seq<E> apply(T value) {
            return f.apply(value);
        }

        @Override
        public Seq<E> reset() {
            return Vector.empty();
        }
    };
}
 

@Override
public Seq<String> getDataCenterNames(TestEvent e) {
    if (e.getMsg().startsWith("dc:")) {
        return Vector.of(e.getMsg().substring(3));
    } else {
        return Vector.empty();
    }
}
 

public ObjectProtocol(
    List<Protocol<JSONEvent, ?>> protocols,
    Function<List<?>, T> produce,
    List<Function1<T, ?>> getters
) {
    this.read = new ObjectReadProtocol<>(Vector.ofAll(protocols), produce, Vector.empty());
    this.write = new ObjectWriteProtocol<>(Vector.ofAll(protocols), getters, Vector.empty());
}
 

public ObjectReadProtocol(ReadProtocol<JSONEvent, T> inner) {
    this(Vector.of(inner), identity(), Vector.empty());
}
 

/**
 * Writes a tag and with any name, getting values using [g1] for writing.
 */
public static <T> TagWriteProtocol<T> writeTagName(Function1<T,QName> g1) {
    return new TagWriteProtocol<>(Option.none(), Vector.empty(), Vector.of(g1));
}
 

/**
 * Reads a tag with any name, creating its result using [f].
 */
public static <T> TagReadProtocol<T> readTagName(Function1<QName,T> f) {
    return new TagReadProtocol<>(Option.none(), Vector.empty(), args -> f.apply((QName) args.get(0)));
}
 

/**
 * Reads and writes a tag with any name, using [f] to create the result on reading, getting values using [g1] for writing.
 */
public static <T> TagProtocol<T> tagName(Function1<QName,T> f, Function1<T,QName> g1) {
    return new TagProtocol<>(Option.none(), Vector.empty(), args -> f.apply((QName) args.get(0)), Vector.of(g1));
}
 

private static Vector<Field> safeFields(FieldList fields) {
    return fields == null ? Vector.empty() : Vector.ofAll(fields);
}
 

/**
 * Reads a tag and one child element (tag or attribute), where the result of this tag is the result of the single child.
 */
public TagReadProtocol(Option<QName> name, ReadProtocol<XMLEvent,?> protocol) {
    this(name, Vector.of(protocol), identity(), Vector.empty());
}
 

public ObjectReadProtocol(
    List<ReadProtocol<JSONEvent, ?>> protocols,
    Function<List<?>, T> produce
) {
    this(Vector.ofAll(protocols), produce, Vector.empty());
}
 

public ObjectWriteProtocol(WriteProtocol<JSONEvent, T> inner) {
    this(Vector.of((WriteProtocol<JSONEvent, ?>)inner), Arrays.asList(Function1.identity()), Vector.empty());
}
 

public ObjectWriteProtocol(
    List<WriteProtocol<JSONEvent, ?>> protocols,
    List<Function1<T, ?>> getters
) {
    this(Vector.ofAll(protocols), getters, Vector.empty());
}
 

@Override
public GraphStageLogic createLogic(Attributes inheritedAttributes) {
    return new TimerGraphStageLogic(shape) {
        Seq<T> buffer = Vector.empty();

        {
            setHandler(in, new AbstractInHandler() {
                @Override
                public void onPush() {
                    T t = grab(in);

                    if (buffer.isEmpty() || test.apply(buffer.get(buffer.size() - 1), t)) {
                        buffer = buffer.append(t);
                        scheduleOnce("idle", idleEmitTimeout);
                        pull(in);
                    } else {
                        emitBuffer();
                        scheduleOnce("idle", idleEmitTimeout);
                        buffer = buffer.append(t);
                    }
                    if (buffer.size() > maxGroupSize) {
                        failStage(new BufferOverflowException("Exceeded configured GroupWhile buffer size of " + maxGroupSize));
                        return;
                    }
                }

                @Override
                public void onUpstreamFinish() {
                    emitBuffer();
                    completeStage();
                }
            });

            setHandler(out, new AbstractOutHandler() {
                @Override
                public void onPull() {
                    if (!hasBeenPulled(in)) {
                        pull(in);
                    }
                }
            });
        }

        private void emitBuffer() {
            if (!buffer.isEmpty() && isAvailable(out)) {
                emit(out, buffer);
                buffer = Vector.empty();
                cancelTimer("idle");
            }
        }

        @Override
        public void onTimer(Object timerKey) {
            log.debug("Idle timeout reached with {} elements waiting", buffer.size());
            emitBuffer();
        }
    };
}
 

public static MaterializerWorkers empty(TemporalAmount rollback) {
    return new MaterializerWorkers(Vector.empty(), rollback);
}
 

/**
 * Creates a new TagReadProtocol
 * @param name Name of the tag to match, or none() to match any tag ([produce] will get another argument (at position 0) with the tag's QName in that case)
 * @param protocols Attributes and child tags to read
 * @param produce Function that must accept a list of (attributes.size + tags.size) objects and turn that into T
 */
public TagReadProtocol(Option<QName> name, Vector<? extends ReadProtocol<XMLEvent,?>> protocols, Function<List<?>, T> produce) {
    this(name, protocols, produce, Vector.empty());
}
 

/**
 * DataColumn constructor.
 *
 * @param type Stores the type of data stored in this column.
 * @param columnName The column name.
 */
public DataColumn(Class<T> type, String columnName) {
    this(type, columnName, Vector.empty());
}
 

/**
 * Returns the events to be emitted as a result of applying the command. 
 * 
 * By default, no events are emitted (which is appropriate for read-only commands).
 */
default public Seq<E> getEventsToEmit() {
    return Vector.empty();
}