net.openhft.chronicle.wire.WireOut Java Examples

@Override
public void writeMarshallable(@NotNull WireOut wireOut) {
    ;
    super.writeMarshallable(wireOut);

    wireOut.write(() -> "valueClass").typeLiteral(valueClass);
    wireOut.write(() -> "valueSizeMarshaller").object(valueSizeMarshaller);
    wireOut.write(() -> "valueReader").object(valueReader);
    wireOut.write(() -> "valueDataAccess").object(valueDataAccess);

    wireOut.write(() -> "constantlySizedEntry").bool(constantlySizedEntry);

    wireOut.write(() -> "alignment").int32(alignment);
    wireOut.write(() -> "worstAlignment").int32(worstAlignment);
    wireOut.write(() -> "maxBloatFactor").float64(maxBloatFactor);
}
 

/**
 * simply reads the csp,tid and payload and sends back the tid and payload
 *
 * @param inWire  the wire from the client
 * @param outWire the wire to be sent back to the server
 * @param sd      details about this session
 */
@Override
protected void process(@NotNull WireIn inWire,
                       @NotNull WireOut outWire,
                       @NotNull SessionDetailsProvider sd) {

    inWire.readDocument(m -> {
        long tid = inWire.read(() -> "tid").int64();
        outWire.writeDocument(true, meta -> meta.write(() -> "tid")
                .int64(tid));

    }, d -> {
        outWire.writeDocument(false, data -> data.write(() -> "payloadResponse")
                .text(inWire.read(() -> "payload").text()));
    });
}
 

@Override
public void onInitialize(@NotNull WireOut outWire) {

    if (nc().eventLoop().isClosed())
        return;

    if (nc().isAcceptor())
        heartbeatHandler(heartbeatTimeoutMs, heartbeatIntervalMs, cid()).writeMarshallable
                (outWire);

    @NotNull final WriteMarshallable heartbeatMessage = new HeartbeatMessage();

    connectionMonitor = nc().acquireConnectionListener();
    timer = new Timer(nc().eventLoop());
    startPeriodicHeartbeatCheck();
    startPeriodicallySendingHeartbeats(heartbeatMessage);
}
 

@Override
public void writeMarshallable(@NotNull WireOut wire) {
    ;
    UnsupportedOperationException read_only = new UnsupportedOperationException("Read only");
    read_only.printStackTrace();
    throw read_only;
}
 

/**
 * simply reads the csp,tid and payload and sends back the tid and payload
 *
 * @param in      the DocumentContext from the client
 * @param outWire the wire to be sent back to the server
 */
@Override
protected void onRead(@NotNull DocumentContext in,
                      @NotNull WireOut outWire) {

    if (in.isMetaData())
        outWire.writeDocument(true, meta -> meta.write(() -> "tid")
                .int64(in.wire().read(() -> "tid").int64()));
    else
        outWire.writeDocument(false, data -> data.write(() -> "payloadResponse")
                .text(in.wire().read(() -> "payload").text()));

}
 

@Override
public void writeMarshallable(@NotNull WireOut wireOut) {
    ;
    super.writeMarshallable(wireOut);

    wireOut.write(() -> "tierModIterBitSetSizeInBits").int64(tierModIterBitSetSizeInBits);
    wireOut.write(() -> "tierModIterBitSetOuterSize").int64(tierModIterBitSetOuterSize);
    wireOut.write(() -> "segmentModIterBitSetsForIdentifierOuterSize")
            .int64(segmentModIterBitSetsForIdentifierOuterSize);
    wireOut.write(() -> "tierBulkModIterBitSetsForIdentifierOuterSize")
            .int64(tierBulkModIterBitSetsForIdentifierOuterSize);
}
 

@Override
public void onInitialize(@NotNull WireOut outWire) {
    if (isClosed.getAndSet(true))
        return;
    nc().terminationEventHandler().onTerminate(nc());
    Closeable.closeQuietly(closable());
}
 

@Override
public void writeMarshallable(@NotNull WireOut wireOut) {
    wireOut.write(() -> "keyReader").typedMarshallable(keyReader);
    wireOut.write(() -> "keyWriter").typedMarshallable(keyWriter);
    wireOut.write(() -> "valueReader").typedMarshallable(valueReader);
    wireOut.write(() -> "valueWriter").typedMarshallable(valueWriter);
}
 

@Override
public void writeMarshallable(@NotNull WireOut w) {
    w.writeDocument(true,
            d -> d.writeEventName(CoreFields.csp).text("/")
                    .writeEventName(CoreFields.cid).int64(cid)
                    .writeEventName(CoreFields.handler).typedMarshallable(new
                            HeartbeatHandler<>(heartbeatTimeoutMs, heartbeatIntervalMs)));
}
 

@Override
public void writeMarshallable(@NotNull WireOut wire) {
    wire
            .write(MetaDataField.roll).typedMarshallable(roll)
            .write(MetaDataField.deltaCheckpointInterval).int32(this.deltaCheckpointInterval)
            .write(MetaDataField.sourceId).int32(this.sourceId);
}
 

@Override
public void writeMarshallable(WireOut out) {
    super.writeMarshallable(out);
    if (PREGENERATED_MARSHALLABLE) {
        out.write("clOrdID").object(String.class, clOrdID);
        out.write("symbol").writeLong(Base85LongConverter.INSTANCE, symbol);
    }
}
 

@Override
public void writeMarshallable(WireOut out) {
    super.writeMarshallable(out);
    if (PREGENERATED_MARSHALLABLE) {
        out.write("clOrdID").object(String.class, clOrdID);
        out.write("symbol").writeLong(Base85LongConverter.INSTANCE, symbol);
        out.write("reason").object(String.class, reason);
    }
}
 

@Override
protected void onRead(@NotNull DocumentContext in, @NotNull WireOut out) {
    for (; ; ) {
        long pos = in.wire().bytes().readPosition();
        if (!reader.readOne())
            return;
        if (pos <= in.wire().bytes().readPosition()) {
            Jvm.warn().on(getClass(), "unable to parse data at the end of message " + in.wire().bytes().toDebugString());
            return;
        }
    }
}
 

@Override
default void writeMarshallable(@NotNull WireOut w) {
    w.writeEventName(EventId.userId).text(userId())
            .writeEventName(EventId.domain).text(domain())
            .writeEventName(EventId.sessionMode).text(sessionMode().toString())
            .writeEventName(EventId.securityToken).text(securityToken())
            .writeEventName(EventId.clientId).text(clientId().toString())
            .writeEventName(EventId.hostId).int8(hostId())
            .writeEventName(EventId.wireType).asEnum(wireType());
}
 

@Nullable
@Override
public WireOut wire() {
    return wire;
}
 

@Override
public void writeMarshallable(@NotNull WireOut wireOut) {
    wireOut.write(() -> "constantSize").int64(constantSize);
}
 

@NotNull
@Override
public WireOut wire() {
    throw new UnsupportedOperationException();
}
 

@Override
public void writeMarshallable(WireOut wire) {
    super.writeMarshallable(wire);
    wire.write(() -> "start").int64(start);
}
 

@Override
public void writeMarshallable(WireOut wire) {
    wire.write(CoreFields.csp).text(csp);
    wire.write(CoreFields.cid).int32(cid);
}
 

@Override
public void writeMarshallable(@NotNull WireOut wireOut) {
    // no fields to write
}
 

@Override
public void writeMarshallable(@NotNull WireOut wireOut) {
    wireOut.write(() -> "tClass").typeLiteral(tClass);
}
 

@Override
public void writeMarshallable(@NotNull WireOut wireOut) {
    wireOut.write(() -> "reader").typedMarshallable(reader);
}
 

@Override
public void writeMarshallable(@NotNull WireOut wireOut) {
    // no config fields to write
}
 

@Override
public void writeMarshallable(@NotNull WireOut wireOut) {
    // no config fields to write
}
 

@Override
public void writeMarshallable(@NotNull WireOut wireOut) {
    // no config fields to write
}
 

@Override
default void writeMarshallable(@NotNull WireOut wireOut) {
    // shouldn't read => shouldn't write fields
}
 

@Override
public void writeMarshallable(@NotNull WireOut wireOut) {
    // no config fields to write
}
 

@Override
public void writeMarshallable(@NotNull WireOut wireOut) {
    // no config fields to write
}
 

@Override
public void writeMarshallable(@NotNull WireOut wireOut) {
    wireOut.write(() -> "tClass").typeLiteral(tClass);
}
 

@Override
public void writeMarshallable(@NotNull WireOut wireOut) {
    super.writeMarshallable(wireOut);
    wireOut.write(() -> "sizedReader").typedMarshallable(sizedReader);
    wireOut.write(() -> "sizedWriter").typedMarshallable(sizedWriter);
}