andreacavalli/netty-incubator-buffer-api
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Remove LE/BE accessor method variants from the Buf interface

Browse Source 
Motivation:
Having method variants for explicit endians made the API too wide.

Modification:
Remove all LE/BE accessor method variants from the Buf API and implementation.

Result:
The Buf API is now simpler.
This commit is contained in:
Chris Vest 2020-10-12 16:26:22 +02:00
parent 0aed8daad4
commit b5ac0fdbe6
4 changed files with 24 additions and 4904 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

980
buffer/src/main/java/io/netty/buffer/b2/Buf.java
View File

File diff suppressed because it is too large Load Diff

580
buffer/src/main/java/io/netty/buffer/b2/MemSegBuf.java
View File

@ -218,34 +218,6 @@ class MemSegBuf extends RcSupport<Buf, MemSegBuf> implements Buf {
return (isBigEndian? getCharAtOffset_BE(seg, roff) : getCharAtOffset_LE(seg, roff));
}
@Override
public char readCharLE() {
checkRead(roff, 2);
char value = getCharAtOffset_LE(seg, roff);
roff += 2;
return value;
}
@Override
public char readCharLE(int roff) {
checkRead(roff, 2);
return getCharAtOffset_LE(seg, roff);
}
@Override
public char readCharBE() {
checkRead(roff, 2);
char value = getCharAtOffset_BE(seg, roff);
roff += 2;
return value;
}
@Override
public char readCharBE(int roff) {
checkRead(roff, 2);
return getCharAtOffset_BE(seg, roff);
}
@Override
public Buf writeChar(char value) {
if (isBigEndian) {
@ -267,32 +239,6 @@ class MemSegBuf extends RcSupport<Buf, MemSegBuf> implements Buf {
return this;
}
@Override
public Buf writeCharLE(char value) {
setCharAtOffset_LE(seg, woff, value);
woff += 2;
return this;
}
@Override
public Buf writeCharLE(int woff, char value) {
setCharAtOffset_LE(seg, woff, value);
return this;
}
@Override
public Buf writeCharBE(char value) {
setCharAtOffset_BE(seg, woff, value);
woff += 2;
return this;
}
@Override
public Buf writeCharBE(int woff, char value) {
setCharAtOffset_BE(seg, woff, value);
return this;
}
@Override
public short readShort() {
checkRead(roff, Short.BYTES);
@ -307,34 +253,6 @@ class MemSegBuf extends RcSupport<Buf, MemSegBuf> implements Buf {
return (isBigEndian? getShortAtOffset_BE(seg, roff) : getShortAtOffset_LE(seg, roff));
}
@Override
public short readShortLE() {
checkRead(roff, Short.BYTES);
short value = getShortAtOffset_LE(seg, roff);
roff += Short.BYTES;
return value;
}
@Override
public short readShortLE(int roff) {
checkRead(roff, Short.BYTES);
return getShortAtOffset_LE(seg, roff);
}
@Override
public short readShortBE() {
checkRead(roff, Short.BYTES);
short value = getShortAtOffset_BE(seg, roff);
roff += Short.BYTES;
return value;
}
@Override
public short readShortBE(int roff) {
checkRead(roff, Short.BYTES);
return getShortAtOffset_BE(seg, roff);
}
@Override
public int readUnsignedShort() {
checkRead(roff, Short.BYTES);
@ -349,34 +267,6 @@ class MemSegBuf extends RcSupport<Buf, MemSegBuf> implements Buf {
return (isBigEndian? getShortAtOffset_BE(seg, roff) : getShortAtOffset_LE(seg, roff)) & 0xFFFF;
}
@Override
public int readUnsignedShortLE() {
checkRead(roff, Short.BYTES);
int value = getShortAtOffset_LE(seg, roff) & 0xFFFF;
roff += Short.BYTES;
return value;
}
@Override
public int readUnsignedShortLE(int roff) {
checkRead(roff, Short.BYTES);
return getShortAtOffset_LE(seg, roff) & 0xFFFF;
}
@Override
public int readUnsignedShortBE() {
checkRead(roff, Short.BYTES);
int value = getShortAtOffset_BE(seg, roff) & 0xFFFF;
roff += Short.BYTES;
return value;
}
@Override
public int readUnsignedShortBE(int roff) {
checkRead(roff, Short.BYTES);
return getShortAtOffset_BE(seg, roff) & 0xFFFF;
}
@Override
public Buf writeShort(short value) {
if (isBigEndian) {
@ -398,32 +288,6 @@ class MemSegBuf extends RcSupport<Buf, MemSegBuf> implements Buf {
return this;
}
@Override
public Buf writeShortLE(short value) {
setShortAtOffset_LE(seg, woff, value);
woff += Short.BYTES;
return this;
}
@Override
public Buf writeShortLE(int woff, short value) {
setShortAtOffset_LE(seg, woff, value);
return this;
}
@Override
public Buf writeShortBE(short value) {
setShortAtOffset_BE(seg, woff, value);
woff += Short.BYTES;
return this;
}
@Override
public Buf writeShortBE(int woff, short value) {
setShortAtOffset_BE(seg, woff, value);
return this;
}
@Override
public Buf writeUnsignedShort(int value) {
if (isBigEndian) {
@ -445,32 +309,6 @@ class MemSegBuf extends RcSupport<Buf, MemSegBuf> implements Buf {
return this;
}
@Override
public Buf writeUnsignedShortLE(int value) {
setShortAtOffset_LE(seg, woff, (short) (value & 0xFFFF));
woff += Short.BYTES;
return this;
}
@Override
public Buf writeUnsignedShortLE(int woff, int value) {
setShortAtOffset_LE(seg, woff, (short) (value & 0xFFFF));
return this;
}
@Override
public Buf writeUnsignedShortBE(int value) {
setShortAtOffset_BE(seg, woff, (short) (value & 0xFFFF));
woff += Short.BYTES;
return this;
}
@Override
public Buf writeUnsignedShortBE(int woff, int value) {
setShortAtOffset_BE(seg, woff, (short) (value & 0xFFFF));
return this;
}
@Override
public int readMedium() {
checkRead(roff, 3);
@ -497,42 +335,6 @@ getByteAtOffset_BE(seg, roff) & 0xFF |
getByteAtOffset_BE(seg, roff + 2) << 16;
}
@Override
public int readMediumLE() {
checkRead(roff, 3);
int value = getByteAtOffset_BE(seg, roff) & 0xFF |
(getByteAtOffset_BE(seg, roff + 1) & 0xFF) << 8 |
getByteAtOffset_BE(seg, roff + 2) << 16;
roff += 3;
return value;
}
@Override
public int readMediumLE(int roff) {
checkRead(roff, 3);
return getByteAtOffset_BE(seg, roff) & 0xFF |
(getByteAtOffset_BE(seg, roff + 1) & 0xFF) << 8 |
getByteAtOffset_BE(seg, roff + 2) << 16;
}
@Override
public int readMediumBE() {
checkRead(roff, 3);
int value = getByteAtOffset_BE(seg, roff) << 16 |
(getByteAtOffset_BE(seg, roff + 1) & 0xFF) << 8 |
getByteAtOffset_BE(seg, roff + 2) & 0xFF;
roff += 3;
return value;
}
@Override
public int readMediumBE(int roff) {
checkRead(roff, 3);
return getByteAtOffset_BE(seg, roff) << 16 |
(getByteAtOffset_BE(seg, roff + 1) & 0xFF) << 8 |
getByteAtOffset_BE(seg, roff + 2) & 0xFF;
}
@Override
public int readUnsignedMedium() {
checkRead(roff, 3);
@ -559,42 +361,6 @@ getByteAtOffset_BE(seg, roff) & 0xFF |
getByteAtOffset_BE(seg, roff + 2) << 16) & 0xFFFFFF;
}
@Override
public int readUnsignedMediumLE() {
checkRead(roff, 3);
int value = (getByteAtOffset_BE(seg, roff) & 0xFF |
(getByteAtOffset_BE(seg, roff + 1) & 0xFF) << 8 |
getByteAtOffset_BE(seg, roff + 2) << 16) & 0xFFFFFF;
roff += 3;
return value;
}
@Override
public int readUnsignedMediumLE(int roff) {
checkRead(roff, 3);
return (getByteAtOffset_BE(seg, roff) & 0xFF |
(getByteAtOffset_BE(seg, roff + 1) & 0xFF) << 8 |
getByteAtOffset_BE(seg, roff + 2) << 16) & 0xFFFFFF;
}
@Override
public int readUnsignedMediumBE() {
checkRead(roff, 3);
int value = (getByteAtOffset_BE(seg, roff) << 16 |
(getByteAtOffset_BE(seg, roff + 1) & 0xFF) << 8 |
getByteAtOffset_BE(seg, roff + 2) & 0xFF) & 0xFFFFFF;
roff += 3;
return value;
}
@Override
public int readUnsignedMediumBE(int roff) {
checkRead(roff, 3);
return (getByteAtOffset_BE(seg, roff) << 16 |
(getByteAtOffset_BE(seg, roff + 1) & 0xFF) << 8 |
getByteAtOffset_BE(seg, roff + 2) & 0xFF) & 0xFFFFFF;
}
@Override
public Buf writeMedium(int value) {
checkWrite(woff, 3);
@ -626,44 +392,6 @@ getByteAtOffset_BE(seg, roff) & 0xFF |
return this;
}
@Override
public Buf writeMediumLE(int value) {
checkWrite(woff, 3);
setByteAtOffset_BE(seg, woff, (byte) (value & 0xFF));
setByteAtOffset_BE(seg, woff + 1, (byte) (value >> 8 & 0xFF));
setByteAtOffset_BE(seg, woff + 2, (byte) (value >> 16 & 0xFF));
woff += 3;
return this;
}
@Override
public Buf writeMediumLE(int woff, int value) {
checkWrite(woff, 3);
setByteAtOffset_BE(seg, woff, (byte) (value & 0xFF));
setByteAtOffset_BE(seg, woff + 1, (byte) (value >> 8 & 0xFF));
setByteAtOffset_BE(seg, woff + 2, (byte) (value >> 16 & 0xFF));
return this;
}
@Override
public Buf writeMediumBE(int value) {
checkWrite(woff, 3);
setByteAtOffset_BE(seg, woff, (byte) (value >> 16));
setByteAtOffset_BE(seg, woff + 1, (byte) (value >> 8 & 0xFF));
setByteAtOffset_BE(seg, woff + 2, (byte) (value & 0xFF));
woff += 3;
return this;
}
@Override
public Buf writeMediumBE(int woff, int value) {
checkWrite(woff, 3);
setByteAtOffset_BE(seg, woff, (byte) (value >> 16));
setByteAtOffset_BE(seg, woff + 1, (byte) (value >> 8 & 0xFF));
setByteAtOffset_BE(seg, woff + 2, (byte) (value & 0xFF));
return this;
}
@Override
public Buf writeUnsignedMedium(int value) {
checkWrite(woff, 3);
@ -695,44 +423,6 @@ getByteAtOffset_BE(seg, roff) & 0xFF |
return this;
}
@Override
public Buf writeUnsignedMediumLE(int value) {
checkWrite(woff, 3);
setByteAtOffset_BE(seg, woff, (byte) (value & 0xFF));
setByteAtOffset_BE(seg, woff + 1, (byte) (value >> 8 & 0xFF));
setByteAtOffset_BE(seg, woff + 2, (byte) (value >> 16 & 0xFF));
woff += 3;
return this;
}
@Override
public Buf writeUnsignedMediumLE(int woff, int value) {
checkWrite(woff, 3);
setByteAtOffset_BE(seg, woff, (byte) (value & 0xFF));
setByteAtOffset_BE(seg, woff + 1, (byte) (value >> 8 & 0xFF));
setByteAtOffset_BE(seg, woff + 2, (byte) (value >> 16 & 0xFF));
return this;
}
@Override
public Buf writeUnsignedMediumBE(int value) {
checkWrite(woff, 3);
setByteAtOffset_BE(seg, woff, (byte) (value >> 16));
setByteAtOffset_BE(seg, woff + 1, (byte) (value >> 8 & 0xFF));
setByteAtOffset_BE(seg, woff + 2, (byte) (value & 0xFF));
woff += 3;
return this;
}
@Override
public Buf writeUnsignedMediumBE(int woff, int value) {
checkWrite(woff, 3);
setByteAtOffset_BE(seg, woff, (byte) (value >> 16));
setByteAtOffset_BE(seg, woff + 1, (byte) (value >> 8 & 0xFF));
setByteAtOffset_BE(seg, woff + 2, (byte) (value & 0xFF));
return this;
}
@Override
public int readInt() {
checkRead(roff, Integer.BYTES);
@ -747,34 +437,6 @@ getByteAtOffset_BE(seg, roff) & 0xFF |
return (isBigEndian? getIntAtOffset_BE(seg, roff) : getIntAtOffset_LE(seg, roff));
}
@Override
public int readIntLE() {
checkRead(roff, Integer.BYTES);
int value = getIntAtOffset_LE(seg, roff);
roff += Integer.BYTES;
return value;
}
@Override
public int readIntLE(int roff) {
checkRead(roff, Integer.BYTES);
return getIntAtOffset_LE(seg, roff);
}
@Override
public int readIntBE() {
checkRead(roff, Integer.BYTES);
int value = getIntAtOffset_BE(seg, roff);
roff += Integer.BYTES;
return value;
}
@Override
public int readIntBE(int roff) {
checkRead(roff, Integer.BYTES);
return getIntAtOffset_BE(seg, roff);
}
@Override
public long readUnsignedInt() {
checkRead(roff, Integer.BYTES);
@ -789,34 +451,6 @@ getByteAtOffset_BE(seg, roff) & 0xFF |
return (isBigEndian? getIntAtOffset_BE(seg, roff) : getIntAtOffset_LE(seg, roff)) & 0xFFFFFFFFL;
}
@Override
public long readUnsignedIntLE() {
checkRead(roff, Integer.BYTES);
long value = getIntAtOffset_LE(seg, roff) & 0xFFFFFFFFL;
roff += Integer.BYTES;
return value;
}
@Override
public long readUnsignedIntLE(int roff) {
checkRead(roff, Integer.BYTES);
return getIntAtOffset_LE(seg, roff) & 0xFFFFFFFFL;
}
@Override
public long readUnsignedIntBE() {
checkRead(roff, Integer.BYTES);
long value = getIntAtOffset_BE(seg, roff) & 0xFFFFFFFFL;
roff += Integer.BYTES;
return value;
}
@Override
public long readUnsignedIntBE(int roff) {
checkRead(roff, Integer.BYTES);
return getIntAtOffset_BE(seg, roff) & 0xFFFFFFFFL;
}
@Override
public Buf writeInt(int value) {
if (isBigEndian) {
@ -838,32 +472,6 @@ getByteAtOffset_BE(seg, roff) & 0xFF |
return this;
}
@Override
public Buf writeIntLE(int value) {
setIntAtOffset_LE(seg, woff, value);
woff += Integer.BYTES;
return this;
}
@Override
public Buf writeIntLE(int woff, int value) {
setIntAtOffset_LE(seg, woff, value);
return this;
}
@Override
public Buf writeIntBE(int value) {
setIntAtOffset_BE(seg, woff, value);
woff += Integer.BYTES;
return this;
}
@Override
public Buf writeIntBE(int woff, int value) {
setIntAtOffset_BE(seg, woff, value);
return this;
}
@Override
public Buf writeUnsignedInt(long value) {
if (isBigEndian) {
@ -885,32 +493,6 @@ getByteAtOffset_BE(seg, roff) & 0xFF |
return this;
}
@Override
public Buf writeUnsignedIntLE(long value) {
setIntAtOffset_LE(seg, woff, (int) (value & 0xFFFFFFFFL));
woff += Integer.BYTES;
return this;
}
@Override
public Buf writeUnsignedIntLE(int woff, long value) {
setIntAtOffset_LE(seg, woff, (int) (value & 0xFFFFFFFFL));
return this;
}
@Override
public Buf writeUnsignedIntBE(long value) {
setIntAtOffset_BE(seg, woff, (int) (value & 0xFFFFFFFFL));
woff += Integer.BYTES;
return this;
}
@Override
public Buf writeUnsignedIntBE(int woff, long value) {
setIntAtOffset_BE(seg, woff, (int) (value & 0xFFFFFFFFL));
return this;
}
@Override
public float readFloat() {
checkRead(roff, Float.BYTES);
@ -925,34 +507,6 @@ getByteAtOffset_BE(seg, roff) & 0xFF |
return (isBigEndian? getFloatAtOffset_BE(seg, roff) : getFloatAtOffset_LE(seg, roff));
}
@Override
public float readFloatLE() {
checkRead(roff, Float.BYTES);
float value = getFloatAtOffset_LE(seg, roff);
roff += Float.BYTES;
return value;
}
@Override
public float readFloatLE(int roff) {
checkRead(roff, Float.BYTES);
return getFloatAtOffset_LE(seg, roff);
}
@Override
public float readFloatBE() {
checkRead(roff, Float.BYTES);
float value = getFloatAtOffset_BE(seg, roff);
roff += Float.BYTES;
return value;
}
@Override
public float readFloatBE(int roff) {
checkRead(roff, Float.BYTES);
return getFloatAtOffset_BE(seg, roff);
}
@Override
public Buf writeFloat(float value) {
if (isBigEndian) {
@ -974,32 +528,6 @@ getByteAtOffset_BE(seg, roff) & 0xFF |
return this;
}
@Override
public Buf writeFloatLE(float value) {
setFloatAtOffset_LE(seg, woff, value);
woff += Float.BYTES;
return this;
}
@Override
public Buf writeFloatLE(int woff, float value) {
setFloatAtOffset_LE(seg, woff, value);
return this;
}
@Override
public Buf writeFloatBE(float value) {
setFloatAtOffset_BE(seg, woff, value);
woff += Float.BYTES;
return this;
}
@Override
public Buf writeFloatBE(int woff, float value) {
setFloatAtOffset_BE(seg, woff, value);
return this;
}
@Override
public long readLong() {
checkRead(roff, Long.BYTES);
@ -1014,34 +542,6 @@ getByteAtOffset_BE(seg, roff) & 0xFF |
return (isBigEndian? getLongAtOffset_BE(seg, roff) : getLongAtOffset_LE(seg, roff));
}
@Override
public long readLongLE() {
checkRead(roff, Long.BYTES);
long value = getLongAtOffset_LE(seg, roff);
roff += Long.BYTES;
return value;
}
@Override
public long readLongLE(int roff) {
checkRead(roff, Long.BYTES);
return getLongAtOffset_LE(seg, roff);
}
@Override
public long readLongBE() {
checkRead(roff, Long.BYTES);
long value = getLongAtOffset_BE(seg, roff);
roff += Long.BYTES;
return value;
}
@Override
public long readLongBE(int roff) {
checkRead(roff, Long.BYTES);
return getLongAtOffset_BE(seg, roff);
}
@Override
public Buf writeLong(long value) {
if (isBigEndian) {
@ -1063,32 +563,6 @@ getByteAtOffset_BE(seg, roff) & 0xFF |
return this;
}
@Override
public Buf writeLongLE(long value) {
setLongAtOffset_LE(seg, woff, value);
woff += Long.BYTES;
return this;
}
@Override
public Buf writeLongLE(int woff, long value) {
setLongAtOffset_LE(seg, woff, value);
return this;
}
@Override
public Buf writeLongBE(long value) {
setLongAtOffset_BE(seg, woff, value);
woff += Long.BYTES;
return this;
}
@Override
public Buf writeLongBE(int woff, long value) {
setLongAtOffset_BE(seg, woff, value);
return this;
}
@Override
public double readDouble() {
checkRead(roff, Double.BYTES);
@ -1103,34 +577,6 @@ getByteAtOffset_BE(seg, roff) & 0xFF |
return (isBigEndian? getDoubleAtOffset_BE(seg, roff) : getDoubleAtOffset_LE(seg, roff));
}
@Override
public double readDoubleLE() {
checkRead(roff, Double.BYTES);
double value = getDoubleAtOffset_LE(seg, roff);
roff += Double.BYTES;
return value;
}
@Override
public double readDoubleLE(int roff) {
checkRead(roff, Double.BYTES);
return getDoubleAtOffset_LE(seg, roff);
}
@Override
public double readDoubleBE() {
checkRead(roff, Double.BYTES);
double value = getDoubleAtOffset_BE(seg, roff);
roff += Double.BYTES;
return value;
}
@Override
public double readDoubleBE(int roff) {
checkRead(roff, Double.BYTES);
return getDoubleAtOffset_BE(seg, roff);
}
@Override
public Buf writeDouble(double value) {
if (isBigEndian) {
@ -1151,32 +597,6 @@ getByteAtOffset_BE(seg, roff) & 0xFF |
}
return this;
}
@Override
public Buf writeDoubleLE(double value) {
setDoubleAtOffset_LE(seg, woff, value);
woff += Double.BYTES;
return this;
}
@Override
public Buf writeDoubleLE(int woff, double value) {
setDoubleAtOffset_LE(seg, woff, value);
return this;
}
@Override
public Buf writeDoubleBE(double value) {
setDoubleAtOffset_BE(seg, woff, value);
woff += Double.BYTES;
return this;
}
@Override
public Buf writeDoubleBE(int woff, double value) {
setDoubleAtOffset_BE(seg, woff, value);
return this;
}
// </editor-fold>
// ### CODEGEN END primitive accessors implementation

3320
buffer/src/test/java/io/netty/buffer/b2/BufTest.java
View File

File diff suppressed because it is too large Load Diff

48
buffer/src/test/java/io/netty/buffer/b2/Codegen.java
View File

@ -635,40 +635,40 @@ public final class Codegen {
builder.add(template.relativeRead(type, Order.DF, false, true));
builder.add(template.offsetRead(type, Order.DF, false, true));
if (type.includeLEBE) {
builder.add(template.relativeRead(type, Order.LE, false, true));
builder.add(template.offsetRead(type, Order.LE, false, true));
builder.add(template.relativeRead(type, Order.BE, false, true));
builder.add(template.offsetRead(type, Order.BE, false, true));
}
// if (type.includeLEBE) {
// builder.add(template.relativeRead(type, Order.LE, false, true));
// builder.add(template.offsetRead(type, Order.LE, false, true));
// builder.add(template.relativeRead(type, Order.BE, false, true));
// builder.add(template.offsetRead(type, Order.BE, false, true));
// }
if (type.unsignedCarrier != null) {
builder.add(template.relativeRead(type, Order.DF, true, true));
builder.add(template.offsetRead(type, Order.DF, true, true));
if (type.includeLEBE) {
builder.add(template.relativeRead(type, Order.LE, true, true));
builder.add(template.offsetRead(type, Order.LE, true, true));
builder.add(template.relativeRead(type, Order.BE, true, true));
builder.add(template.offsetRead(type, Order.BE, true, true));
}
// if (type.includeLEBE) {
// builder.add(template.relativeRead(type, Order.LE, true, true));
// builder.add(template.offsetRead(type, Order.LE, true, true));
// builder.add(template.relativeRead(type, Order.BE, true, true));
// builder.add(template.offsetRead(type, Order.BE, true, true));
// }
}
builder.add(template.relativeWrite(type, Order.DF, false, false));
builder.add(template.offsetWrite(type, Order.DF, false, false));
if (type.includeLEBE) {
builder.add(template.relativeWrite(type, Order.LE, false, false));
builder.add(template.offsetWrite(type, Order.LE, false, false));
builder.add(template.relativeWrite(type, Order.BE, false, false));
builder.add(template.offsetWrite(type, Order.BE, false, false));
}
// if (type.includeLEBE) {
// builder.add(template.relativeWrite(type, Order.LE, false, false));
// builder.add(template.offsetWrite(type, Order.LE, false, false));
// builder.add(template.relativeWrite(type, Order.BE, false, false));
// builder.add(template.offsetWrite(type, Order.BE, false, false));
// }
if (type.unsignedCarrier != null) {
builder.add(template.relativeWrite(type, Order.DF, true, false));
builder.add(template.offsetWrite(type, Order.DF, true, false));
if (type.includeLEBE) {
builder.add(template.relativeWrite(type, Order.LE, true, false));
builder.add(template.offsetWrite(type, Order.LE, true, false));
builder.add(template.relativeWrite(type, Order.BE, true, false));
builder.add(template.offsetWrite(type, Order.BE, true, false));
}
// if (type.includeLEBE) {
// builder.add(template.relativeWrite(type, Order.LE, true, false));
// builder.add(template.offsetWrite(type, Order.LE, true, false));
// builder.add(template.relativeWrite(type, Order.BE, true, false));
// builder.add(template.offsetWrite(type, Order.BE, true, false));
// }
}
return builder.build();