/*
capacity是不会改变的。
limit是最后一个元素位置。
position是第一个元素位置。
mark是标识，reset()方法调用。
0<=mark<=position<=limit<=capacity
不可变buffer是内容不可变，但是mark、position、limit、capacity是可以变化的。
不是线程安全的，要想安全就要加同步。
链式调用： b.flip(); b.position(23); b.limit(42);
b.flip().position(23).limit(42);
*/
public abstract class Buffer1 {
//遍历或者切割元素的特征值
static final int SPLITERATOR_CHARACTERISTICS = Spliterator.SIZED | Spliterator.SUBSIZED | Spliterator.ORDERED;
private int mark = -1;
private int position = 0;//下一个要放的位置
private int limit;
private int capacity;
long address;//直接地址，GetDirectBufferAddress
public Buffer1(int mark, int pos, int lim, int cap) {//包私有
if (cap < 0)
throw new IllegalArgumentException("Negative capacity: " + cap);
this.capacity = cap;
limit(lim);//limit大于capacity抛异常，limit小于0抛异常，limit小于position：position等于limit，makr大于limit：markt等于-1。
position(pos);//position大于limit抛异常，positon小于0抛异常，mark大于position:mark等于-1。
if (mark >= 0) {
if (mark > pos)
throw new IllegalArgumentException("mark > position: (" + mark + " > " + pos + ")");
this.mark = mark;
}
}
public final int capacity() {
return capacity;
}
public final int position() {
return position;
}
//position大于limit抛异常，positon小于0抛异常，mark大于position:mark等于-1。
public final Buffer1 position(int newPosition) {
if ((newPosition > limit) || (newPosition < 0))
throw new IllegalArgumentException();
position = newPosition;
if (mark > position) mark = -1;
return this;
}
public final int limit() {
return limit;
}
//limit大于capacity抛异常，limit小于0抛异常，limit小于position：position等于limit，makr大于limit：markt等于-1。
public final Buffer1 limit(int newLimit) {
if ((newLimit > capacity) || (newLimit < 0))
throw new IllegalArgumentException();
limit = newLimit;
if (position > limit) position = limit;
if (mark > limit) mark = -1;
return this;
}
//设置mark为position的值
public final Buffer1 mark() {
mark = position;
return this;
}
//position回指到mark
public final Buffer1 reset() {
int m = mark;
if (m < 0)
throw new InvalidMarkException();
position = m;
return this;
}
//不清除数组的元素
public final Buffer1 clear() {
position = 0;
limit = capacity;
mark = -1;
return this;
}
//读进来之后，写出去时候要反转
public final Buffer1 flip() {//position是下一个要放的位置，下一个要读的位置。limit是读进去的时候最后一个元素下一个位置。limit读出去时候是最后一个元素下一个位置。
limit = position;//读进去的时候，position是下一个要放的位置，limit是等于capacity的，limit是没有用的。
//反转时候，limit=position，是读出来时候，最后一个元素的后一个位置，也就是放进去时候最后一个元素的后一个位置。position是下一个要读的位置。
position = 0;
mark = -1;
return this;
}
public final Buffer1 rewind() {
position = 0;
mark = -1;
return this;
}
public final int remaining() {//剩余可以读出去的元素
return limit - position;//(limit+1) - (position+1)。不包括前面包括后面的元素个数。
}
public final boolean hasRemaining() {
return position < limit;
}
public abstract boolean isReadOnly();
public abstract boolean hasArray();
public abstract Object array();
public abstract int arrayOffset();
//是否直接内存
public abstract boolean isDirect();
public final int nextGetIndex() { //包私有方法
if (position >= limit)
throw new BufferUnderflowException();
return position++;
}
public final int nextGetIndex(int nb) {//包私有方法
if (limit - position < nb)
throw new BufferUnderflowException();
int p = position;
position += nb;
return p;
}
public final int nextPutIndex() {//包私有方法,position++
if (position >= limit)
throw new BufferOverflowException();
return position++;
}
public final int nextPutIndex(int nb) {//包私有方法
if (limit - position < nb)
throw new BufferOverflowException();
int p = position;
position += nb;
return p;
}
public final int checkIndex(int i) { // package-private
if ((i < 0) || (i >= limit))
throw new IndexOutOfBoundsException();
return i;
}
public final int checkIndex(int i, int nb) { // package-private
if ((i < 0) || (nb > limit - i))
throw new IndexOutOfBoundsException();
return i;
}
public final int markValue() { // package-private
return mark;
}
public final void truncate() { // package-private
mark = -1;
position = 0;
limit = 0;
capacity = 0;
}
public final void discardMark() { // package-private
mark = -1;
}
public static void checkBounds(int off, int len, int size) { // package-private
if ((off | len | (off + len) | (size - (off + len))) < 0)
throw new IndexOutOfBoundsException();
}
}
//get，put，分为直接和非直接内存，wrap()是非直接的，view()方法是直接的，
public abstract class LongBuffer1 extends Buffer1 implements Comparable<LongBuffer1>{
final long[] hb; // 堆内存才有值，是一个数组，
final int offset;
boolean isReadOnly;
LongBuffer1(int mark, int pos, int lim, int cap,long[] hb, int offset){
super(mark, pos, lim, cap);
this.hb = hb;
this.offset = offset;
}
LongBuffer1(int mark, int pos, int lim, int cap) { // package-private
this(mark, pos, lim, cap, null, 0);
}
public static LongBuffer1 allocate(int capacity) {
if (capacity < 0)
throw new IllegalArgumentException();
//limit=capacity，new long[cap]，mark=-1，position=0,offset=0,
return new HeapLongBuffer1(capacity, capacity);
}
//将Long数组包装到LongBuffer。 Long数组的改变会引起buffer的改变，反之亦然。
public static LongBuffer1 wrap(long[] array,int offset, int length){
try {
//mark=-1，position=offset,limit=offset+length,capacity=array.length,hb=array,offset=0,
return new HeapLongBuffer1(array, offset, length);
} catch (IllegalArgumentException x) {
throw new IndexOutOfBoundsException();
}
}
public static LongBuffer1 wrap(long[] array) {
return wrap(array, 0, array.length);
}
//切割，原数组是直接内存切割后就是直接内存，原数组只读切割后就只读。
public abstract LongBuffer1 slice();
//复制，原数组是直接内存切割后就是直接内存，原数组只读切割后就只读。
public abstract LongBuffer1 duplicate();
public abstract LongBuffer1 asReadOnlyBuffer();
public abstract long get();
public abstract LongBuffer1 put(long l);
public abstract long get(int index);
public abstract LongBuffer1 put(int index, long l);
public LongBuffer1 get(long[] dst, int offset, int length) {
checkBounds(offset, length, dst.length);
if (length > remaining())
throw new BufferUnderflowException();
int end = offset + length;//offset是下标，end就是下标。
for (int i = offset; i < end; i++)
dst[i] = get();//拷贝到dst
return this;
}
public LongBuffer1 get(long[] dst) {
return get(dst, 0, dst.length);
}
public LongBuffer1 put(LongBuffer1 src) {
if (src == this)
throw new IllegalArgumentException();
if (isReadOnly())
throw new ReadOnlyBufferException();
int n = src.remaining();//不包括position包括limit的元素个数,也是包括position不包括limit的元素的个数。
if (n > remaining())
throw new BufferOverflowException();
for (int i = 0; i < n; i++)
put(src.get());//把src剩余的元素放进this中
return this;
}
public LongBuffer1 put(long[] src, int offset, int length) {
checkBounds(offset, length, src.length);
if (length > remaining())
throw new BufferOverflowException();
int end = offset + length;
for (int i = offset; i < end; i++)
this.put(src[i]);
return this;
}
public final LongBuffer1 put(long[] src) {
return put(src, 0, src.length);
}
public final boolean hasArray() {
return (hb != null) && !isReadOnly;
}
public final long[] array() {
if (hb == null)
throw new UnsupportedOperationException();
if (isReadOnly)
throw new ReadOnlyBufferException();
return hb;
}
public final int arrayOffset() {
if (hb == null)
throw new UnsupportedOperationException();
if (isReadOnly)
throw new ReadOnlyBufferException();
return offset;
}
public abstract LongBuffer1 compact();
public abstract boolean isDirect();
public String toString() {
StringBuffer sb = new StringBuffer();
sb.append(getClass().getName());
sb.append("[pos=");
sb.append(position());
sb.append(" lim=");
sb.append(limit());
sb.append(" cap=");
sb.append(capacity());
sb.append("]");
return sb.toString();
}
public int hashCode() {
int h = 1;
int p = position();
for (int i = limit() - 1; i >= p; i--)
h = 31 * h + (int)get(i);
return h;
}
public boolean equals(Object ob) {
if (this == ob)
return true;
if (!(ob instanceof LongBuffer1))//快速失败
return false;
LongBuffer1 that = (LongBuffer1)ob;
if (this.remaining() != that.remaining())//快速失败
return false;
int p = this.position();
for (int i = this.limit() - 1, j = that.limit() - 1; i >= p; i--, j--)//从各自的limit开始
if (!equals(this.get(i), that.get(j)))
return false;
return true;
}
private static boolean equals(long x, long y) {
return x == y;
}
public int compareTo(LongBuffer1 that) {
int n = this.position() + Math.min(this.remaining(), that.remaining());
//position到n的位置this都是可以取到的，that从that.position到n不一定取的到。
for (int i = this.position(), j = that.position(); i < n; i++, j++) {
int cmp = compare(this.get(i), that.get(j));
if (cmp != 0)
return cmp;
}
return this.remaining() - that.remaining();
}
private static int compare(long x, long y) {
return Long.compare(x, y);
}
// 字节顺序。
public abstract ByteOrder order();
}
class HeapLongBuffer1 extends LongBuffer1{
HeapLongBuffer1(int cap, int lim) {
super(-1, 0, lim, cap, new long[cap], 0);
}
HeapLongBuffer1(long[] buf, int off, int len) {
super(-1, off, off + len, buf.length, buf, 0);//mark, pos, lim, cap, hb, off
}
protected HeapLongBuffer1(long[] buf,int mark, int pos, int lim, int cap,int off){
super(mark, pos, lim, cap, buf, off);
}
public LongBuffer1 slice() { //mark, pos, lim, cap, off，截断之后只保留position到limit之间的元素，包括position不包括limit,切割之后元素的个数位remaining=limit-position。
//切割之后是一个新的数组，开始元素必须从0开始，结束位置是remaining=limit-position。还是用的hb，相对于原来数组的偏移是offset=position，
//新数组元素值还是原来从position到limit的元素。
return new HeapLongBuffer1(hb,-1,0,this.remaining(),this.remaining(),this.position() + offset);
}
public LongBuffer1 duplicate() { //mark, pos, lim, cap, off
return new HeapLongBuffer1(hb,this.markValue(),this.position(),this.limit(),this.capacity(),offset);
}
public LongBuffer1 asReadOnlyBuffer() { //mark, pos, lim, cap, off
return new HeapLongBufferR1(hb,this.markValue(),this.position(),this.limit(),this.capacity(),offset);
}
protected int ix(int i) {
return i + offset;
}
//get和put都是position++,然后取或者放元素，
public long get() {
return hb[ix(nextGetIndex())];
}
public LongBuffer1 put(long x) {//position加一，放在pposition位置。
hb[ix(nextPutIndex())] = x;//nextPutIndex():position++， ix():position + offset
return this;
}
public LongBuffer1 put(int i, long x) {
hb[ix(checkIndex(i))] = x;
return this;
}
public long get(int i) {
return hb[ix(checkIndex(i))];
}
public LongBuffer1 get(long[] dst, int offset, int length) {
checkBounds(offset, length, dst.length);
if (length > remaining())
throw new BufferUnderflowException();
System.arraycopy(hb, ix(position()), dst, offset, length);//把hb复制到dest，position是下一个读取地方，
position(position() + length);//position加length，position继续指向下一个读取位置，
return this;
}
public boolean isDirect() {
return false;
}
public boolean isReadOnly() {
return false;
}
public LongBuffer1 put(long[] src, int offset, int length) {
checkBounds(offset, length, src.length);
if (length > remaining())
throw new BufferOverflowException();
System.arraycopy(src, offset, hb, ix(position()), length);//把src复制到hb，position是下一个放置地方，
position(position() + length);//position继续指向下一个放置位置，
return this;
}
public LongBuffer1 put(LongBuffer1 src) {
if (src instanceof HeapLongBuffer1) {
if (src == this)
throw new IllegalArgumentException();
HeapLongBuffer1 sb = (HeapLongBuffer1)src;
int n = sb.remaining();
if (n > remaining())
throw new BufferOverflowException();
System.arraycopy(sb.hb, sb.ix(sb.position()),hb, ix(position()), n);
sb.position(sb.position() + n);//position继续指向下一个放置位置，
position(position() + n);//position继续指向下一个放置位置，
} else if (src.isDirect()) {
int n = src.remaining();
if (n > remaining())
throw new BufferOverflowException();
src.get(hb, ix(position()), n);
position(position() + n);//position继续指向下一个放置位置，
} else {
super.put(src);
}
return this;
}
public LongBuffer1 compact() {
System.arraycopy(hb, ix(position()), hb, ix(0), remaining());
position(remaining());
limit(capacity());
discardMark();
return this;
}
public ByteOrder order() {
return ByteOrder.nativeOrder();
}
class HeapLongBufferR1 extends HeapLongBuffer1{//只读的longbuffer
HeapLongBufferR1(int cap, int lim) { // package-private
super(cap, lim);
this.isReadOnly = true;
}
HeapLongBufferR1(long[] buf, int off, int len) { // package-private
super(buf, off, len);
this.isReadOnly = true;
}
protected HeapLongBufferR1(long[] buf,int mark, int pos, int lim, int cap,int off){
super(buf, mark, pos, lim, cap, off);
this.isReadOnly = true;
}
public LongBuffer1 slice() {
return new HeapLongBufferR1(hb,-1,0,this.remaining(),this.remaining(),this.position() + offset);
}
public LongBuffer1 duplicate() {
return new HeapLongBufferR1(hb,this.markValue(),this.position(),this.limit(),this.capacity(),offset);
}
public LongBuffer1 asReadOnlyBuffer() {
return duplicate();
}
public boolean isReadOnly() {
return true;
}
public LongBuffer1 put(long x) {
throw new ReadOnlyBufferException();
}
public LongBuffer1 put(int i, long x) {
throw new ReadOnlyBufferException();
}
public LongBuffer1 put(long[] src, int offset, int length) {
throw new ReadOnlyBufferException();
}
public LongBuffer1 put(LongBuffer1 src) {
throw new ReadOnlyBufferException();
}
public LongBuffer1 compact() {
throw new ReadOnlyBufferException();
}
public ByteOrder order() {
return ByteOrder.nativeOrder();
}
}
