org.elasticsearch.common.io.stream.StreamOutput Java Examples

@Override
public void writeTo(StreamOutput out) throws IOException {
    super.writeTo(out);
    out.writeVInt(mappings.size());
    for (Map.Entry<String, ImmutableMap<String, ImmutableMap<String, FieldMappingMetaData>>> indexEntry : mappings.entrySet()) {
        out.writeString(indexEntry.getKey());
        out.writeVInt(indexEntry.getValue().size());
        for (Map.Entry<String, ImmutableMap<String, FieldMappingMetaData>> typeEntry : indexEntry.getValue().entrySet()) {
            out.writeString(typeEntry.getKey());
            out.writeVInt(typeEntry.getValue().size());
            for (Map.Entry<String, FieldMappingMetaData> fieldEntry : typeEntry.getValue().entrySet()) {
                out.writeString(fieldEntry.getKey());
                FieldMappingMetaData fieldMapping = fieldEntry.getValue();
                out.writeString(fieldMapping.fullName());
                out.writeBytesReference(fieldMapping.source);
            }
        }
    }
}
 

@Override
public void writeTo(final StreamOutput out) throws IOException {
    out.writeVInt(activePrimaryShards);
    out.writeVInt(activeShards);
    out.writeVInt(relocatingShards);
    out.writeVInt(initializingShards);
    out.writeVInt(unassignedShards);
    out.writeVInt(numberOfNodes);
    out.writeVInt(numberOfDataNodes);
    out.writeByte(status.value());
    out.writeVInt(indices.size());
    for (ClusterIndexHealth indexHealth : this) {
        indexHealth.writeTo(out);
    }
    out.writeDouble(activeShardsPercent);
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
   assert searchRequest != null;
   this.searchRequest.writeTo(out);
   out.writeOptionalString(queryHint);
   out.writeOptionalString(algorithm);
   out.writeInt(maxHits);
   out.writeBoolean(createUngroupedDocumentsCluster);
   out.writeString(defaultLanguage);

   out.writeVInt(fieldMapping.size());
   for (FieldMappingSpec spec : fieldMapping) {
      spec.writeTo(out);
   }

   boolean hasAttributes = (attributes != null);
   out.writeBoolean(hasAttributes);
   if (hasAttributes) {
      out.writeMap(attributes);
   }
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    out.writeVInt(explanations.size());
    for (Map.Entry<ShardId, List<NodeExplanation>> entry : explanations.entrySet()) {
        entry.getKey().writeTo(out);
        out.writeVInt(entry.getValue().size());
        for (NodeExplanation nodeExplanation : entry.getValue()) {
            if (nodeExplanation.node() == null) {
                out.writeBoolean(false);
            } else {
                out.writeBoolean(true);
                nodeExplanation.node().writeTo(out);
            }
            out.writeString(nodeExplanation.description());
        }
    }
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    super.writeTo(out);
    out.writeString(nodeId);
    out.writeVInt(results.size());
    for (TaskResponse result : results) {
        if (result != null) {
            out.writeBoolean(true);
            result.writeTo(out);
        } else {
            out.writeBoolean(false);
        }
    }
    out.writeBoolean(exceptions != null);
    if (exceptions != null) {
        int taskFailures = exceptions.size();
        out.writeVInt(taskFailures);
        for (TaskOperationFailure exception : exceptions) {
            exception.writeTo(out);
        }
    }
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    total.writeTo(out);
    features.writeTo(out);
    featuresets.writeTo(out);
    models.writeTo(out);
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    out.writeVLong(startTime);
    out.writeVLong(time);

    out.writeVInt(numberOfFiles);
    out.writeVInt(processedFiles);

    out.writeVLong(totalSize);
    out.writeVLong(processedSize);
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    super.writeTo(out);
    shardCounts.writeTo(out);
    out.writeInt(shardsResultPerIndex.size());
    for (Map.Entry<String, List<ShardsSyncedFlushResult>> entry : shardsResultPerIndex.entrySet()) {
        out.writeString(entry.getKey());
        out.writeInt(entry.getValue().size());
        for (ShardsSyncedFlushResult shardsSyncedFlushResult : entry.getValue()) {
            shardsSyncedFlushResult.writeTo(out);
        }
    }
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    out.writeNullableString(loginUsername);
    out.writeLong(tenantId);
    out.writeNullableString(password);
    out.writeNullableString(sourceAddrs);
    out.writeNullableString(proxyAddrs);
    out.writeBoolean(authenticated);
    out.writeBoolean(authorized);
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    relationName.writeTo(out);
    out.writeOptionalString(partitionIdent);

    Symbols.toStream(idSymbols, out);
    out.writeVInt(primaryKeys.size());
    for (ColumnIdent primaryKey : primaryKeys) {
        primaryKey.writeTo(out);
    }
    Symbols.toStream(partitionedBySymbols, out);
    if (clusteredBySymbol == null) {
        out.writeBoolean(false);
    } else {
        out.writeBoolean(true);
        Symbols.toStream(clusteredBySymbol, out);
    }

    if (clusteredByColumn == null) {
        out.writeBoolean(false);
    } else {
        out.writeBoolean(true);
        clusteredByColumn.writeTo(out);
    }
    out.writeVInt(bulkActions);
    out.writeBoolean(autoCreateIndices);
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    super.writeTo(out);
    out.writeStringArrayNullable(indices);
    indicesOptions.writeIndicesOptions(out);
    writeSettingsToStream(settings, out);
    out.writeBoolean(preserveExisting);
}
 

@Override
public void writeTo(final StreamOutput out) throws IOException {
    super.writeTo(out);
    out.writeLong(recoveryId);
    shardId.writeTo(out);
    primaryContext.writeTo(out);
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    super.writeTo(out);
    out.writeStringArray(indices);
    out.writeStringArray(types);
    indicesOptions.writeIndicesOptions(out);
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    out.writeVInt(versions.size());
    for (ObjectIntCursor<JvmVersion> v : versions) {
        v.key.writeTo(out);
        out.writeVInt(v.value);
    }

    out.writeVLong(threads);
    out.writeVLong(maxUptime);
    out.writeVLong(heapUsed);
    out.writeVLong(heapMax);
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    super.writeTo(out);
    out.writeVInt(directResponse.size());
    for (Bucket bucket : directResponse) {
        StreamBucket.writeBucket(out, streamers, bucket);
    }
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    super.writeTo(out);
    out.writeString(snapshot);
    out.writeString(repository);
    out.writeStringArray(indices);
    indicesOptions.writeIndicesOptions(out);
    writeSettingsToStream(settings, out);
    out.writeBoolean(includeGlobalState);
    out.writeBoolean(waitForCompletion);
    out.writeBoolean(partial);
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    super.writeTo(out);
    out.writeNullableString(nodeIp);
    out.writeInt(nodePort);
    out.writeNullableString(tenantName);
    out.writeInt(operation.getValue());
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    out.writeOptionalString(nodeId);
    shardId.writeTo(out);
    out.writeString(reason);
    RestStatus.writeTo(out, status);
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    super.writeTo(out);
    out.writeStringArray(cols);
    out.writeBoolean(includeTypes);
    out.writeFloat(duration);
    if (includeTypes) {
        out.writeVInt(colTypes.length);
        for (DataType colType : colTypes) {
            DataTypes.toStream(colType, out);
        }
    }
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    super.writeTo(out);
    int tenantNum = tenantNames == null ? 0 : tenantNames.length;
    out.writeInt(tenantNum);
    for (int i = 0; i < tenantNum; ++i) {
        out.writeString(tenantNames[i]);
    }
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    out.writeVInt(collectors.length);
    for (GarbageCollector gc : collectors) {
        gc.writeTo(out);
    }
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    super.writeTo(out);
    out.writeString(index);
    out.writeInt(shardId);
    timeout.writeTo(out);
    out.writeOptionalString(concreteIndex);
}
 

/**
 * {@inheritDoc}
 */
@Override
public void writeTo(StreamOutput out) throws IOException {
    out.writeVInt(repositories.size());
    for (RepositoryMetaData repository : repositories) {
        repository.writeTo(out);
    }
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    super.writeTo(out);
    out.writeString(name);
    if (searchRequest == null) {
        out.writeBoolean(false);
    } else {
        out.writeBoolean(true);
        searchRequest.writeTo(out);
    }
    writeTimeout(out);
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    super.writeTo(out);
    out.writeOptionalString(routing);
    out.writeOptionalString(preference);
    out.writeBytesReference(source);
    out.writeStringArray(types);
}
 

@Override
public void writeValueTo(StreamOutput out, Object v) throws IOException {
    out.writeBoolean(v == null);
    if (v != null) {
        out.writeInt(((Number) v).intValue());
    }
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    super.writeTo(out);
    out.writeLong(jobId.getMostSignificantBits());
    out.writeLong(jobId.getLeastSignificantBits());
    out.writeVInt(indices.size());
    for (String index : indices) {
        out.writeString(index);
    }
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    super.writeTo(out);
    indicesLevelRequest.writeTo(out);
    int size = shards.size();
    out.writeVInt(size);
    for (int i = 0; i < size; i++) {
        shards.get(i).writeTo(out);
    }
    out.writeString(nodeId);
}
 

@Override
public void doWriteTo(StreamOutput out) throws IOException {
    ValueFormatterStreams.writeOptional(formatter, out);
    gapPolicy.writeTo(out);
    boolean hasXAxisUnitsValue = xAxisUnits != null;
    out.writeBoolean(hasXAxisUnitsValue);
    if (hasXAxisUnitsValue) {
        out.writeDouble(xAxisUnits);
    }
}
 

@Override
public void writeTo(StreamOutput out) throws IOException {
    super.writeTo(out);
    out.writeOptionalString(preference);
    out.writeVInt(requests.size());
    for (TermVectorsRequest termVectorsRequest : requests) {
        termVectorsRequest.writeTo(out);
    }
}