io.vavr.collection.Vector#of

Source File: MaterializerWorkers.java From ts-reaktive with MIT License

6 votes

/** Returns a new MaterializerWorkers where the single expected worker has progressed to the given timestamp */
public MaterializerWorkers applyEvent(long event) {
    if (workers.size() == 0) {
        return new MaterializerWorkers(Vector.of(Worker.newBuilder()
            .setId(toProtobuf(UUID.randomUUID()))
            .setTimestamp(event)
            .build()), rollback);
    } else if (workers.size() == 1) {
        return new MaterializerWorkers(Vector.of(workers.head().toBuilder()
            .setTimestamp(event)
            .build()), rollback);
    } else {
        throw new IllegalStateException("Encountered legacy Long event " + event
            + " AFTER having more than 1 worker: " + workers);
    }
}

Source File: NamedColumnWriteProtocol.java From ts-reaktive with MIT License

6 votes

@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();
            }
        }
    };
}

Source File: DataColumnTests.java From java-datatable with Apache License 2.0

5 votes

@Test
public void testVectorDataColumnCreation() {
    Vector<Integer> data = Vector.of(5, 7, 9);
    DataColumn<Integer> column = new DataColumn<>(Integer.class, "IntegerCol", data);

    assertEquals(column.data().length(), 3);
    assertTrue(column.data().get(1) == 7);
}

Source File: AbstractStatefulPersistentActorSpec.java From ts-reaktive with MIT License

5 votes

@Override
public Results<MyEvent> handleSynchronously(MyState state, String cmd) {
    return new Results<MyEvent>() {
        @Override
        public Seq<MyEvent> getEventsToEmit() {
            return Vector.of(new MyEvent(cmd));
        }

        @Override
        public Object getReply(Seq<MyEvent> emittedEvents, long lastSequenceNr) {
            return Done.getInstance();
        }                    
    };
}

Source File: Writer.java From ts-reaktive with MIT License

5 votes

/**
 * 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();
        }
    };
}

Source File: PolymorphicPojoTest.java From vavr-jackson with Apache License 2.0

5 votes

@Test
void testVector() throws Exception {
    Vector<I> src = Vector.of(new A(), new B());
    String json = MAPPER.writeValueAsString(new VectorPojo().setValue(src));
    Assertions.assertEquals(json, "{\"value\":[{\"type\":\"a\"},{\"type\":\"b\"}]}");
    VectorPojo pojo = MAPPER.readValue(json, VectorPojo.class);
    Vector<I> restored = pojo.getValue();
    Assertions.assertTrue(restored.get(0) instanceof A);
    Assertions.assertTrue(restored.get(1) instanceof B);
}

Source File: TagWriteProtocol.java From ts-reaktive with MIT License

5 votes

@Override
public Writer<XMLEvent,T> writer() {
    return new Writer<XMLEvent, T>() {
        boolean started = false;
        private EndElement endElement;
        
        @Override
        public Seq<XMLEvent> apply(T value) {
            log.debug("{}: Writing {}", TagWriteProtocol.this, value);
            Seq<XMLEvent> prefix = (started) ? Vector.empty() : Vector.of(startElement(value));
            started = true;
            endElement = factory.createEndElement(getName.apply(value), null);
            
            return prefix.appendAll(
                Vector.range(0, otherProtocols.size()).map(i -> {
                    Writer<XMLEvent,Object> w = (Writer<XMLEvent,Object>) otherProtocols.get(i).writer();
                    return w.applyAndReset(otherGetters.get(i).apply(value));
                }).flatMap(Function.identity())
            );
        }

        @Override
        public Seq<XMLEvent> reset() {
            log.debug("{}: Resetting", TagWriteProtocol.this);
            if (started) {
                started = false;
                return Vector.of(endElement);
            } else {
                return Vector.empty();
            }
        }
    };
}