Slice是用于高效地处理堆和堆外内存一个Java 库
    Slice成员变量
    image.png
    详细介绍Slice类具体成员变量和具体实现方法

    1. /*
    2.  * Licensed under the Apache License, Version 2.0 (the "License");
    3.  * you may not use this file except in compliance with the License.
    4.  * You may obtain a copy of the License at
    5.  *
    6.  *     http://www.apache.org/licenses/LICENSE-2.0
    7.  *
    8.  * Unless required by applicable law or agreed to in writing, software
    9.  * distributed under the License is distributed on an "AS IS" BASIS,
    10.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    11.  * See the License for the specific language governing permissions and
    12.  * limitations under the License.
    13.  */
    14. package io.airlift.slice;
    16. import org.openjdk.jol.info.ClassLayout;
    17. import sun.misc.Unsafe;
    19. import javax.annotation.Nullable;
    21. import java.io.IOException;
    22. import java.io.InputStream;
    23. import java.io.OutputStream;
    24. import java.nio.ByteBuffer;
    25. import java.nio.charset.Charset;
    27. import static io.airlift.slice.JvmUtils.bufferAddress;
    28. import static io.airlift.slice.JvmUtils.unsafe;
    29. import static io.airlift.slice.Preconditions.checkArgument;
    30. import static io.airlift.slice.Preconditions.checkPositionIndexes;
    31. import static io.airlift.slice.SizeOf.SIZE_OF_BYTE;
    32. import static io.airlift.slice.SizeOf.SIZE_OF_DOUBLE;
    33. import static io.airlift.slice.SizeOf.SIZE_OF_FLOAT;
    34. import static io.airlift.slice.SizeOf.SIZE_OF_INT;
    35. import static io.airlift.slice.SizeOf.SIZE_OF_LONG;
    36. import static io.airlift.slice.SizeOf.SIZE_OF_SHORT;
    37. import static io.airlift.slice.SizeOf.sizeOf;
    38. import static io.airlift.slice.SizeOf.sizeOfBooleanArray;
    39. import static io.airlift.slice.SizeOf.sizeOfDoubleArray;
    40. import static io.airlift.slice.SizeOf.sizeOfFloatArray;
    41. import static io.airlift.slice.SizeOf.sizeOfIntArray;
    42. import static io.airlift.slice.SizeOf.sizeOfLongArray;
    43. import static io.airlift.slice.SizeOf.sizeOfShortArray;
    44. import static java.lang.Math.min;
    45. import static java.lang.Math.multiplyExact;
    46. import static java.lang.Math.toIntExact;
    47. import static java.lang.String.format;
    48. import static java.nio.charset.StandardCharsets.UTF_8;
    49. import static java.util.Objects.requireNonNull;
    50. import static sun.misc.Unsafe.ARRAY_BOOLEAN_INDEX_SCALE;
    51. import static sun.misc.Unsafe.ARRAY_BYTE_BASE_OFFSET;
    52. import static sun.misc.Unsafe.ARRAY_DOUBLE_INDEX_SCALE;
    53. import static sun.misc.Unsafe.ARRAY_FLOAT_INDEX_SCALE;
    54. import static sun.misc.Unsafe.ARRAY_INT_INDEX_SCALE;
    55. import static sun.misc.Unsafe.ARRAY_LONG_INDEX_SCALE;
    56. import static sun.misc.Unsafe.ARRAY_SHORT_INDEX_SCALE;
    58. public final class Slice
    59.         implements Comparable<Slice>
    60. {
    61.     private static final int INSTANCE_SIZE = ClassLayout.parseClass(Slice.class).instanceSize();
    62.     private static final Object COMPACT = new byte[0];
    63.     private static final Object NOT_COMPACT = null;
    64.     private static final ByteBuffer EMPTY_BYTE_BUFFER = ByteBuffer.allocate(0);
    66.     /**
    67.      * Base object for relative addresses.  If null, the address is an
    68.      * absolute location in memory.
    69.      */
    70.     private final Object base;
    72.     /**
    73.      * If base is null, address is the absolute memory location of data for
    74.      * this slice; otherwise, address is the offset from the base object.
    75.      * This base plus relative offset addressing is taken directly from
    76.      * the Unsafe interface.
    77.      * <p>
    78.      * Note: if base object is a byte array, this address ARRAY_BYTE_BASE_OFFSET,
    79.      * since the byte array data starts AFTER the byte array object header.
    82.      */
    83.     private final long address;
    85.     /**
    86.      * Size of the slice
    87.      */
    88.     private final int size;
    90.     /**
    91.      * Bytes retained by the slice
    92.      */
    93.     private final long retainedSize;
    95.     /**
    96.      * Reference has two use cases:
    97.      * <p>
    98.      * 1. It can be an object this slice must hold onto to assure that the
    99.      * underlying memory is not freed by the garbage collector.
    100.      * It is typically a ByteBuffer object, but can be any object.
    101.      * This is not needed for arrays, since the array is referenced by {@code base}.
    102.      * <p>
    103.      * 2. If reference is not used to prevent garbage collector from freeing the
    104.      * underlying memory, it will be used to indicate if the slice is compact.
    105.      * When {@code reference == COMPACT}, the slice is considered as compact.
    106.      * Otherwise, it will be null.
    107.      * <p>
    108.      * A slice is considered compact if the base object is an heap array and
    109.      * it contains the whole array.
    110.      * Thus, for the first use case, the slice is always considered as not compact.
    111.      */
    112.     private final Object reference;
    114.     private int hash;
    116.     /**
    117.      * Creates an empty slice.
    118.      */
    119.     Slice()
    120.     {
    121.         this.base = null;
    122.         this.address = 0;
    123.         this.size = 0;
    124.         this.retainedSize = INSTANCE_SIZE;
    125.         this.reference = COMPACT;
    126.     }
    128.     /**
    129.      * Creates a slice over the specified array.
    130.      */
    131.     Slice(byte[] base)
    132.     {
    133.         requireNonNull(base, "base is null");
    134.         this.base = base;
    135.         this.address = ARRAY_BYTE_BASE_OFFSET;
    136.         this.size = base.length;
    137.         this.retainedSize = INSTANCE_SIZE + sizeOf(base);
    138.         this.reference = COMPACT;
    139.     }
    141.     /**
    142.      * Creates a slice over the specified array range.
    143.      *
    144.      * @param offset the array position at which the slice begins
    145.      * @param length the number of array positions to include in the slice
    146.      */
    147.     Slice(byte[] base, int offset, int length)
    148.     {
    149.         requireNonNull(base, "base is null");
    150.         checkPositionIndexes(offset, offset + length, base.length);
    152.         this.base = base;
    153.         this.address = ARRAY_BYTE_BASE_OFFSET + offset;
    154.         this.size = length;
    155.         this.retainedSize = INSTANCE_SIZE + sizeOf(base);
    156.         this.reference = (offset == 0 && length == base.length) ? COMPACT : NOT_COMPACT;
    157.     }
    159.     /**
    160.      * Creates a slice over the specified array range.
    161.      *
    162.      * @param offset the array position at which the slice begins
    163.      * @param length the number of array positions to include in the slice
    164.      */
    165.     Slice(boolean[] base, int offset, int length)
    166.     {
    167.         requireNonNull(base, "base is null");
    168.         checkPositionIndexes(offset, offset + length, base.length);
    170.         this.base = base;
    171.         this.address = sizeOfBooleanArray(offset);
    172.         this.size = multiplyExact(length, ARRAY_BOOLEAN_INDEX_SCALE);
    173.         this.retainedSize = INSTANCE_SIZE + sizeOf(base);
    174.         this.reference = (offset == 0 && length == base.length) ? COMPACT : NOT_COMPACT;
    175.     }
    177.     /**
    178.      * Creates a slice over the specified array range.
    179.      *
    180.      * @param offset the array position at which the slice begins
    181.      * @param length the number of array positions to include in the slice
    182.      */
    183.     Slice(short[] base, int offset, int length)
    184.     {
    185.         requireNonNull(base, "base is null");
    186.         checkPositionIndexes(offset, offset + length, base.length);
    188.         this.base = base;
    189.         this.address = sizeOfShortArray(offset);
    190.         this.size = multiplyExact(length, ARRAY_SHORT_INDEX_SCALE);
    191.         this.retainedSize = INSTANCE_SIZE + sizeOf(base);
    192.         this.reference = (offset == 0 && length == base.length) ? COMPACT : NOT_COMPACT;
    193.     }
    195.     /**
    196.      * Creates a slice over the specified array range.
    197.      *
    198.      * @param offset the array position at which the slice begins
    199.      * @param length the number of array positions to include in the slice
    200.      */
    201.     Slice(int[] base, int offset, int length)
    202.     {
    203.         requireNonNull(base, "base is null");
    204.         checkPositionIndexes(offset, offset + length, base.length);
    206.         this.base = base;
    207.         this.address = sizeOfIntArray(offset);
    208.         this.size = multiplyExact(length, ARRAY_INT_INDEX_SCALE);
    209.         this.retainedSize = INSTANCE_SIZE + sizeOf(base);
    210.         this.reference = (offset == 0 && length == base.length) ? COMPACT : NOT_COMPACT;
    211.     }
    213.     /**
    214.      * Creates a slice over the specified array range.
    215.      *
    216.      * @param offset the array position at which the slice begins
    217.      * @param length the number of array positions to include in the slice
    218.      */
    219.     Slice(long[] base, int offset, int length)
    220.     {
    221.         requireNonNull(base, "base is null");
    222.         checkPositionIndexes(offset, offset + length, base.length);
    224.         this.base = base;
    225.         this.address = sizeOfLongArray(offset);
    226.         this.size = multiplyExact(length, ARRAY_LONG_INDEX_SCALE);
    227.         this.retainedSize = INSTANCE_SIZE + sizeOf(base);
    228.         this.reference = (offset == 0 && length == base.length) ? COMPACT : NOT_COMPACT;
    229.     }
    231.     /**
    232.      * Creates a slice over the specified array range.
    233.      *
    234.      * @param offset the array position at which the slice begins
    235.      * @param length the number of array positions to include in the slice
    236.      */
    237.     Slice(float[] base, int offset, int length)
    238.     {
    239.         requireNonNull(base, "base is null");
    240.         checkPositionIndexes(offset, offset + length, base.length);
    242.         this.base = base;
    243.         this.address = sizeOfFloatArray(offset);
    244.         this.size = multiplyExact(length, ARRAY_FLOAT_INDEX_SCALE);
    245.         this.retainedSize = INSTANCE_SIZE + sizeOf(base);
    246.         this.reference = (offset == 0 && length == base.length) ? COMPACT : NOT_COMPACT;
    247.     }
    249.     /**
    250.      * Creates a slice over the specified array range.
    251.      *
    252.      * @param offset the array position at which the slice begins
    253.      * @param length the number of array positions to include in the slice
    254.      */
    255.     Slice(double[] base, int offset, int length)
    256.     {
    257.         requireNonNull(base, "base is null");
    258.         checkPositionIndexes(offset, offset + length, base.length);
    260.         this.base = base;
    261.         this.address = sizeOfDoubleArray(offset);
    262.         this.size = multiplyExact(length, ARRAY_DOUBLE_INDEX_SCALE);
    263.         this.retainedSize = INSTANCE_SIZE + sizeOf(base);
    264.         this.reference = (offset == 0 && length == base.length) ? COMPACT : NOT_COMPACT;
    265.     }
    267.     /**
    268.      * Creates a slice for directly accessing the base object.
    269.      */
    270.     Slice(@Nullable Object base, long address, int size, long retainedSize, @Nullable Object reference)
    271.     {
    272.         if (address <= 0) {
    273.             throw new IllegalArgumentException(format("Invalid address: %s", address));
    274.         }
    275.         if (size <= 0) {
    276.             throw new IllegalArgumentException(format("Invalid size: %s", size));
    277.         }
    278.         checkArgument((address + size) >= size, "Address + size is greater than 64 bits");
    280.         this.reference = reference;
    281.         this.base = base;
    282.         this.address = address;
    283.         this.size = size;
    284.         // INSTANCE_SIZE is not included, as the caller is responsible for including it.
    285.         this.retainedSize = retainedSize;
    286.     }
    288.     /**
    289.      * Returns the base object of this Slice, or null.  This is appropriate for use
    290.      * with {@link Unsafe} if you wish to avoid all the safety belts e.g. bounds checks.
    291.      */
    292.     public Object getBase()
    293.     {
    294.         return base;
    295.     }
    297.     /**
    298.      * Return the address offset of this Slice.  This is appropriate for use
    299.      * with {@link Unsafe} if you wish to avoid all the safety belts e.g. bounds checks.
    300.      */
    301.     public long getAddress()
    302.     {
    303.         return address;
    304.     }
    306.     /**
    307.      * Length of this slice.
    308.      */
    309.     public int length()
    310.     {
    311.         return size;
    312.     }
    314.     /**
    315.      * Approximate number of bytes retained by this slice.
    316.      */
    317.     public long getRetainedSize()
    318.     {
    319.         return retainedSize;
    320.     }
    322.     /**
    323.      * A slice is considered compact if the base object is an array and it contains the whole array.
    324.      * As a result, it cannot be a view of a bigger slice.
    325.      */
    326.     public boolean isCompact()
    327.     {
    328.         return reference == COMPACT;
    329.     }
    331.     private void checkHasByteArray()
    332.             throws UnsupportedOperationException
    333.     {
    334.         if (!hasByteArray()) {
    335.             throw new UnsupportedOperationException("Slice is not backed by a byte array");
    336.         }
    337.     }
    339.     public boolean hasByteArray()
    340.     {
    341.         return base instanceof byte[];
    342.     }
    344.     /**
    345.      * Returns the byte array wrapped by this Slice, if any. Callers are expected to check {@link Slice#hasByteArray()} before calling
    346.      * this method since not all instances are backed by a byte array. Callers should also take care to use {@link Slice#byteArrayOffset()}
    347.      * since the contents of this Slice may not start at array index 0.
    348.      *
    349.      * @throws UnsupportedOperationException if this Slice has no underlying byte array
    350.      */
    351.     public byte[] byteArray()
    352.             throws UnsupportedOperationException
    353.     {
    354.         checkHasByteArray();
    355.         return (byte[]) base;
    356.     }
    358.     /**
    359.      * Returns the start index the content of this slice within the byte array wrapped by this slice. Callers should
    360.      * check {@link Slice#hasByteArray()} before calling this method since not all Slices wrap a heap byte array
    361.      *
    362.      * @throws UnsupportedOperationException if this Slice has no underlying byte array
    363.      */
    364.     public int byteArrayOffset()
    365.             throws UnsupportedOperationException
    366.     {
    367.         checkHasByteArray();
    368.         return (int) (address - ARRAY_BYTE_BASE_OFFSET);
    369.     }
    371.     /**
    372.      * Fill the slice with the specified value;
    373.      */
    374.     public void fill(byte value)
    375.     {
    376.         int offset = 0;
    377.         int length = size;
    378.         long longValue = fillLong(value);
    379.         while (length >= SIZE_OF_LONG) {
    380.             unsafe.putLong(base, address + offset, longValue);
    381.             offset += SIZE_OF_LONG;
    382.             length -= SIZE_OF_LONG;
    383.         }
    385.         while (length > 0) {
    386.             unsafe.putByte(base, address + offset, value);
    387.             offset++;
    388.             length--;
    389.         }
    390.     }
    392.     /**
    393.      * Fill the slice with zeros;
    394.      */
    395.     public void clear()
    396.     {
    397.         clear(0, size);
    398.     }
    400.     public void clear(int offset, int length)
    401.     {
    402.         while (length >= SIZE_OF_LONG) {
    403.             unsafe.putLong(base, address + offset, 0);
    404.             offset += SIZE_OF_LONG;
    405.             length -= SIZE_OF_LONG;
    406.         }
    408.         while (length > 0) {
    409.             unsafe.putByte(base, address + offset, (byte) 0);
    410.             offset++;
    411.             length--;
    412.         }
    413.     }
    415.     /**
    416.      * Gets a byte at the specified absolute {@code index} in this buffer.
    417.      *
    418.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0} or
    419.      * {@code index + 1} is greater than {@code this.length()}
    420.      */
    421.     public byte getByte(int index)
    422.     {
    423.         checkIndexLength(index, SIZE_OF_BYTE);
    424.         return getByteUnchecked(index);
    425.     }
    427.     byte getByteUnchecked(int index)
    428.     {
    429.         return unsafe.getByte(base, address + index);
    430.     }
    432.     /**
    433.      * Gets an unsigned byte at the specified absolute {@code index} in this
    434.      * buffer.
    435.      *
    436.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0} or
    437.      * {@code index + 1} is greater than {@code this.length()}
    438.      */
    439.     public short getUnsignedByte(int index)
    440.     {
    441.         return (short) (getByte(index) & 0xFF);
    442.     }
    444.     /**
    445.      * Gets a 16-bit short integer at the specified absolute {@code index} in
    446.      * this slice.
    447.      *
    448.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0} or
    449.      * {@code index + 2} is greater than {@code this.length()}
    450.      */
    451.     public short getShort(int index)
    452.     {
    453.         checkIndexLength(index, SIZE_OF_SHORT);
    454.         return getShortUnchecked(index);
    455.     }
    457.     short getShortUnchecked(int index)
    458.     {
    459.         return unsafe.getShort(base, address + index);
    460.     }
    462.     /**
    463.      * Gets an unsigned 16-bit short integer at the specified absolute {@code index}
    464.      * in this slice.
    465.      *
    466.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0} or
    467.      * {@code index + 2} is greater than {@code this.length()}
    468.      */
    469.     public int getUnsignedShort(int index)
    470.     {
    471.         return getShort(index) & 0xFFFF;
    472.     }
    474.     /**
    475.      * Gets a 32-bit integer at the specified absolute {@code index} in
    476.      * this buffer.
    477.      *
    478.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0} or
    479.      * {@code index + 4} is greater than {@code this.length()}
    480.      */
    481.     public int getInt(int index)
    482.     {
    483.         checkIndexLength(index, SIZE_OF_INT);
    484.         return getIntUnchecked(index);
    485.     }
    487.     int getIntUnchecked(int index)
    488.     {
    489.         return unsafe.getInt(base, address + index);
    490.     }
    492.     /**
    493.      * Gets an unsigned 32-bit integer at the specified absolute {@code index} in
    494.      * this buffer.
    495.      *
    496.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0} or
    497.      * {@code index + 4} is greater than {@code this.length()}
    498.      */
    499.     public long getUnsignedInt(int index)
    500.     {
    501.         return getInt(index) & 0xFFFFFFFFL;
    502.     }
    504.     /**
    505.      * Gets a 64-bit long integer at the specified absolute {@code index} in
    506.      * this buffer.
    507.      *
    508.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0} or
    509.      * {@code index + 8} is greater than {@code this.length()}
    510.      */
    511.     public long getLong(int index)
    512.     {
    513.         checkIndexLength(index, SIZE_OF_LONG);
    514.         return getLongUnchecked(index);
    515.     }
    517.     long getLongUnchecked(int index)
    518.     {
    519.         return unsafe.getLong(base, address + index);
    520.     }
    522.     /**
    523.      * Gets a 32-bit float at the specified absolute {@code index} in
    524.      * this buffer.
    525.      *
    526.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0} or
    527.      * {@code index + 4} is greater than {@code this.length()}
    528.      */
    529.     public float getFloat(int index)
    530.     {
    531.         checkIndexLength(index, SIZE_OF_FLOAT);
    532.         return unsafe.getFloat(base, address + index);
    533.     }
    535.     /**
    536.      * Gets a 64-bit double at the specified absolute {@code index} in
    537.      * this buffer.
    538.      *
    539.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0} or
    540.      * {@code index + 8} is greater than {@code this.length()}
    541.      */
    542.     public double getDouble(int index)
    543.     {
    544.         checkIndexLength(index, SIZE_OF_DOUBLE);
    545.         return unsafe.getDouble(base, address + index);
    546.     }
    548.     /**
    549.      * Transfers portion of data from this slice into the specified destination starting at
    550.      * the specified absolute {@code index}.
    551.      *
    552.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0}, or
    553.      * if {@code index + destination.length()} is greater than {@code this.length()}
    554.      */
    555.     public void getBytes(int index, Slice destination)
    556.     {
    557.         getBytes(index, destination, 0, destination.length());
    558.     }
    560.     /**
    561.      * Transfers portion of data from this slice into the specified destination starting at
    562.      * the specified absolute {@code index}.
    563.      *
    564.      * @param destinationIndex the first index of the destination
    565.      * @param length the number of bytes to transfer
    566.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0},
    567.      * if the specified {@code destinationIndex} is less than {@code 0},
    568.      * if {@code index + length} is greater than
    569.      * {@code this.length()}, or
    570.      * if {@code destinationIndex + length} is greater than
    571.      * {@code destination.length()}
    572.      */
    573.     public void getBytes(int index, Slice destination, int destinationIndex, int length)
    574.     {
    575.         destination.setBytes(destinationIndex, this, index, length);
    576.     }
    578.     /**
    579.      * Transfers portion of data from this slice into the specified destination starting at
    580.      * the specified absolute {@code index}.
    581.      *
    582.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0}, or
    583.      * if {@code index + destination.length} is greater than {@code this.length()}
    584.      */
    585.     public void getBytes(int index, byte[] destination)
    586.     {
    587.         getBytes(index, destination, 0, destination.length);
    588.     }
    590.     /**
    591.      * Transfers portion of data from this slice into the specified destination starting at
    592.      * the specified absolute {@code index}.
    593.      *
    594.      * @param destinationIndex the first index of the destination
    595.      * @param length the number of bytes to transfer
    596.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0},
    597.      * if the specified {@code destinationIndex} is less than {@code 0},
    598.      * if {@code index + length} is greater than
    599.      * {@code this.length()}, or
    600.      * if {@code destinationIndex + length} is greater than
    601.      * {@code destination.length}
    602.      */
    603.     public void getBytes(int index, byte[] destination, int destinationIndex, int length)
    604.     {
    605.         checkIndexLength(index, length);
    606.         checkPositionIndexes(destinationIndex, destinationIndex + length, destination.length);
    608.         copyMemory(base, address + index, destination, (long) ARRAY_BYTE_BASE_OFFSET + destinationIndex, length);
    609.     }
    611.     /**
    612.      * Returns a copy of this buffer as a byte array.
    613.      */
    614.     public byte[] getBytes()
    615.     {
    616.         return getBytes(0, length());
    617.     }
    619.     /**
    620.      * Returns a copy of this buffer as a byte array.
    621.      *
    622.      * @param index the absolute index to start at
    623.      * @param length the number of bytes to return
    624.      * @throws IndexOutOfBoundsException if the specified {@code index} is less then {@code 0},
    625.      * or if the specified {@code index + length} is greater than {@code this.length()}
    626.      */
    627.     public byte[] getBytes(int index, int length)
    628.     {
    629.         byte[] bytes = new byte[length];
    630.         getBytes(index, bytes, 0, length);
    631.         return bytes;
    632.     }
    634.     /**
    635.      * Transfers a portion of data from this slice into the specified stream starting at the
    636.      * specified absolute {@code index}.
    637.      *
    638.      * @param length the number of bytes to transfer
    639.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0} or
    640.      * if {@code index + length} is greater than
    641.      * {@code this.length()}
    642.      * @throws java.io.IOException if the specified stream threw an exception during I/O
    643.      */
    644.     public void getBytes(int index, OutputStream out, int length)
    645.             throws IOException
    646.     {
    647.         checkIndexLength(index, length);
    649.         if (hasByteArray()) {
    650.             out.write(byteArray(), byteArrayOffset() + index, length);
    651.             return;
    652.         }
    654.         byte[] buffer = new byte[4096];
    655.         while (length > 0) {
    656.             int size = min(buffer.length, length);
    657.             getBytes(index, buffer, 0, size);
    658.             out.write(buffer, 0, size);
    659.             length -= size;
    660.             index += size;
    661.         }
    662.     }
    664.     /**
    665.      * Sets the specified byte at the specified absolute {@code index} in this
    666.      * buffer.  The 24 high-order bits of the specified value are ignored.
    667.      *
    668.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0} or
    669.      * {@code index + 1} is greater than {@code this.length()}
    670.      */
    671.     public void setByte(int index, int value)
    672.     {
    673.         checkIndexLength(index, SIZE_OF_BYTE);
    674.         setByteUnchecked(index, value);
    675.     }
    677.     void setByteUnchecked(int index, int value)
    678.     {
    679.         unsafe.putByte(base, address + index, (byte) (value & 0xFF));
    680.     }
    682.     /**
    683.      * Sets the specified 16-bit short integer at the specified absolute
    684.      * {@code index} in this buffer.  The 16 high-order bits of the specified
    685.      * value are ignored.
    686.      *
    687.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0} or
    688.      * {@code index + 2} is greater than {@code this.length()}
    689.      */
    690.     public void setShort(int index, int value)
    691.     {
    692.         checkIndexLength(index, SIZE_OF_SHORT);
    693.         setShortUnchecked(index, value);
    694.     }
    696.     void setShortUnchecked(int index, int value)
    697.     {
    698.         unsafe.putShort(base, address + index, (short) (value & 0xFFFF));
    699.     }
    701.     /**
    702.      * Sets the specified 32-bit integer at the specified absolute
    703.      * {@code index} in this buffer.
    704.      *
    705.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0} or
    706.      * {@code index + 4} is greater than {@code this.length()}
    707.      */
    708.     public void setInt(int index, int value)
    709.     {
    710.         checkIndexLength(index, SIZE_OF_INT);
    711.         setIntUnchecked(index, value);
    712.     }
    714.     void setIntUnchecked(int index, int value)
    715.     {
    716.         unsafe.putInt(base, address + index, value);
    717.     }
    719.     /**
    720.      * Sets the specified 64-bit long integer at the specified absolute
    721.      * {@code index} in this buffer.
    722.      *
    723.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0} or
    724.      * {@code index + 8} is greater than {@code this.length()}
    725.      */
    726.     public void setLong(int index, long value)
    727.     {
    728.         checkIndexLength(index, SIZE_OF_LONG);
    729.         setLongUnchecked(index, value);
    730.     }
    732.     void setLongUnchecked(int index, long value)
    733.     {
    734.         unsafe.putLong(base, address + index, value);
    735.     }
    737.     /**
    738.      * Sets the specified 32-bit float at the specified absolute
    739.      * {@code index} in this buffer.
    740.      *
    741.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0} or
    742.      * {@code index + 4} is greater than {@code this.length()}
    743.      */
    744.     public void setFloat(int index, float value)
    745.     {
    746.         checkIndexLength(index, SIZE_OF_FLOAT);
    747.         unsafe.putFloat(base, address + index, value);
    748.     }
    750.     /**
    751.      * Sets the specified 64-bit double at the specified absolute
    752.      * {@code index} in this buffer.
    753.      *
    754.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0} or
    755.      * {@code index + 8} is greater than {@code this.length()}
    756.      */
    757.     public void setDouble(int index, double value)
    758.     {
    759.         checkIndexLength(index, SIZE_OF_DOUBLE);
    760.         unsafe.putDouble(base, address + index, value);
    761.     }
    763.     /**
    764.      * Transfers data from the specified slice into this buffer starting at
    765.      * the specified absolute {@code index}.
    766.      *
    767.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0}, or
    768.      * if {@code index + source.length()} is greater than {@code this.length()}
    769.      */
    770.     public void setBytes(int index, Slice source)
    771.     {
    772.         setBytes(index, source, 0, source.length());
    773.     }
    775.     /**
    776.      * Transfers data from the specified slice into this buffer starting at
    777.      * the specified absolute {@code index}.
    778.      *
    779.      * @param sourceIndex the first index of the source
    780.      * @param length the number of bytes to transfer
    781.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0},
    782.      * if the specified {@code sourceIndex} is less than {@code 0},
    783.      * if {@code index + length} is greater than
    784.      * {@code this.length()}, or
    785.      * if {@code sourceIndex + length} is greater than
    786.      * {@code source.length()}
    787.      */
    788.     public void setBytes(int index, Slice source, int sourceIndex, int length)
    789.     {
    790.         checkIndexLength(index, length);
    791.         checkPositionIndexes(sourceIndex, sourceIndex + length, source.length());
    793.         copyMemory(source.base, source.address + sourceIndex, base, address + index, length);
    794.     }
    796.     /**
    797.      * Transfers data from the specified slice into this buffer starting at
    798.      * the specified absolute {@code index}.
    799.      *
    800.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0}, or
    801.      * if {@code index + source.length} is greater than {@code this.length()}
    802.      */
    803.     public void setBytes(int index, byte[] source)
    804.     {
    805.         setBytes(index, source, 0, source.length);
    806.     }
    808.     /**
    809.      * Transfers data from the specified array into this buffer starting at
    810.      * the specified absolute {@code index}.
    811.      *
    812.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0},
    813.      * if the specified {@code sourceIndex} is less than {@code 0},
    814.      * if {@code index + length} is greater than
    815.      * {@code this.length()}, or
    816.      * if {@code sourceIndex + length} is greater than {@code source.length}
    817.      */
    818.     public void setBytes(int index, byte[] source, int sourceIndex, int length)
    819.     {
    820.         checkIndexLength(index, length);
    821.         checkPositionIndexes(sourceIndex, sourceIndex + length, source.length);
    822.         copyMemory(source, (long) ARRAY_BYTE_BASE_OFFSET + sourceIndex, base, address + index, length);
    823.     }
    825.     /**
    826.      * Transfers data from the specified input stream into this slice starting at
    827.      * the specified absolute {@code index}.
    828.      *
    829.      * @throws IndexOutOfBoundsException if the specified {@code index} is less than {@code 0}, or
    830.      * if {@code index + source.length} is greater than {@code this.length()}
    831.      */
    832.     public void setBytes(int index, InputStream in, int length)
    833.             throws IOException
    834.     {
    835.         checkIndexLength(index, length);
    836.         if (hasByteArray()) {
    837.             byte[] bytes = byteArray();
    838.             int offset = byteArrayOffset() + index;
    839.             while (length > 0) {
    840.                 int bytesRead = in.read(bytes, offset, length);
    841.                 if (bytesRead < 0) {
    842.                     throw new IndexOutOfBoundsException("End of stream");
    843.                 }
    844.                 length -= bytesRead;
    845.                 offset += bytesRead;
    846.             }
    847.             return;
    848.         }
    850.         byte[] bytes = new byte[4096];
    852.         while (length > 0) {
    853.             int bytesRead = in.read(bytes, 0, min(bytes.length, length));
    854.             if (bytesRead < 0) {
    855.                 throw new IndexOutOfBoundsException("End of stream");
    856.             }
    857.             copyMemory(bytes, ARRAY_BYTE_BASE_OFFSET, base, address + index, bytesRead);
    858.             length -= bytesRead;
    859.             index += bytesRead;
    860.         }
    861.     }
    863.     /**
    864.      * Returns a slice of this buffer's sub-region. Modifying the content of
    865.      * the returned buffer or this buffer affects each other's content.
    866.      */
    867.     public Slice slice(int index, int length)
    868.     {
    869.         if ((index == 0) && (length == length())) {
    870.             return this;
    871.         }
    872.         checkIndexLength(index, length);
    873.         if (length == 0) {
    874.             return Slices.EMPTY_SLICE;
    875.         }
    877.         if (reference == COMPACT) {
    878.             return new Slice(base, address + index, length, retainedSize, NOT_COMPACT);
    879.         }
    880.         return new Slice(base, address + index, length, retainedSize, reference);
    881.     }
    883.     public int indexOfByte(int b)
    884.     {
    885.         checkArgument((b >> Byte.SIZE) == 0, "byte value out of range");
    886.         return indexOfByte((byte) b);
    887.     }
    889.     public int indexOfByte(byte b)
    890.     {
    891.         for (int i = 0; i < size; i++) {
    892.             if (getByteUnchecked(i) == b) {
    893.                 return i;
    894.             }
    895.         }
    896.         return -1;
    897.     }
    899.     /**
    900.      * Returns the index of the first occurrence of the pattern with this slice.
    901.      * If the pattern is not found -1 is returned. If patten is empty, zero is
    902.      * returned.
    903.      */
    904.     public int indexOf(Slice slice)
    905.     {
    906.         return indexOf(slice, 0);
    907.     }
    909.     /**
    910.      * Returns the index of the first occurrence of the pattern with this slice.
    911.      * If the pattern is not found -1 is returned. If patten is empty, the offset
    912.      * is returned.
    913.      */
    914.     public int indexOf(Slice pattern, int offset)
    915.     {
    916.         if (size == 0 || offset >= size) {
    917.             return -1;
    918.         }
    920.         if (pattern.length() == 0) {
    921.             return offset;
    922.         }
    924.         // Do we have enough characters
    925.         if (pattern.length() < SIZE_OF_INT || size < SIZE_OF_LONG) {
    926.             return indexOfBruteForce(pattern, offset);
    927.         }
    929.         // Using first four bytes for faster search. We are not using eight bytes for long
    930.         // because we want more strings to get use of fast search.
    931.         int head = pattern.getIntUnchecked(0);
    933.         // Take the first byte of head for faster skipping
    934.         int firstByteMask = head & 0xff;
    935.         firstByteMask |= firstByteMask << 8;
    936.         firstByteMask |= firstByteMask << 16;
    938.         int lastValidIndex = size - pattern.length();
    939.         int index = offset;
    940.         while (index <= lastValidIndex) {
    941.             // Read four bytes in sequence
    942.             int value = getIntUnchecked(index);
    944.             // Compare all bytes of value with first byte of search data
    945.             // see https://graphics.stanford.edu/~seander/bithacks.html#ZeroInWord
    946.             int valueXor = value ^ firstByteMask;
    947.             int hasZeroBytes = (valueXor - 0x01010101) & ~valueXor & 0x80808080;
    949.             // If valueXor doesn't have any zero byte then there is no match and we can advance
    950.             if (hasZeroBytes == 0) {
    951.                 index += SIZE_OF_INT;
    952.                 continue;
    953.             }
    955.             // Try fast match of head and the rest
    956.             if (value == head && equalsUnchecked(index, pattern, 0, pattern.length())) {
    957.                 return index;
    958.             }
    960.             index++;
    961.         }
    963.         return -1;
    964.     }
    966.     int indexOfBruteForce(Slice pattern, int offset)
    967.     {
    968.         if (size == 0 || offset >= size) {
    969.             return -1;
    970.         }
    972.         if (pattern.length() == 0) {
    973.             return offset;
    974.         }
    976.         byte firstByte = pattern.getByteUnchecked(0);
    977.         int lastValidIndex = size - pattern.length();
    978.         int index = offset;
    979.         while (true) {
    980.             // seek to first byte match
    981.             while (index < lastValidIndex && getByteUnchecked(index) != firstByte) {
    982.                 index++;
    983.             }
    984.             if (index > lastValidIndex) {
    985.                 break;
    986.             }
    988.             if (equalsUnchecked(index, pattern, 0, pattern.length())) {
    989.                 return index;
    990.             }
    992.             index++;
    993.         }
    995.         return -1;
    996.     }
    998.     /**
    999.      * Compares the content of the specified buffer to the content of this
    1000.      * buffer.  This comparison is performed byte by byte using an unsigned
    1001.      * comparison.
    1002.      */
    1003.     @SuppressWarnings("ObjectEquality")
    1004.     @Override
    1005.     public int compareTo(Slice that)
    1006.     {
    1007.         if (this == that) {
    1008.             return 0;
    1009.         }
    1010.         return compareTo(0, size, that, 0, that.size);
    1011.     }
    1013.     /**
    1014.      * Compares a portion of this slice with a portion of the specified slice.  Equality is
    1015.      * solely based on the contents of the slice.
    1016.      */
    1017.     @SuppressWarnings("ObjectEquality")
    1018.     public int compareTo(int offset, int length, Slice that, int otherOffset, int otherLength)
    1019.     {
    1020.         if ((this == that) && (offset == otherOffset) && (length == otherLength)) {
    1021.             return 0;
    1022.         }
    1024.         checkIndexLength(offset, length);
    1025.         that.checkIndexLength(otherOffset, otherLength);
    1027.         long thisAddress = address + offset;
    1028.         long thatAddress = that.address + otherOffset;
    1030.         int compareLength = min(length, otherLength);
    1031.         while (compareLength >= SIZE_OF_LONG) {
    1032.             long thisLong = unsafe.getLong(base, thisAddress);
    1033.             long thatLong = unsafe.getLong(that.base, thatAddress);
    1035.             if (thisLong != thatLong) {
    1036.                 return longBytesToLong(thisLong) < longBytesToLong(thatLong) ? -1 : 1;
    1037.             }
    1039.             thisAddress += SIZE_OF_LONG;
    1040.             thatAddress += SIZE_OF_LONG;
    1041.             compareLength -= SIZE_OF_LONG;
    1042.         }
    1044.         while (compareLength > 0) {
    1045.             byte thisByte = unsafe.getByte(base, thisAddress);
    1046.             byte thatByte = unsafe.getByte(that.base, thatAddress);
    1048.             int v = compareUnsignedBytes(thisByte, thatByte);
    1049.             if (v != 0) {
    1050.                 return v;
    1051.             }
    1052.             thisAddress++;
    1053.             thatAddress++;
    1054.             compareLength--;
    1055.         }
    1057.         return Integer.compare(length, otherLength);
    1058.     }
    1060.     /**
    1061.      * Compares the specified object with this slice for equality.  Equality is
    1062.      * solely based on the contents of the slice.
    1063.      */
    1064.     @Override
    1065.     public boolean equals(Object o)
    1066.     {
    1067.         if (this == o) {
    1068.             return true;
    1069.         }
    1070.         if (!(o instanceof Slice)) {
    1071.             return false;
    1072.         }
    1074.         Slice that = (Slice) o;
    1075.         if (length() != that.length()) {
    1076.             return false;
    1077.         }
    1079.         return equalsUnchecked(0, that, 0, length());
    1080.     }
    1082.     /**
    1083.      * Returns the hash code of this slice.  The hash code is cached once calculated
    1084.      * and any future changes to the slice will not effect the hash code.
    1085.      */
    1086.     @SuppressWarnings("NonFinalFieldReferencedInHashCode")
    1087.     @Override
    1088.     public int hashCode()
    1089.     {
    1090.         if (hash != 0) {
    1091.             return hash;
    1092.         }
    1094.         hash = hashCode(0, size);
    1095.         return hash;
    1096.     }
    1098.     /**
    1099.      * Returns the hash code of a portion of this slice.
    1100.      */
    1101.     public int hashCode(int offset, int length)
    1102.     {
    1103.         return (int) XxHash64.hash(this, offset, length);
    1104.     }
    1106.     /**
    1107.      * Compares a portion of this slice with a portion of the specified slice.  Equality is
    1108.      * solely based on the contents of the slice.
    1109.      */
    1110.     @SuppressWarnings("ObjectEquality")
    1111.     public boolean equals(int offset, int length, Slice that, int otherOffset, int otherLength)
    1112.     {
    1113.         if (length != otherLength) {
    1114.             return false;
    1115.         }
    1117.         if ((this == that) && (offset == otherOffset)) {
    1118.             return true;
    1119.         }
    1121.         checkIndexLength(offset, length);
    1122.         that.checkIndexLength(otherOffset, otherLength);
    1124.         return equalsUnchecked(offset, that, otherOffset, length);
    1125.     }
    1127.     boolean equalsUnchecked(int offset, Slice that, int otherOffset, int length)
    1128.     {
    1129.         long thisAddress = address + offset;
    1130.         long thatAddress = that.address + otherOffset;
    1132.         while (length >= SIZE_OF_LONG) {
    1133.             long thisLong = unsafe.getLong(base, thisAddress);
    1134.             long thatLong = unsafe.getLong(that.base, thatAddress);
    1136.             if (thisLong != thatLong) {
    1137.                 return false;
    1138.             }
    1140.             thisAddress += SIZE_OF_LONG;
    1141.             thatAddress += SIZE_OF_LONG;
    1142.             length -= SIZE_OF_LONG;
    1143.         }
    1145.         while (length > 0) {
    1146.             byte thisByte = unsafe.getByte(base, thisAddress);
    1147.             byte thatByte = unsafe.getByte(that.base, thatAddress);
    1148.             if (thisByte != thatByte) {
    1149.                 return false;
    1150.             }
    1151.             thisAddress++;
    1152.             thatAddress++;
    1153.             length--;
    1154.         }
    1156.         return true;
    1157.     }
    1159.     /**
    1160.      * Creates a slice input backed by this slice.  Any changes to this slice
    1161.      * will be immediately visible to the slice input.
    1162.      */
    1163.     public BasicSliceInput getInput()
    1164.     {
    1165.         return new BasicSliceInput(this);
    1166.     }
    1168.     /**
    1169.      * Creates a slice output backed by this slice.  Any data written to the
    1170.      * slice output will be immediately visible in this slice.
    1171.      */
    1172.     public SliceOutput getOutput()
    1173.     {
    1174.         return new BasicSliceOutput(this);
    1175.     }
    1177.     /**
    1178.      * Decodes the contents of this slice into a string with the specified
    1179.      * character set name.
    1180.      */
    1181.     public String toString(Charset charset)
    1182.     {
    1183.         return toString(0, length(), charset);
    1184.     }
    1186.     /**
    1187.      * Decodes the contents of this slice into a string using the UTF-8
    1188.      * character set.
    1189.      */
    1190.     public String toStringUtf8()
    1191.     {
    1192.         return toString(UTF_8);
    1193.     }
    1195.     /**
    1196.      * Decodes the contents of this slice into a string using the US_ASCII
    1197.      * character set.  The low order 7 bits if each byte are converted directly
    1198.      * into a code point for the string.
    1199.      */
    1200.     public String toStringAscii()
    1201.     {
    1202.         return toStringAscii(0, size);
    1203.     }
    1205.     public String toStringAscii(int index, int length)
    1206.     {
    1207.         checkIndexLength(index, length);
    1208.         if (length == 0) {
    1209.             return "";
    1210.         }
    1212.         if (hasByteArray()) {
    1213.             //noinspection deprecation
    1214.             return new String(byteArray(), 0, byteArrayOffset() + index, length);
    1215.         }
    1217.         char[] chars = new char[length];
    1218.         for (int pos = index; pos < length; pos++) {
    1219.             chars[pos] = (char) (getByteUnchecked(pos) & 0x7F);
    1220.         }
    1221.         return new String(chars);
    1222.     }
    1224.     /**
    1225.      * Decodes the a portion of this slice into a string with the specified
    1226.      * character set name.
    1227.      */
    1228.     public String toString(int index, int length, Charset charset)
    1229.     {
    1230.         if (length == 0) {
    1231.             return "";
    1232.         }
    1233.         if (hasByteArray()) {
    1234.             return new String(byteArray(), byteArrayOffset() + index, length, charset);
    1235.         }
    1236.         return new String(getBytes(index, length), charset);
    1237.     }
    1239.     public ByteBuffer toByteBuffer()
    1240.     {
    1241.         return toByteBuffer(0, size);
    1242.     }
    1244.     public ByteBuffer toByteBuffer(int index, int length)
    1245.     {
    1246.         checkIndexLength(index, length);
    1248.         if (length() == 0) {
    1249.             return EMPTY_BYTE_BUFFER;
    1250.         }
    1252.         if (hasByteArray()) {
    1253.             return ByteBuffer.wrap(byteArray(), byteArrayOffset() + index, length).slice();
    1254.         }
    1256.         if ((reference instanceof ByteBuffer) && ((ByteBuffer) reference).isDirect()) {
    1257.             ByteBuffer buffer = (ByteBuffer) reference;
    1258.             int position = toIntExact(address - bufferAddress(buffer)) + index;
    1259.             buffer = buffer.duplicate();
    1260.             buffer.position(position);
    1261.             buffer.limit(position + length);
    1262.             return buffer.slice();
    1263.         }
    1265.         throw new UnsupportedOperationException("Conversion to ByteBuffer not supported for this Slice");
    1266.     }
    1268.     /**
    1269.      * Decodes the a portion of this slice into a string with the specified
    1270.      * character set name.
    1271.      */
    1272.     @Override
    1273.     public String toString()
    1274.     {
    1275.         StringBuilder builder = new StringBuilder("Slice{");
    1276.         if (base != null) {
    1277.             builder.append("base=").append(identityToString(base)).append(", ");
    1278.         }
    1279.         builder.append("address=").append(address);
    1280.         builder.append(", length=").append(length());
    1281.         builder.append('}');
    1282.         return builder.toString();
    1283.     }
    1285.     private static String identityToString(Object o)
    1286.     {
    1287.         if (o == null) {
    1288.             return null;
    1289.         }
    1290.         return o.getClass().getName() + "@" + Integer.toHexString(System.identityHashCode(o));
    1291.     }
    1293.     private static void copyMemory(Object src, long srcAddress, Object dest, long destAddress, int length)
    1294.     {
    1295.         // The Unsafe Javadoc specifies that the transfer size is 8 iff length % 8 == 0
    1296.         // so ensure that we copy big chunks whenever possible, even at the expense of two separate copy operations
    1297.         int bytesToCopy = length - (length % 8);
    1298.         unsafe.copyMemory(src, srcAddress, dest, destAddress, bytesToCopy);
    1299.         unsafe.copyMemory(src, srcAddress + bytesToCopy, dest, destAddress + bytesToCopy, length - bytesToCopy);
    1300.     }
    1302.     private void checkIndexLength(int index, int length)
    1303.     {
    1304.         checkPositionIndexes(index, index + length, length());
    1305.     }
    1307.     //
    1308.     // The following methods were forked from Guava primitives
    1309.     //
    1311.     private static long fillLong(byte value)
    1312.     {
    1313.         return (value & 0xFFL) << 56
    1314.                 | (value & 0xFFL) << 48
    1315.                 | (value & 0xFFL) << 40
    1316.                 | (value & 0xFFL) << 32
    1317.                 | (value & 0xFFL) << 24
    1318.                 | (value & 0xFFL) << 16
    1319.                 | (value & 0xFFL) << 8
    1320.                 | (value & 0xFFL);
    1321.     }
    1323.     private static int compareUnsignedBytes(byte thisByte, byte thatByte)
    1324.     {
    1325.         return unsignedByteToInt(thisByte) - unsignedByteToInt(thatByte);
    1326.     }
    1328.     private static int unsignedByteToInt(byte thisByte)
    1329.     {
    1330.         return thisByte & 0xFF;
    1331.     }
    1333.     /**
    1334.      * Turns a long representing a sequence of 8 bytes read in little-endian order
    1335.      * into a number that when compared produces the same effect as comparing the
    1336.      * original sequence of bytes lexicographically
    1337.      */
    1338.     private static long longBytesToLong(long bytes)
    1339.     {
    1340.         return Long.reverseBytes(bytes) ^ Long.MIN_VALUE;
    1341.     }
    1342. }