com.tangosol.io.ByteArrayReadBuffer Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of coherence Show documentation
Show all versions of coherence Show documentation
Oracle Coherence Community Edition
/*
* Copyright (c) 2000, 2020, Oracle and/or its affiliates.
*
* Licensed under the Universal Permissive License v 1.0 as shown at
* http://oss.oracle.com/licenses/upl.
*/
package com.tangosol.io;
/**
* A ReadBuffer on top of a byte array.
*
* @author cp 2005.01.20
*/
public class ByteArrayReadBuffer
extends AbstractByteArrayReadBuffer
{
// ----- constructors ---------------------------------------------------
/**
* Default constructor provided for subclasses.
*/
protected ByteArrayReadBuffer()
{
super();
}
/**
* Construct a ByteArrayReadBuffer object from a byte array.
* This constructor does not copy the byte array or make it private.
*
* @param ab an array of bytes
*/
public ByteArrayReadBuffer(byte[] ab)
{
this(ab, 0, ab.length);
}
/**
* Construct a ByteArrayReadBuffer object from a portion of a byte array.
* This constructor does not copy the byte array or make it private.
*
* @param ab an array of bytes
* @param of the offset into the byte array
* @param cb the number of bytes to extract
*/
public ByteArrayReadBuffer(byte[] ab, int of, int cb)
{
this(ab, of, cb, false, false, false);
}
/**
* Construct a ByteArrayReadBuffer object from a portion of a byte array.
*
* @param ab an array of bytes
* @param of the offset into the byte array
* @param cb the number of bytes to extract
* @param fCopy true to make a copy of the passed array
* @param fPrivate true to treat the passed array as private data
* @param fShallowClone true to allow cloning without copying the
* underlying byte[]
*/
public ByteArrayReadBuffer(byte[] ab, int of, int cb, boolean fCopy,
boolean fPrivate, boolean fShallowClone)
{
super(fCopy ? ab.clone() : ab, of, cb);
m_fPrivate = fPrivate;
m_fShallowClone = fShallowClone;
}
// ----- AbstractByteArrayReadBuffer methods ----------------------------
/**
* {@inheritDoc}
*/
public final void resetRange(int of, int cb)
{
super.resetRange(of, cb);
}
// ----- accessors ------------------------------------------------------
/**
* Obtain the byte array that this ReadBuffer uses. If the underlying byte
* array is private, then this method will always return a copy of the
* portion of the byte array that this ReadBuffer represents as if the
* called had called {@link #toByteArray()}.
*
* @return the byte array that this ReadBuffer uses
*/
public final byte[] getRawByteArray()
{
return isByteArrayPrivate() ? toByteArray() : m_ab;
}
/**
* Determine the offset into the byte array returned from
* {@link #getRawByteArray()} that this ReadBuffer uses. If the
* underlying byte array is private, then this method will always
* return zero because {@link #getRawByteArray()} will always return
* a copy of the portion of the byte array that this ReadBuffer
* represents.
*
* @return the offset into the raw byte array that this ReadBuffer uses
*/
public final int getRawOffset()
{
return isByteArrayPrivate() ? 0 : m_of;
}
// ----- factory methods ------------------------------------------------
/**
* Factory method: Instantiate a ReadBuffer for a portion of this
* ReadBuffer.
*
* @param of the beginning index, inclusive
* @param cb the number of bytes to include in the resulting ReadBuffer
*
* @return a ReadBuffer that represents a portion of this ReadBuffer
*/
protected final ReadBuffer instantiateReadBuffer(int of, int cb)
{
return new ByteArrayReadBuffer(m_ab, m_of + of, cb, false,
isByteArrayPrivate(), isShallowCloneable());
}
// ----- Object methods -------------------------------------------------
/**
* {@inheritDoc}
*/
public Object clone()
{
if (isShallowCloneable())
{
// no mutable state
return this;
}
// no shallow clone -- we MUST copy the byte array
byte[] ab = m_ab;
int of = m_of;
int cb = m_cb;
byte[] abNew;
if (of == 0 && cb == ab.length)
{
// just clone our byte array
abNew = ab.clone();
}
else
{
abNew = new byte[cb];
System.arraycopy(ab, of, abNew, 0, cb);
}
// if this buffer's data is private, then the clone's data will be
// private, and as a result, the clone will therefore be shallow
// cloneable
boolean fPrivate = isByteArrayPrivate();
return new ByteArrayReadBuffer(abNew, 0, cb, false, fPrivate, fPrivate);
}
/**
* Provide a human-readable representation of the Binary object.
*
* @return a String whose contents represent the value of this Binary
* object
*/
public String toString()
{
// "ByteArrayReadBuffer(length=4, value=0x01F03DA7)"
return "ByteArrayReadBuffer(length="
+ m_cb
+ ", value"
+ (m_cb > 2 * 1024
? " (truncated by " + (m_cb - 2 * 1024) + " bytes)="
: "=")
+ toHexEscape(m_ab, m_of, Math.min(2 * 1024, m_cb)) + ')';
}
// ----- internal -------------------------------------------------------
/**
* {@inheritDoc}
*/
protected final boolean isByteArrayPrivate()
{
return m_fPrivate;
}
/**
* Determine whether a clone can be made without cloning the byte array.
*
* @return true iff the underlying data can be shared by multiple
* instances of the ByteArrayReadBuffer class
*/
protected final boolean isShallowCloneable()
{
return m_fShallowClone;
}
/**
* Allow the length to be modified. This method is provided for use by
* ByteArrayWriteBuffer only, and only for read buffers that it owns.
*
* @param cb the new length for the ByteArrayReadBuffer
*/
void updateLength(int cb)
{
m_cb = cb;
}
// ----- data members ---------------------------------------------------
/**
* Specifies whether or not the byte array is treated as private data.
*/
private transient boolean m_fPrivate;
/**
* Specifies whether a clone can be made without cloning the byte array.
*/
private transient boolean m_fShallowClone;
}