org.apache.druid.segment.serde.MetaSerdeHelper Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of druid-processing Show documentation
Show all versions of druid-processing Show documentation
A module that is everything required to understands Druid Segments
/*
* Licensed to the Apache Software Foundation (ASF) under one
* or more contributor license agreements. See the NOTICE file
* distributed with this work for additional information
* regarding copyright ownership. The ASF licenses this file
* to you 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.apache.druid.segment.serde;
import org.apache.druid.io.Channels;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.WritableByteChannel;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;
public final class MetaSerdeHelper
{
public static MetaSerdeHelper firstWriteByte(ByteFieldWriter fieldWriter)
{
return new MetaSerdeHelper().writeByte(fieldWriter);
}
private final List> fieldWriters = new ArrayList<>();
private MetaSerdeHelper()
{
}
public MetaSerdeHelper writeInt(IntFieldWriter fieldWriter)
{
return writeSomething(fieldWriter);
}
public MetaSerdeHelper writeByte(ByteFieldWriter fieldWriter)
{
return writeSomething(fieldWriter);
}
public MetaSerdeHelper maybeWriteByte(Predicate condition, ByteFieldWriter fieldWriter)
{
return writeSomething(
new FieldWriter()
{
@Override
public void writeTo(ByteBuffer buffer, T x)
{
if (condition.test(x)) {
buffer.put(fieldWriter.getField(x));
}
}
@Override
public int size(T x)
{
return condition.test(x) ? Byte.BYTES : 0;
}
}
);
}
public MetaSerdeHelper writeByteArray(Function getByteArray)
{
return writeSomething(
new FieldWriter()
{
@Override
public void writeTo(ByteBuffer buffer, T x)
{
buffer.put(getByteArray.apply(x));
}
@Override
public int size(T x)
{
return getByteArray.apply(x).length;
}
}
);
}
public MetaSerdeHelper writeSomething(FieldWriter fieldWriter)
{
fieldWriters.add(fieldWriter);
return this;
}
public void writeTo(WritableByteChannel channel, T x) throws IOException
{
ByteBuffer meta = ByteBuffer.allocate(size(x));
for (FieldWriter w : fieldWriters) {
w.writeTo(meta, x);
}
meta.flip();
Channels.writeFully(channel, meta);
}
public int size(T x)
{
return fieldWriters.stream().mapToInt(w -> w.size(x)).sum();
}
public interface FieldWriter
{
void writeTo(ByteBuffer buffer, T x);
int size(T x);
}
@FunctionalInterface
public interface IntFieldWriter extends FieldWriter
{
int getField(T x);
@Override
default void writeTo(ByteBuffer buffer, T x)
{
buffer.putInt(getField(x));
}
@Override
default int size(T x)
{
return Integer.BYTES;
}
}
@FunctionalInterface
public interface ByteFieldWriter extends FieldWriter
{
byte getField(T x);
@Override
default void writeTo(ByteBuffer buffer, T x)
{
buffer.put(getField(x));
}
@Override
default int size(T x)
{
return Byte.BYTES;
}
}
}