Java tutorial
/* * Licensed 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 com.addthis.hydra.store.db; import javax.annotation.Nonnull; import java.util.Arrays; import com.addthis.basis.util.LessBytes; import com.addthis.basis.util.Varint; import com.addthis.hydra.store.util.Raw; import static com.google.common.base.Preconditions.checkArgument; import io.netty.buffer.ByteBuf; import io.netty.buffer.Unpooled; public final class DBKey implements IPageDB.Key, Comparable<DBKey> { private static final Raw EMPTY = Raw.get(new byte[0]); private final long id; private final Raw key; public DBKey(long id) { this(id, (Raw) null); } public DBKey(long id, String key) { this(id, Raw.get(key)); } public DBKey(long id, Raw key) { checkArgument(id >= 0, "Argument was %s but expected non-negative integer", id); if (key == null) { key = EMPTY; } this.id = id; this.key = key; } /** * Create a DBKey from its serialization byte array representation. * If the most significant bit of the first byte is set then * interpret the id as a 63-bit unsigned long. Otherwise interpret the * id as a 31-bit unsigned int. * * @param raw * @return */ public static DBKey fromBytes(byte[] raw) { byte head = raw[0]; int numBytes; long id; if ((head >> 7) == 0) { id = (long) LessBytes.toInt(raw); numBytes = 4; } else { id = LessBytes.toLong(raw) & ~(Long.MIN_VALUE); numBytes = 8; } Raw key = Raw.get(LessBytes.cut(raw, numBytes, raw.length - numBytes)); return new DBKey(id, key); } public static DBKey deltaDecode(byte[] encoding, @Nonnull IPageDB.Key baseKey) { ByteBuf buffer = Unpooled.copiedBuffer(encoding); long offset = Varint.readSignedVarLong(buffer); long id = offset + baseKey.id(); Raw key; if (buffer.readableBytes() == 0) { key = null; } else { byte[] data = new byte[buffer.readableBytes()]; buffer.readBytes(data); key = Raw.get(data); } return new DBKey(id, key); } @Override public long id() { return id; } @Override public byte[] key() { return key.toBytes(); } @Override public Raw rawKey() { return key; } public String toString() { return id + ":" + key; } @Override public int hashCode() { return key.hashCode() + Long.hashCode(id); } @Override public boolean equals(Object o) { if (o == this) { return true; } if (o instanceof DBKey) { DBKey k = (DBKey) o; return (k.id == id && k.key.equals(key)); } else { return false; } } @Override public int compareTo(DBKey dk) { long dkId = dk.id(); if (dkId == id) { return key.compareTo(dk.key); } return id > dkId ? 1 : -1; } /** * Generate the serialized byte array representation. * If the id can be represented as a 31-bit unsigned integer * then use a 4-byte representation. If is cannot be represented * in 4 bytes then use an 8-byte representation and set the * most significant bit of the first byte as a flag. * * @return serialized representation */ @Override public byte[] toBytes() { byte[] idBytes; if (id <= Integer.MAX_VALUE) { idBytes = LessBytes.toBytes((int) id); } else { idBytes = LessBytes.toBytes(id | Long.MIN_VALUE); } if (key == null) { return idBytes; } return Raw.get(idBytes).cat(key).toBytes(); } @Override public byte[] deltaEncode(@Nonnull IPageDB.Key baseKey) { long offset = id - baseKey.id(); ByteBuf buffer = Unpooled.buffer(); Varint.writeSignedVarLong(offset, buffer); if (key != null) { buffer.writeBytes(key.toBytes()); } return Arrays.copyOf(buffer.array(), buffer.readableBytes()); } }