io.deephaven.chunk.util.hashing.ByteChunkHasher Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of deephaven-engine-chunk Show documentation

Engine Chunks: Array-like data structures for dense, efficient data movement

The newest version!

//
// Copyright (c) 2016-2024 Deephaven Data Labs and Patent Pending
//
// ****** AUTO-GENERATED CLASS - DO NOT EDIT MANUALLY
// ****** Edit CharChunkHasher and run "./gradlew replicateHashing" to regenerate
//
// @formatter:off
package io.deephaven.chunk.util.hashing;

import io.deephaven.chunk.ByteChunk;
import io.deephaven.chunk.Chunk;
import io.deephaven.chunk.WritableIntChunk;
import io.deephaven.chunk.attributes.HashCodes;
import io.deephaven.chunk.attributes.Values;
import io.deephaven.util.compare.ByteComparisons;
import io.deephaven.util.type.TypeUtils;

import static io.deephaven.chunk.util.hashing.ChunkHasher.scrambleHash;

public class ByteChunkHasher implements ChunkHasher {
    public static ByteChunkHasher INSTANCE = new ByteChunkHasher();

    private static void hashInitial(ByteChunk values, WritableIntChunk destination) {
        for (int ii = 0; ii < values.size(); ++ii) {
            final byte value = values.get(ii);
            destination.set(ii, hashInitialSingle(value));
        }
        destination.setSize(values.size());
    }

    private static void hashSecondary(ByteChunk values, WritableIntChunk destination) {
        for (int ii = 0; ii < values.size(); ++ii) {
            destination.set(ii, hashUpdateSingle(destination.get(ii), values.get(ii)));
        }
        destination.setSize(values.size());
    }

    public static int hashInitialSingle(byte value) {
        return scrambleHash(ByteComparisons.hashCode(value));
    }

    public static int hashUpdateSingle(int existing, byte newValue) {
        return existing * 31 + hashInitialSingle(newValue);
    }

    @Override
    public int hashInitial(Object value) {
        return hashInitialSingle(TypeUtils.unbox((Byte) value));
    }

    @Override
    public int hashUpdate(int existing, Object value) {
        return hashUpdateSingle(existing, TypeUtils.unbox((Byte) value));
    }

    @Override
    public void hashInitial(Chunk values, WritableIntChunk destination) {
        hashInitial(values.asByteChunk(), destination);
    }

    @Override
    public void hashUpdate(Chunk values, WritableIntChunk destination) {
        hashSecondary(values.asByteChunk(), destination);
    }
}