Java Code Examples for java.nio.ByteOrder#equals()

private static void verifyByteOrder()
{
    ByteOrder order = ByteOrder.nativeOrder();
    if (!order.equals(ByteOrder.LITTLE_ENDIAN)) {
        failRequirement("Presto requires a little endian platform (found %s)", order);
    }
}
 

/**
 * Sets the order of the buffer.
 *
 * @param order
 *            The order of the buffer.
 */
public void setByteOrder(ByteOrder order) {
    if (!order.equals(fByteOrder)) {
        fByteOrder = order;
        fBuffer.order(order);
    }
}
 

/**
 * Create a new bit input stream based on an existing Java InputStream.
 *
 * @param aIS
 *        the input stream this class should read the bits from. May not be
 *        <code>null</code>.
 * @param aByteOrder
 *        The non-<code>null</code> byte order to use.
 */
public NonBlockingBitInputStream (@Nonnull final InputStream aIS, @Nonnull final ByteOrder aByteOrder)
{
  ValueEnforcer.notNull (aIS, "InputStream");
  ValueEnforcer.notNull (aByteOrder, "ByteOrder");

  m_aIS = StreamHelper.getBuffered (aIS);
  m_bHighOrderBitFirst = aByteOrder.equals (ByteOrder.LITTLE_ENDIAN);
  m_nNextBitIndex = CGlobal.BITS_PER_BYTE;
}
 

/**
 * Create a new bit output stream based on an existing Java OutputStream.
 *
 * @param aOS
 *        the output stream this class should use. May not be
 *        <code>null</code>.
 * @param aByteOrder
 *        The non-<code>null</code> byte order to use.
 */
public NonBlockingBitOutputStream (@Nonnull final OutputStream aOS, @Nonnull final ByteOrder aByteOrder)
{
  ValueEnforcer.notNull (aOS, "OutputStream");
  ValueEnforcer.notNull (aByteOrder, "ByteOrder");

  m_aOS = aOS;
  m_bHighOrderBitFirst = aByteOrder.equals (ByteOrder.LITTLE_ENDIAN);
  m_nBufferedBitCount = 0;
}
 

/**
 * Creates a new composite buffer which wraps the slices of the specified
 * NIO buffers without copying them.  A modification on the content of the
 * specified buffers will be visible to the returned buffer.
 * If gathering is {@code true} then gathering writes will be used when ever
 * possible.
 *
 * @throws IllegalArgumentException
 *         if the specified buffers' endianness are different from each
 *         other
 */
public static ChannelBuffer wrappedBuffer(boolean gathering, ByteBuffer... buffers) {
    switch (buffers.length) {
    case 0:
        break;
    case 1:
        if (buffers[0].hasRemaining()) {
            return wrappedBuffer(buffers[0]);
        }
        break;
    default:
        ByteOrder order = null;
        final List<ChannelBuffer> components = new ArrayList<ChannelBuffer>(buffers.length);
        for (ByteBuffer b: buffers) {
            if (b == null) {
                break;
            }
            if (b.hasRemaining()) {
                if (order != null) {
                    if (!order.equals(b.order())) {
                        throw new IllegalArgumentException(
                                "inconsistent byte order");
                    }
                } else {
                    order = b.order();
                }
                components.add(wrappedBuffer(b));
            }
        }
        return compositeBuffer(order, components, gathering);
    }

    return EMPTY_BUFFER;
}
 

/**
 * Creates a new composite buffer which wraps the slices of the specified
 * NIO buffers without copying them.  A modification on the content of the
 * specified buffers will be visible to the returned buffer.
 * If gathering is {@code true} then gathering writes will be used when ever
 * possible.
 *
 * @throws IllegalArgumentException
 *         if the specified buffers' endianness are different from each
 *         other
 */
public static ChannelBuffer wrappedBuffer(boolean gathering, ByteBuffer... buffers) {
    switch (buffers.length) {
    case 0:
        break;
    case 1:
        if (buffers[0].hasRemaining()) {
            return wrappedBuffer(buffers[0]);
        }
        break;
    default:
        ByteOrder order = null;
        final List<ChannelBuffer> components = new ArrayList<ChannelBuffer>(buffers.length);
        for (ByteBuffer b: buffers) {
            if (b == null) {
                break;
            }
            if (b.hasRemaining()) {
                if (order != null) {
                    if (!order.equals(b.order())) {
                        throw new IllegalArgumentException(
                                "inconsistent byte order");
                    }
                } else {
                    order = b.order();
                }
                components.add(wrappedBuffer(b));
            }
        }
        return compositeBuffer(order, components, gathering);
    }

    return EMPTY_BUFFER;
}
 

public void order(ByteOrder bo) {
  if (bo == null)
    return;
  this.bigEndian = bo.equals(ByteOrder.BIG_ENDIAN);
}
 

private static boolean isBigEndian(@Nullable ByteOrder byteOrder) {
    return (byteOrder != null) && byteOrder.equals(ByteOrder.BIG_ENDIAN);
}
 

/**
 * Creates a new composite buffer which wraps the readable bytes of the
 * specified buffers without copying them.  A modification on the content
 * of the specified buffers will be visible to the returned buffer.
 * If gathering is {@code true} then gathering writes will be used when ever
 * possible.
 *
 * @throws IllegalArgumentException
 *         if the specified buffers' endianness are different from each
 *         other
 */
public static ChannelBuffer wrappedBuffer(boolean gathering, ChannelBuffer... buffers) {
    switch (buffers.length) {
    case 0:
        break;
    case 1:
        if (buffers[0].readable()) {
            return wrappedBuffer(buffers[0]);
        }
        break;
    default:
        ByteOrder order = null;
        final List<ChannelBuffer> components = new ArrayList<ChannelBuffer>(buffers.length);
        for (ChannelBuffer c: buffers) {
            if (c == null) {
                break;
            }
            if (c.readable()) {
                if (order != null) {
                    if (!order.equals(c.order())) {
                        throw new IllegalArgumentException(
                                "inconsistent byte order");
                    }
                } else {
                    order = c.order();
                }
                if (c instanceof CompositeChannelBuffer) {
                    // Expand nested composition.
                    components.addAll(
                            ((CompositeChannelBuffer) c).decompose(
                                    c.readerIndex(), c.readableBytes()));
                } else {
                    // An ordinary buffer (non-composite)
                    components.add(c.slice());
                }
            }
        }
        return compositeBuffer(order, components, gathering);
    }
    return EMPTY_BUFFER;
}
 

DirectMemory(long address, long length, ByteOrder order) {
    this.address = address;
    this.length = length;
    this.order = order;
    directDataAccess = order.equals(ByteOrder.nativeOrder()) ? NativeEndianDirectDataAccess.getInstance() : ReverseEndianDirectDataAccess.getInstance();
}
 

/**
 * Creates a new composite buffer which wraps the readable bytes of the
 * specified buffers without copying them.  A modification on the content
 * of the specified buffers will be visible to the returned buffer.
 * If gathering is {@code true} then gathering writes will be used when ever
 * possible.
 *
 * @throws IllegalArgumentException
 *         if the specified buffers' endianness are different from each
 *         other
 */
public static ChannelBuffer wrappedBuffer(boolean gathering, ChannelBuffer... buffers) {
    switch (buffers.length) {
    case 0:
        break;
    case 1:
        if (buffers[0].readable()) {
            return wrappedBuffer(buffers[0]);
        }
        break;
    default:
        ByteOrder order = null;
        final List<ChannelBuffer> components = new ArrayList<ChannelBuffer>(buffers.length);
        for (ChannelBuffer c: buffers) {
            if (c == null) {
                break;
            }
            if (c.readable()) {
                if (order != null) {
                    if (!order.equals(c.order())) {
                        throw new IllegalArgumentException(
                                "inconsistent byte order");
                    }
                } else {
                    order = c.order();
                }
                if (c instanceof CompositeChannelBuffer) {
                    // Expand nested composition.
                    components.addAll(
                            ((CompositeChannelBuffer) c).decompose(
                                    c.readerIndex(), c.readableBytes()));
                } else {
                    // An ordinary buffer (non-composite)
                    components.add(c.slice());
                }
            }
        }
        return compositeBuffer(order, components, gathering);
    }
    return EMPTY_BUFFER;
}
 

/**
 * Sets the byte order for reading the wrapeed buffer.
 * 
 * @param endianess
 *            byte order
 */
public void setOrder( final ByteOrder endianess ) {
    this.reader = endianess.equals(ByteOrder.LITTLE_ENDIAN) ? readerLittleEndian : readerBigEndian;
}