From cd15a1a5862300eaf4e5e55a0c256f7ff2a38b68 Mon Sep 17 00:00:00 2001 From: redkale Date: Tue, 1 Oct 2024 19:55:40 +0800 Subject: [PATCH] protobuf --- .../org/redkale/convert/ConvertFactory.java | 31 + .../convert/ext/BigIntegerSimpledCoder.java | 15 +- .../convert/ext/InetAddressSimpledCoder.java | 16 +- .../ext/LocalDateTimeSimpledCoder.java | 16 +- .../convert/ext/Uint128SimpledCoder.java | 13 +- .../convert/pb/ProtobufArrayDecoder.java | 16 +- .../convert/pb/ProtobufArrayEncoder.java | 10 +- .../redkale/convert/pb/ProtobufCoders.java | 956 +++++++++++++----- .../convert/pb/ProtobufCollectionDecoder.java | 15 +- .../convert/pb/ProtobufCollectionEncoder.java | 11 +- .../convert/pb/ProtobufDynEncoder.java | 13 +- .../convert/pb/ProtobufEncodeable.java | 4 + .../convert/pb/ProtobufEnumSimpledCoder.java | 5 + .../redkale/convert/pb/ProtobufFactory.java | 259 ++--- .../convert/pb/ProtobufMapEncoder.java | 18 +- .../convert/pb/ProtobufObjectEncoder.java | 8 +- .../convert/pb/ProtobufPrimitivable.java | 10 +- .../redkale/convert/pb/ProtobufReader.java | 63 +- .../convert/pb/ProtobufStreamDecoder.java | 15 +- .../convert/pb/ProtobufStreamEncoder.java | 11 +- .../redkale/convert/pb/ProtobufTypeEnum.java | 56 + .../redkale/convert/pb/ProtobufWriter.java | 240 ++--- .../test/convert/pb/RequiredBeanTest.java | 22 +- .../org/redkale/test/convert/pb/UserBean.java | 18 +- .../convert/pb/UserBeanProtoDynEncoder.java | 4 - 25 files changed, 1123 insertions(+), 722 deletions(-) create mode 100644 src/main/java/org/redkale/convert/pb/ProtobufTypeEnum.java diff --git a/src/main/java/org/redkale/convert/ConvertFactory.java b/src/main/java/org/redkale/convert/ConvertFactory.java index f36ad97b8..922a70157 100644 --- a/src/main/java/org/redkale/convert/ConvertFactory.java +++ b/src/main/java/org/redkale/convert/ConvertFactory.java @@ -317,6 +317,37 @@ public abstract class ConvertFactory { return ptype.getActualTypeArguments()[0]; } + protected boolean isStreamType(final Type type) { + if (type == null) { + return false; + } + if (type instanceof Class) { + return Stream.class.isAssignableFrom((Class) type); + } + ParameterizedType ptype = (ParameterizedType) type; + if (!(ptype.getRawType() instanceof Class)) { + return false; + } + Type[] ptargs = ptype.getActualTypeArguments(); + if (ptargs == null || ptargs.length != 1) { + return false; + } + Class ownerType = (Class) ptype.getRawType(); + return Stream.class.isAssignableFrom(ownerType); + } + + // 返回null表示type不是Stream类型 + protected Type getStreamionComponentType(final Type type) { + if (!isStreamType(type)) { + return null; + } + if (type instanceof Class) { + return Object.class; + } + ParameterizedType ptype = ((ParameterizedType) type); + return ptype.getActualTypeArguments()[0]; + } + protected Encodeable createDyncEncoder(Type type) { return null; } diff --git a/src/main/java/org/redkale/convert/ext/BigIntegerSimpledCoder.java b/src/main/java/org/redkale/convert/ext/BigIntegerSimpledCoder.java index c25c3797c..d4eac9b26 100644 --- a/src/main/java/org/redkale/convert/ext/BigIntegerSimpledCoder.java +++ b/src/main/java/org/redkale/convert/ext/BigIntegerSimpledCoder.java @@ -6,6 +6,7 @@ package org.redkale.convert.ext; import java.math.BigInteger; +import java.util.Objects; import org.redkale.convert.*; import org.redkale.convert.json.*; @@ -22,6 +23,16 @@ public class BigIntegerSimpledCoder extends public static final BigIntegerSimpledCoder instance = new BigIntegerSimpledCoder(); + protected final SimpledCoder bsSimpledCoder; + + protected BigIntegerSimpledCoder() { + this.bsSimpledCoder = ByteArraySimpledCoder.instance; + } + + public BigIntegerSimpledCoder(SimpledCoder bSimpledCoder) { + this.bsSimpledCoder = Objects.requireNonNull(bSimpledCoder); + } + @Override @SuppressWarnings("unchecked") public void convertTo(W out, BigInteger value) { @@ -29,13 +40,13 @@ public class BigIntegerSimpledCoder extends out.writeNull(); return; } - ByteArraySimpledCoder.instance.convertTo(out, value.toByteArray()); + bsSimpledCoder.convertTo(out, value.toByteArray()); } @Override @SuppressWarnings("unchecked") public BigInteger convertFrom(R in) { - byte[] bytes = ByteArraySimpledCoder.instance.convertFrom(in); + byte[] bytes = bsSimpledCoder.convertFrom(in); return bytes == null ? null : new BigInteger(bytes); } diff --git a/src/main/java/org/redkale/convert/ext/InetAddressSimpledCoder.java b/src/main/java/org/redkale/convert/ext/InetAddressSimpledCoder.java index 89799f007..ac6cc7bd8 100644 --- a/src/main/java/org/redkale/convert/ext/InetAddressSimpledCoder.java +++ b/src/main/java/org/redkale/convert/ext/InetAddressSimpledCoder.java @@ -6,6 +6,7 @@ package org.redkale.convert.ext; import java.net.*; +import java.util.Objects; import org.redkale.convert.*; import org.redkale.convert.json.*; import org.redkale.util.StringWrapper; @@ -24,18 +25,29 @@ public class InetAddressSimpledCoder extends public static final InetAddressSimpledCoder instance = new InetAddressSimpledCoder(); + protected final SimpledCoder bsSimpledCoder; + + protected InetAddressSimpledCoder() { + this.bsSimpledCoder = ByteArraySimpledCoder.instance; + } + + public InetAddressSimpledCoder(SimpledCoder bSimpledCoder) { + this.bsSimpledCoder = Objects.requireNonNull(bSimpledCoder); + } + + @Override public void convertTo(W out, InetAddress value) { if (value == null) { out.writeNull(); return; } - ByteArraySimpledCoder.instance.convertTo(out, value.getAddress()); + bsSimpledCoder.convertTo(out, value.getAddress()); } @Override public InetAddress convertFrom(R in) { - byte[] bytes = ByteArraySimpledCoder.instance.convertFrom(in); + byte[] bytes = bsSimpledCoder.convertFrom(in); if (bytes == null) { return null; } diff --git a/src/main/java/org/redkale/convert/ext/LocalDateTimeSimpledCoder.java b/src/main/java/org/redkale/convert/ext/LocalDateTimeSimpledCoder.java index 35753f095..f2e5c52a3 100644 --- a/src/main/java/org/redkale/convert/ext/LocalDateTimeSimpledCoder.java +++ b/src/main/java/org/redkale/convert/ext/LocalDateTimeSimpledCoder.java @@ -6,6 +6,7 @@ package org.redkale.convert.ext; import java.time.*; +import java.util.Objects; import org.redkale.convert.*; import org.redkale.convert.json.*; @@ -18,13 +19,20 @@ import org.redkale.convert.json.*; * @param Reader输入的子类型 * @param Writer输出的子类型 */ -public class LocalDateTimeSimpledCoder - extends SimpledCoder { - - private static final ByteArraySimpledCoder bsSimpledCoder = ByteArraySimpledCoder.instance; +public class LocalDateTimeSimpledCoder extends SimpledCoder { public static final LocalDateTimeSimpledCoder instance = new LocalDateTimeSimpledCoder(); + protected final SimpledCoder bsSimpledCoder; + + protected LocalDateTimeSimpledCoder() { + this.bsSimpledCoder = ByteArraySimpledCoder.instance; + } + + public LocalDateTimeSimpledCoder(SimpledCoder bSimpledCoder) { + this.bsSimpledCoder = Objects.requireNonNull(bSimpledCoder); + } + @Override public void convertTo(W out, LocalDateTime value) { if (value == null) { diff --git a/src/main/java/org/redkale/convert/ext/Uint128SimpledCoder.java b/src/main/java/org/redkale/convert/ext/Uint128SimpledCoder.java index eeb95e9ff..df1e6c3cb 100644 --- a/src/main/java/org/redkale/convert/ext/Uint128SimpledCoder.java +++ b/src/main/java/org/redkale/convert/ext/Uint128SimpledCoder.java @@ -5,6 +5,7 @@ */ package org.redkale.convert.ext; +import java.util.Objects; import org.redkale.convert.*; import org.redkale.convert.json.*; import org.redkale.util.*; @@ -20,10 +21,18 @@ import org.redkale.util.*; */ public class Uint128SimpledCoder extends SimpledCoder { - private static final ByteArraySimpledCoder bsSimpledCoder = ByteArraySimpledCoder.instance; - public static final Uint128SimpledCoder instance = new Uint128SimpledCoder(); + protected final SimpledCoder bsSimpledCoder; + + protected Uint128SimpledCoder() { + this.bsSimpledCoder = ByteArraySimpledCoder.instance; + } + + public Uint128SimpledCoder(SimpledCoder bSimpledCoder) { + this.bsSimpledCoder = Objects.requireNonNull(bSimpledCoder); + } + @Override @SuppressWarnings("unchecked") public void convertTo(final W out, final Uint128 value) { diff --git a/src/main/java/org/redkale/convert/pb/ProtobufArrayDecoder.java b/src/main/java/org/redkale/convert/pb/ProtobufArrayDecoder.java index f2d41b66d..f84e9caeb 100644 --- a/src/main/java/org/redkale/convert/pb/ProtobufArrayDecoder.java +++ b/src/main/java/org/redkale/convert/pb/ProtobufArrayDecoder.java @@ -34,13 +34,21 @@ public class ProtobufArrayDecoder extends ArrayDecoder final List result = new ArrayList(); final int limit = in.limit(); while (in.hasNext()) { - ProtobufReader subin = in; + boolean nodata = false; if (!simpled) { int contentLen = in.readRawVarint32(); - in.limit(in.position() + contentLen + 1); + if (contentLen == 0) { + nodata = true; + } else { + in.limit(in.position() + contentLen + 1); + } + } + if (nodata) { + result.add(null); + } else { + result.add(itemDecoder.convertFrom(in)); + in.limit(limit); } - result.add(itemDecoder.convertFrom(subin)); - in.limit(limit); if (!in.readNextTag(member)) { // 元素结束 break; } diff --git a/src/main/java/org/redkale/convert/pb/ProtobufArrayEncoder.java b/src/main/java/org/redkale/convert/pb/ProtobufArrayEncoder.java index 472d620c5..990fdc8d3 100644 --- a/src/main/java/org/redkale/convert/pb/ProtobufArrayEncoder.java +++ b/src/main/java/org/redkale/convert/pb/ProtobufArrayEncoder.java @@ -42,11 +42,10 @@ public class ProtobufArrayEncoder extends ArrayEncoder for (T item : array) { out.writeField(member); if (item == null) { - out.writeUInt32(0); + out.writeLength(0); } else if (componentSimpled) { itemEncoder.convertTo(out, item); } else { - // itemEncoder.convertTo(out, item); ProtobufWriter tmp = out.pollChild(); itemEncoder.convertTo(tmp, item); out.writeTuple(tmp); @@ -74,6 +73,11 @@ public class ProtobufArrayEncoder extends ArrayEncoder @Override public boolean requireSize() { - return componentSizeRequired; + return !componentSimpled; + } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; } } diff --git a/src/main/java/org/redkale/convert/pb/ProtobufCoders.java b/src/main/java/org/redkale/convert/pb/ProtobufCoders.java index ceb08787e..68c1a8eac 100644 --- a/src/main/java/org/redkale/convert/pb/ProtobufCoders.java +++ b/src/main/java/org/redkale/convert/pb/ProtobufCoders.java @@ -11,6 +11,7 @@ import java.net.InetAddress; import java.net.InetSocketAddress; import java.util.*; import java.util.concurrent.atomic.*; +import java.util.function.IntFunction; import java.util.stream.Stream; import org.redkale.convert.SimpledCoder; import org.redkale.convert.ext.AtomicBooleanSimpledCoder; @@ -57,12 +58,17 @@ public abstract class ProtobufCoders { // ------------------------------------- boolean ------------------------------------- public static class ProtobufBoolSimpledCoder extends BoolSimpledCoder - implements ProtobufPrimitivable, ProtobufEncodeable { + implements ProtobufPrimitivable, ProtobufEncodeable { public static final ProtobufBoolSimpledCoder instance = new ProtobufBoolSimpledCoder(); @Override public int computeSize(ProtobufWriter out, int tagSize, Boolean value) { + return computeSize(value); + } + + @Override + public int computeSize(Boolean value) { return value == null ? 0 : 1; } @@ -70,15 +76,30 @@ public abstract class ProtobufCoders { public Type getType() { return Boolean.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.INT; + } + + @Override + public final Class primitiveType() { + return boolean.class; + } } public static class ProtobufByteSimpledCoder extends ByteSimpledCoder - implements ProtobufPrimitivable, ProtobufEncodeable { + implements ProtobufPrimitivable, ProtobufEncodeable { public static final ProtobufByteSimpledCoder instance = new ProtobufByteSimpledCoder(); @Override public int computeSize(ProtobufWriter out, int tagSize, Byte value) { + return computeSize(value); + } + + @Override + public int computeSize(Byte value) { return value == null ? 0 : 1; } @@ -86,15 +107,30 @@ public abstract class ProtobufCoders { public Type getType() { return Byte.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.INT; + } + + @Override + public final Class primitiveType() { + return byte.class; + } } public static class ProtobufCharSimpledCoder extends CharSimpledCoder - implements ProtobufPrimitivable, ProtobufEncodeable { + implements ProtobufPrimitivable, ProtobufEncodeable { public static final ProtobufCharSimpledCoder instance = new ProtobufCharSimpledCoder(); @Override public int computeSize(ProtobufWriter out, int tagSize, Character value) { + return computeSize(value); + } + + @Override + public int computeSize(Character value) { return value == null ? 0 : ProtobufFactory.computeSInt32SizeNoTag(value); } @@ -102,15 +138,30 @@ public abstract class ProtobufCoders { public Type getType() { return Character.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.INT; + } + + @Override + public final Class primitiveType() { + return char.class; + } } public static class ProtobufShortSimpledCoder extends ShortSimpledCoder - implements ProtobufPrimitivable, ProtobufEncodeable { + implements ProtobufPrimitivable, ProtobufEncodeable { public static final ProtobufShortSimpledCoder instance = new ProtobufShortSimpledCoder(); @Override public int computeSize(ProtobufWriter out, int tagSize, Short value) { + return computeSize(value); + } + + @Override + public int computeSize(Short value) { return value == null ? 0 : ProtobufFactory.computeSInt32SizeNoTag(value); } @@ -118,15 +169,30 @@ public abstract class ProtobufCoders { public Type getType() { return Short.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.INT; + } + + @Override + public final Class primitiveType() { + return short.class; + } } public static class ProtobufIntSimpledCoder extends IntSimpledCoder - implements ProtobufPrimitivable, ProtobufEncodeable { + implements ProtobufPrimitivable, ProtobufEncodeable { public static final ProtobufIntSimpledCoder instance = new ProtobufIntSimpledCoder(); @Override public int computeSize(ProtobufWriter out, int tagSize, Integer value) { + return computeSize(value); + } + + @Override + public int computeSize(Integer value) { return value == null ? 0 : ProtobufFactory.computeSInt32SizeNoTag(value); } @@ -134,15 +200,30 @@ public abstract class ProtobufCoders { public Type getType() { return Integer.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.INT; + } + + @Override + public final Class primitiveType() { + return int.class; + } } public static class ProtobufFloatSimpledCoder extends FloatSimpledCoder - implements ProtobufPrimitivable, ProtobufEncodeable { + implements ProtobufPrimitivable, ProtobufEncodeable { public static final ProtobufFloatSimpledCoder instance = new ProtobufFloatSimpledCoder(); @Override public int computeSize(ProtobufWriter out, int tagSize, Float value) { + return computeSize(value); + } + + @Override + public int computeSize(Float value) { return value == null ? 0 : 4; } @@ -150,15 +231,30 @@ public abstract class ProtobufCoders { public Type getType() { return Float.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.FLOAT; + } + + @Override + public final Class primitiveType() { + return float.class; + } } public static class ProtobufLongSimpledCoder extends LongSimpledCoder - implements ProtobufPrimitivable, ProtobufEncodeable { + implements ProtobufPrimitivable, ProtobufEncodeable { public static final ProtobufLongSimpledCoder instance = new ProtobufLongSimpledCoder(); @Override public int computeSize(ProtobufWriter out, int tagSize, Long value) { + return computeSize(value); + } + + @Override + public int computeSize(Long value) { return value == null ? 0 : ProtobufFactory.computeSInt64SizeNoTag(value); } @@ -166,15 +262,30 @@ public abstract class ProtobufCoders { public Type getType() { return Long.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.INT; + } + + @Override + public final Class primitiveType() { + return long.class; + } } public static class ProtobufDoubleSimpledCoder extends DoubleSimpledCoder - implements ProtobufPrimitivable, ProtobufEncodeable { + implements ProtobufPrimitivable, ProtobufEncodeable { public static final ProtobufDoubleSimpledCoder instance = new ProtobufDoubleSimpledCoder(); @Override public int computeSize(ProtobufWriter out, int tagSize, Double value) { + return computeSize(value); + } + + @Override + public int computeSize(Double value) { return value == null ? 0 : 8; } @@ -182,6 +293,16 @@ public abstract class ProtobufCoders { public Type getType() { return Double.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.DOUBLE; + } + + @Override + public final Class primitiveType() { + return double.class; + } } public static class ProtobufStringSimpledCoder extends StringSimpledCoder @@ -202,24 +323,43 @@ public abstract class ProtobufCoders { public Type getType() { return String.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } // ------------------------------------- simple object ------------------------------------- public static class ProtobufNumberSimpledCoder extends NumberSimpledCoder - implements ProtobufPrimitivable, ProtobufEncodeable { + implements ProtobufPrimitivable, ProtobufEncodeable { public static final ProtobufNumberSimpledCoder instance = new ProtobufNumberSimpledCoder(); @Override public int computeSize(ProtobufWriter out, int tagSize, Number value) { - return ProtobufLongSimpledCoder.instance.computeSize( - out, tagSize, value == null ? null : value.longValue()); + return computeSize(value); + } + + @Override + public int computeSize(Number value) { + return ProtobufLongSimpledCoder.instance.computeSize(value.longValue()); } @Override public Type getType() { return Number.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.INT; + } + + @Override + public final Class primitiveType() { + return long.class; + } } public static class ProtobufStringWrapperSimpledCoder @@ -238,6 +378,11 @@ public abstract class ProtobufCoders { public Type getType() { return StringWrapper.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufCharSequenceSimpledCoder @@ -256,6 +401,11 @@ public abstract class ProtobufCoders { public Type getType() { return CharSequence.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufStringBuilderSimpledCoder @@ -274,51 +424,89 @@ public abstract class ProtobufCoders { public Type getType() { return StringBuilder.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufDateSimpledCoder extends DateSimpledCoder - implements ProtobufPrimitivable, ProtobufEncodeable { + implements ProtobufPrimitivable, ProtobufEncodeable { public static final ProtobufDateSimpledCoder instance = new ProtobufDateSimpledCoder(); @Override public int computeSize(ProtobufWriter out, int tagSize, java.util.Date value) { - return ProtobufLongSimpledCoder.instance.computeSize(out, tagSize, value == null ? null : value.getTime()); + return computeSize(value); + } + + @Override + public int computeSize(java.util.Date value) { + return ProtobufLongSimpledCoder.instance.computeSize(value.getTime()); } @Override public Type getType() { return java.util.Date.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.INT; + } + + @Override + public final Class primitiveType() { + return long.class; + } } public static class ProtobufInstantSimpledCoder extends InstantSimpledCoder - implements ProtobufPrimitivable, ProtobufEncodeable { + implements ProtobufPrimitivable, ProtobufEncodeable { public static final ProtobufInstantSimpledCoder instance = new ProtobufInstantSimpledCoder(); @Override public int computeSize(ProtobufWriter out, int tagSize, java.time.Instant value) { - return ProtobufLongSimpledCoder.instance.computeSize( - out, tagSize, value == null ? null : value.toEpochMilli()); + return computeSize(value); + } + + @Override + public int computeSize(java.time.Instant value) { + return ProtobufLongSimpledCoder.instance.computeSize(value == null ? null : value.toEpochMilli()); } @Override public Type getType() { return java.time.Instant.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.INT; + } + + @Override + public final Class primitiveType() { + return long.class; + } } public static class ProtobufLocalDateSimpledCoder extends LocalDateSimpledCoder - implements ProtobufPrimitivable, ProtobufEncodeable { + implements ProtobufPrimitivable, + ProtobufEncodeable { public static final ProtobufLocalDateSimpledCoder instance = new ProtobufLocalDateSimpledCoder(); @Override public int computeSize(ProtobufWriter out, int tagSize, java.time.LocalDate value) { + return computeSize(value); + } + + @Override + public int computeSize(java.time.LocalDate value) { return ProtobufIntSimpledCoder.instance.computeSize( - out, - tagSize, value == null ? null : (value.getYear() * 100_00 + value.getMonthValue() * 100 + value.getDayOfMonth())); @@ -328,23 +516,48 @@ public abstract class ProtobufCoders { public Type getType() { return java.time.LocalDate.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.INT; + } + + @Override + public final Class primitiveType() { + return int.class; + } } public static class ProtobufLocalTimeSimpledCoder extends LocalTimeSimpledCoder - implements ProtobufPrimitivable, ProtobufEncodeable { + implements ProtobufPrimitivable, + ProtobufEncodeable { public static final ProtobufLocalTimeSimpledCoder instance = new ProtobufLocalTimeSimpledCoder(); @Override public int computeSize(ProtobufWriter out, int tagSize, java.time.LocalTime value) { - return ProtobufLongSimpledCoder.instance.computeSize( - out, tagSize, value == null ? null : value.toNanoOfDay()); + return computeSize(value); + } + + @Override + public int computeSize(java.time.LocalTime value) { + return ProtobufLongSimpledCoder.instance.computeSize(value == null ? null : value.toNanoOfDay()); } @Override public Type getType() { return java.time.LocalTime.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.INT; + } + + @Override + public final Class primitiveType() { + return long.class; + } } public static class ProtobufLocalDateTimeSimpledCoder @@ -353,6 +566,10 @@ public abstract class ProtobufCoders { public static final ProtobufLocalDateTimeSimpledCoder instance = new ProtobufLocalDateTimeSimpledCoder(); + public ProtobufLocalDateTimeSimpledCoder() { + super(ProtobufByteArraySimpledCoder.instance); + } + @Override public int computeSize(ProtobufWriter out, int tagSize, java.time.LocalDateTime value) { return value == null ? 0 : (ProtobufFactory.computeSInt64SizeNoTag(12) + 12); @@ -362,32 +579,58 @@ public abstract class ProtobufCoders { public Type getType() { return java.time.LocalDateTime.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufDurationSimpledCoder extends DurationSimpledCoder - implements ProtobufPrimitivable, ProtobufEncodeable { + implements ProtobufPrimitivable, + ProtobufEncodeable { public static final ProtobufDurationSimpledCoder instance = new ProtobufDurationSimpledCoder(); @Override public int computeSize(ProtobufWriter out, int tagSize, java.time.Duration value) { - return ProtobufLongSimpledCoder.instance.computeSize(out, tagSize, value == null ? null : value.toNanos()); + return computeSize(value); + } + + @Override + public int computeSize(java.time.Duration value) { + return ProtobufLongSimpledCoder.instance.computeSize(value == null ? null : value.toNanos()); } @Override public Type getType() { return java.time.Duration.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.INT; + } + + @Override + public final Class primitiveType() { + return long.class; + } } public static class ProtobufAtomicBooleanSimpledCoder extends AtomicBooleanSimpledCoder - implements ProtobufPrimitivable, ProtobufEncodeable { + implements ProtobufPrimitivable, ProtobufEncodeable { public static final ProtobufAtomicBooleanSimpledCoder instance = new ProtobufAtomicBooleanSimpledCoder(); @Override public int computeSize(ProtobufWriter out, int tagSize, AtomicBoolean value) { + return computeSize(value); + } + + @Override + public int computeSize(AtomicBoolean value) { return value == null ? 0 : 1; } @@ -395,39 +638,79 @@ public abstract class ProtobufCoders { public Type getType() { return AtomicBoolean.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.INT; + } + + @Override + public final Class primitiveType() { + return boolean.class; + } } public static class ProtobufAtomicIntegerSimpledCoder extends AtomicIntegerSimpledCoder - implements ProtobufPrimitivable, ProtobufEncodeable { + implements ProtobufPrimitivable, ProtobufEncodeable { public static final ProtobufAtomicIntegerSimpledCoder instance = new ProtobufAtomicIntegerSimpledCoder(); @Override public int computeSize(ProtobufWriter out, int tagSize, AtomicInteger value) { - return ProtobufIntSimpledCoder.instance.computeSize(out, tagSize, value == null ? null : value.get()); + return computeSize(value); + } + + @Override + public int computeSize(AtomicInteger value) { + return ProtobufIntSimpledCoder.instance.computeSize(value == null ? null : value.get()); } @Override public Type getType() { return AtomicInteger.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.INT; + } + + @Override + public final Class primitiveType() { + return int.class; + } } public static class ProtobufAtomicLongSimpledCoder extends AtomicLongSimpledCoder - implements ProtobufPrimitivable, ProtobufEncodeable { + implements ProtobufPrimitivable, ProtobufEncodeable { public static final ProtobufAtomicLongSimpledCoder instance = new ProtobufAtomicLongSimpledCoder(); @Override public int computeSize(ProtobufWriter out, int tagSize, AtomicLong value) { - return ProtobufLongSimpledCoder.instance.computeSize(out, tagSize, value == null ? null : value.get()); + return computeSize(value); + } + + @Override + public int computeSize(AtomicLong value) { + return ProtobufLongSimpledCoder.instance.computeSize(value == null ? null : value.get()); } @Override public Type getType() { return AtomicLong.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.INT; + } + + @Override + public final Class primitiveType() { + return long.class; + } } public static class ProtobufBigIntegerSimpledCoder extends BigIntegerSimpledCoder @@ -441,7 +724,7 @@ public abstract class ProtobufCoders { return 0; } byte[] bs = value.toByteArray(); - return ProtobufFactory.computeSInt32SizeNoTag(bs.length) + bs.length; + return ProtobufByteArraySimpledCoder.instance.computeSize(out, tagSize, bs); } @Override @@ -450,8 +733,8 @@ public abstract class ProtobufCoders { } @Override - public final boolean requireSize() { - return true; + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; } } @@ -472,6 +755,11 @@ public abstract class ProtobufCoders { public Type getType() { return BigDecimal.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufInetAddressSimpledCoder extends InetAddressSimpledCoder @@ -479,13 +767,17 @@ public abstract class ProtobufCoders { public static final ProtobufInetAddressSimpledCoder instance = new ProtobufInetAddressSimpledCoder(); + public ProtobufInetAddressSimpledCoder() { + super(ProtobufByteArraySimpledCoder.instance); + } + @Override public int computeSize(ProtobufWriter out, int tagSize, InetAddress value) { if (value == null) { return 0; } byte[] bs = value.getAddress(); - return ProtobufFactory.computeSInt32SizeNoTag(bs.length) + bs.length; + return ProtobufByteArraySimpledCoder.instance.computeSize(out, tagSize, bs); } @Override @@ -494,8 +786,8 @@ public abstract class ProtobufCoders { } @Override - public final boolean requireSize() { - return true; + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; } } @@ -512,7 +804,7 @@ public abstract class ProtobufCoders { return 0; } byte[] bs = value.getAddress().getAddress(); - return ProtobufFactory.computeSInt32SizeNoTag(bs.length) + bs.length; + return ProtobufByteArraySimpledCoder.instance.computeSize(out, tagSize, bs); } @Override @@ -521,26 +813,40 @@ public abstract class ProtobufCoders { } @Override - public final boolean requireSize() { - return true; + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; } } public static class ProtobufLongAdderSimpledCoder extends LongAdderSimpledCoder - implements ProtobufPrimitivable, ProtobufEncodeable { + implements ProtobufPrimitivable, ProtobufEncodeable { public static final ProtobufLongAdderSimpledCoder instance = new ProtobufLongAdderSimpledCoder(); @Override public int computeSize(ProtobufWriter out, int tagSize, LongAdder value) { - return ProtobufLongSimpledCoder.instance.computeSize( - out, tagSize, value == null ? null : value.longValue()); + return computeSize(value); + } + + @Override + public int computeSize(LongAdder value) { + return ProtobufLongSimpledCoder.instance.computeSize(value == null ? null : value.longValue()); } @Override public Type getType() { return LongAdder.class; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.INT; + } + + @Override + public final Class primitiveType() { + return long.class; + } } public static class ProtobufUint128SimpledCoder extends Uint128SimpledCoder @@ -554,7 +860,7 @@ public abstract class ProtobufCoders { return 0; } byte[] bs = value.getBytes(); - return ProtobufFactory.computeSInt32SizeNoTag(bs.length) + bs.length; + return ProtobufByteArraySimpledCoder.instance.computeSize(out, tagSize, bs); } @Override @@ -563,8 +869,195 @@ public abstract class ProtobufCoders { } @Override - public final boolean requireSize() { - return true; + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } + } + + public static class ProtobufPrimitiveArraySimpledCoder extends SimpledCoder + implements ProtobufEncodeable { + + private final IntFunction arrayFunc; + private final SimpledCoder componentCoder; + + public ProtobufPrimitiveArraySimpledCoder(ProtobufPrimitivable primitiveCoder) { + this.componentCoder = (SimpledCoder) primitiveCoder; + this.arrayFunc = Creator.funcArray(TypeToken.typeToClass(this.componentCoder.getType())); + } + + @Override + public void convertTo(ProtobufWriter out, T[] value) { + if (value == null || value.length == 0) { + return; + } + SimpledCoder itemCoder = this.componentCoder; + ProtobufPrimitivable primCoder = (ProtobufPrimitivable) itemCoder; + T[] array = value; + int len = 0; + for (T item : array) { + len += primCoder.computeSize(item == null ? 0 : item); + } + out.writeLength(len); + for (T item : array) { + itemCoder.convertTo(out, item); + } + } + + @Override + public T[] convertFrom(ProtobufReader in) { + SimpledCoder itemCoder = this.componentCoder; + ProtobufPrimitivable primCoder = (ProtobufPrimitivable) itemCoder; + List data = new ArrayList<>(); + int len = in.readRawVarint32(); + while (len > 0) { + T val = itemCoder.convertFrom(in); + len -= primCoder.computeSize(val); + data.add(val); + } + return data.toArray(this.arrayFunc); + } + + @Override + public int computeSize(ProtobufWriter out, int tagSize, T[] value) { + if (value == null || value.length == 0) { + return 0; + } + ProtobufPrimitivable primCoder = (ProtobufPrimitivable) this.componentCoder; + int len = 0; + for (T item : value) { + len += primCoder.computeSize(item); + } + return len; + } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } + } + + public static class ProtobufPrimitiveCollectionSimpledCoder + extends SimpledCoder> + implements ProtobufEncodeable> { + + private final Creator creator; + + private final SimpledCoder componentCoder; + + public ProtobufPrimitiveCollectionSimpledCoder( + Creator creator, ProtobufPrimitivable primitiveCoder) { + this.creator = creator; + this.componentCoder = (SimpledCoder) primitiveCoder; + } + + @Override + public void convertTo(ProtobufWriter out, Collection values) { + SimpledCoder itemCoder = this.componentCoder; + ProtobufPrimitivable primCoder = (ProtobufPrimitivable) itemCoder; + Collection array = values; + if (array != null && !array.isEmpty()) { + int len = 0; + for (T item : array) { + len += primCoder.computeSize(item == null ? 0 : item); + } + out.writeLength(len); + for (T item : array) { + itemCoder.convertTo(out, item); + } + } + } + + @Override + public Collection convertFrom(ProtobufReader in) { + SimpledCoder itemCoder = this.componentCoder; + ProtobufPrimitivable primCoder = (ProtobufPrimitivable) itemCoder; + Collection data = creator.create(); + int len = in.readRawVarint32(); + while (len > 0) { + T val = itemCoder.convertFrom(in); + len -= primCoder.computeSize(val); + data.add(val); + } + return data; + } + + @Override + public int computeSize(ProtobufWriter out, int tagSize, Collection value) { + if (value == null || value.isEmpty()) { + return 0; + } + ProtobufPrimitivable primCoder = (ProtobufPrimitivable) this.componentCoder; + int len = 0; + for (T item : value) { + len += primCoder.computeSize(item); + } + return len; + } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } + } + + public static class ProtobufPrimitiveStreamSimpledCoder + extends SimpledCoder> + implements ProtobufEncodeable> { + + private final SimpledCoder componentCoder; + + public ProtobufPrimitiveStreamSimpledCoder(ProtobufPrimitivable primitiveCoder) { + this.componentCoder = (SimpledCoder) primitiveCoder; + } + + @Override + public void convertTo(ProtobufWriter out, Stream value) { + if (value == null) { + return; + } + SimpledCoder itemCoder = this.componentCoder; + ProtobufPrimitivable primCoder = (ProtobufPrimitivable) itemCoder; + Object[] array = value.toArray(); + int len = 0; + for (Object item : array) { + len += primCoder.computeSize(item == null ? 0 : item); + } + out.writeLength(len); + for (Object item : array) { + itemCoder.convertTo(out, (T) item); + } + } + + @Override + public Stream convertFrom(ProtobufReader in) { + SimpledCoder itemCoder = this.componentCoder; + ProtobufPrimitivable primCoder = (ProtobufPrimitivable) itemCoder; + List data = new ArrayList<>(); + int len = in.readRawVarint32(); + while (len > 0) { + T val = itemCoder.convertFrom(in); + len -= primCoder.computeSize(val); + data.add(val); + } + return data.stream(); + } + + @Override + public int computeSize(ProtobufWriter out, int tagSize, Stream value) { + if (value == null) { + return 0; + } + ProtobufPrimitivable primCoder = (ProtobufPrimitivable) this.componentCoder; + int len = 0; + for (Object item : value.toArray()) { + len += primCoder.computeSize(item); + } + return len; + } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; } } @@ -588,6 +1081,11 @@ public abstract class ProtobufCoders { public int computeSize(ProtobufWriter out, int tagSize, boolean[] value) { return value == null ? 0 : value.length; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufByteArraySimpledCoder extends SimpledCoder @@ -609,6 +1107,11 @@ public abstract class ProtobufCoders { public int computeSize(ProtobufWriter out, int tagSize, byte[] value) { return value == null ? 0 : value.length; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufCharArraySimpledCoder extends SimpledCoder @@ -637,6 +1140,11 @@ public abstract class ProtobufCoders { } return len; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufShortArraySimpledCoder extends SimpledCoder @@ -665,6 +1173,11 @@ public abstract class ProtobufCoders { } return len; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufIntArraySimpledCoder extends SimpledCoder @@ -693,6 +1206,11 @@ public abstract class ProtobufCoders { } return len; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufFloatArraySimpledCoder extends SimpledCoder @@ -714,6 +1232,11 @@ public abstract class ProtobufCoders { public int computeSize(ProtobufWriter out, int tagSize, float[] value) { return value == null ? 0 : value.length * 4; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufLongArraySimpledCoder extends SimpledCoder @@ -742,6 +1265,11 @@ public abstract class ProtobufCoders { } return len; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufDoubleArraySimpledCoder extends SimpledCoder @@ -763,6 +1291,11 @@ public abstract class ProtobufCoders { public int computeSize(ProtobufWriter out, int tagSize, double[] value) { return value == null ? 0 : value.length * 8; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } // ------------------------------------- Boolean[] ------------------------------------- @@ -785,6 +1318,11 @@ public abstract class ProtobufCoders { public int computeSize(ProtobufWriter out, int tagSize, Boolean[] value) { return value == null ? 0 : value.length; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufByteArraySimpledCoder2 extends SimpledCoder @@ -806,6 +1344,11 @@ public abstract class ProtobufCoders { public int computeSize(ProtobufWriter out, int tagSize, Byte[] value) { return value == null ? 0 : value.length; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufCharArraySimpledCoder2 extends SimpledCoder @@ -834,6 +1377,11 @@ public abstract class ProtobufCoders { } return len; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufShortArraySimpledCoder2 extends SimpledCoder @@ -862,6 +1410,11 @@ public abstract class ProtobufCoders { } return len; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufIntArraySimpledCoder2 extends SimpledCoder @@ -890,6 +1443,11 @@ public abstract class ProtobufCoders { } return len; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufFloatArraySimpledCoder2 extends SimpledCoder @@ -911,6 +1469,11 @@ public abstract class ProtobufCoders { public int computeSize(ProtobufWriter out, int tagSize, Float[] value) { return value == null ? 0 : value.length * 4; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufLongArraySimpledCoder2 extends SimpledCoder @@ -939,6 +1502,11 @@ public abstract class ProtobufCoders { } return len; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufDoubleArraySimpledCoder2 extends SimpledCoder @@ -960,64 +1528,10 @@ public abstract class ProtobufCoders { public int computeSize(ProtobufWriter out, int tagSize, Double[] value) { return value == null ? 0 : value.length * 8; } - } - - public static class ProtobufAtomicIntegerArraySimpledCoder - extends SimpledCoder - implements ProtobufEncodeable { - - public static final ProtobufAtomicIntegerArraySimpledCoder instance = - new ProtobufAtomicIntegerArraySimpledCoder(); @Override - public void convertTo(ProtobufWriter out, AtomicInteger[] values) { - out.writeAtomicIntegers(values); - } - - @Override - public AtomicInteger[] convertFrom(ProtobufReader in) { - return in.readAtomicIntegers(); - } - - @Override - public int computeSize(ProtobufWriter out, int tagSize, AtomicInteger[] value) { - if (value == null || value.length == 0) { - return 0; - } - int len = 0; - for (AtomicInteger item : value) { - len += ProtobufFactory.computeSInt32SizeNoTag(item == null ? 0 : item.get()); - } - return len; - } - } - - public static class ProtobufAtomicLongArraySimpledCoder - extends SimpledCoder - implements ProtobufEncodeable { - - public static final ProtobufAtomicLongArraySimpledCoder instance = new ProtobufAtomicLongArraySimpledCoder(); - - @Override - public void convertTo(ProtobufWriter out, AtomicLong[] values) { - out.writeAtomicLongs(values); - } - - @Override - public AtomicLong[] convertFrom(ProtobufReader in) { - return in.readAtomicLongs(); - } - - @Override - public int computeSize(ProtobufWriter out, int tagSize, AtomicLong[] value) { - if (value == null || value.length == 0) { - return 0; - } - int len = 0; - for (AtomicLong item : value) { - len += ProtobufFactory.computeSInt64SizeNoTag(item == null ? 0 : item.get()); - } - return len; + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; } } @@ -1046,6 +1560,11 @@ public abstract class ProtobufCoders { public int computeSize(ProtobufWriter out, int tagSize, Collection value) { return value == null ? 0 : value.size(); } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufByteCollectionSimpledCoder @@ -1072,6 +1591,11 @@ public abstract class ProtobufCoders { public int computeSize(ProtobufWriter out, int tagSize, Collection value) { return value == null ? 0 : value.size(); } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufCharCollectionSimpledCoder @@ -1105,6 +1629,11 @@ public abstract class ProtobufCoders { } return len; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufShortCollectionSimpledCoder @@ -1138,6 +1667,11 @@ public abstract class ProtobufCoders { } return len; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufIntCollectionSimpledCoder @@ -1171,6 +1705,11 @@ public abstract class ProtobufCoders { } return len; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufFloatCollectionSimpledCoder @@ -1197,6 +1736,11 @@ public abstract class ProtobufCoders { public int computeSize(ProtobufWriter out, int tagSize, Collection value) { return value == null ? 0 : value.size() * 4; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufLongCollectionSimpledCoder @@ -1230,6 +1774,11 @@ public abstract class ProtobufCoders { } return len; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufDoubleCollectionSimpledCoder @@ -1256,97 +1805,10 @@ public abstract class ProtobufCoders { public int computeSize(ProtobufWriter out, int tagSize, Collection value) { return value == null ? 0 : value.size() * 8; } - } - - public static class ProtobufAtomicBooleanCollectionSimpledCoder - extends SimpledCoder> - implements ProtobufEncodeable> { - - private final Creator creator; - - public ProtobufAtomicBooleanCollectionSimpledCoder(Creator creator) { - this.creator = creator; - } @Override - public void convertTo(ProtobufWriter out, Collection values) { - out.writeAtomicBooleans(values); - } - - @Override - public Collection convertFrom(ProtobufReader in) { - return in.readAtomicBooleans(creator); - } - - @Override - public int computeSize(ProtobufWriter out, int tagSize, Collection value) { - return value == null ? 0 : value.size(); - } - } - - public static class ProtobufAtomicIntegerCollectionSimpledCoder - extends SimpledCoder> - implements ProtobufEncodeable> { - - private final Creator creator; - - public ProtobufAtomicIntegerCollectionSimpledCoder(Creator creator) { - this.creator = creator; - } - - @Override - public void convertTo(ProtobufWriter out, Collection values) { - out.writeAtomicIntegers(values); - } - - @Override - public Collection convertFrom(ProtobufReader in) { - return in.readAtomicIntegers(creator); - } - - @Override - public int computeSize(ProtobufWriter out, int tagSize, Collection value) { - if (value == null || value.isEmpty()) { - return 0; - } - int len = 0; - for (AtomicInteger item : value) { - len += ProtobufFactory.computeSInt32SizeNoTag(item == null ? 0 : item.get()); - } - return len; - } - } - - public static class ProtobufAtomicLongCollectionSimpledCoder - extends SimpledCoder> - implements ProtobufEncodeable> { - - private final Creator creator; - - public ProtobufAtomicLongCollectionSimpledCoder(Creator creator) { - this.creator = creator; - } - - @Override - public void convertTo(ProtobufWriter out, Collection values) { - out.writeAtomicLongs(values); - } - - @Override - public Collection convertFrom(ProtobufReader in) { - return in.readAtomicLongs(creator); - } - - @Override - public int computeSize(ProtobufWriter out, int tagSize, Collection value) { - if (value == null || value.isEmpty()) { - return 0; - } - int len = 0; - for (AtomicLong item : value) { - len += ProtobufFactory.computeSInt64SizeNoTag(item == null ? 0 : item.get()); - } - return len; + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; } } @@ -1371,6 +1833,11 @@ public abstract class ProtobufCoders { public int computeSize(ProtobufWriter out, int tagSize, Stream value) { return value == null ? 0 : (int) value.count(); } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufByteStreamSimpledCoder @@ -1393,6 +1860,11 @@ public abstract class ProtobufCoders { public int computeSize(ProtobufWriter out, int tagSize, Stream value) { return value == null ? 0 : (int) value.count(); } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufCharStreamSimpledCoder @@ -1422,6 +1894,11 @@ public abstract class ProtobufCoders { } return len; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufShortStreamSimpledCoder @@ -1451,6 +1928,11 @@ public abstract class ProtobufCoders { } return len; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufIntStreamSimpledCoder @@ -1480,6 +1962,11 @@ public abstract class ProtobufCoders { } return len; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufFloatStreamSimpledCoder @@ -1502,6 +1989,11 @@ public abstract class ProtobufCoders { public int computeSize(ProtobufWriter out, int tagSize, Stream value) { return value == null ? 0 : (int) value.count() * 4; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufLongStreamSimpledCoder @@ -1531,6 +2023,11 @@ public abstract class ProtobufCoders { } return len; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } public static class ProtobufDoubleStreamSimpledCoder @@ -1553,87 +2050,10 @@ public abstract class ProtobufCoders { public int computeSize(ProtobufWriter out, int tagSize, Stream value) { return value == null ? 0 : (int) value.count() * 8; } - } - - public static class ProtobufAtomicBooleanStreamSimpledCoder - extends SimpledCoder> - implements ProtobufEncodeable> { - - public static final ProtobufAtomicBooleanStreamSimpledCoder instance = - new ProtobufAtomicBooleanStreamSimpledCoder(); @Override - public void convertTo(ProtobufWriter out, Stream values) { - out.writeAtomicBooleans(values); - } - - @Override - public Stream convertFrom(ProtobufReader in) { - return in.readAtomicBooleans(LIST_CREATOR).stream(); - } - - @Override - public int computeSize(ProtobufWriter out, int tagSize, Stream value) { - return value == null ? 0 : (int) value.count(); - } - } - - public static class ProtobufAtomicIntegerStreamSimpledCoder - extends SimpledCoder> - implements ProtobufEncodeable> { - - public static final ProtobufAtomicIntegerStreamSimpledCoder instance = - new ProtobufAtomicIntegerStreamSimpledCoder(); - - @Override - public void convertTo(ProtobufWriter out, Stream values) { - out.writeAtomicIntegers(values); - } - - @Override - public Stream convertFrom(ProtobufReader in) { - return in.readAtomicIntegers(LIST_CREATOR).stream(); - } - - @Override - public int computeSize(ProtobufWriter out, int tagSize, Stream value) { - if (value == null) { - return 0; - } - int len = 0; - for (Object item : value.toArray()) { - len += ProtobufFactory.computeSInt32SizeNoTag(item == null ? 0 : ((AtomicInteger) item).get()); - } - return len; - } - } - - public static class ProtobufAtomicLongStreamSimpledCoder - extends SimpledCoder> - implements ProtobufEncodeable> { - - public static final ProtobufAtomicLongStreamSimpledCoder instance = new ProtobufAtomicLongStreamSimpledCoder(); - - @Override - public void convertTo(ProtobufWriter out, Stream values) { - out.writeAtomicLongs(values); - } - - @Override - public Stream convertFrom(ProtobufReader in) { - return in.readAtomicLongs(LIST_CREATOR).stream(); - } - - @Override - public int computeSize(ProtobufWriter out, int tagSize, Stream value) { - if (value == null) { - return 0; - } - int len = 0; - for (Object item : value.toArray()) { - len += ProtobufFactory.computeSInt64SizeNoTag(item == null ? 0 : ((AtomicLong) item).get()); - } - return len; + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; } } } diff --git a/src/main/java/org/redkale/convert/pb/ProtobufCollectionDecoder.java b/src/main/java/org/redkale/convert/pb/ProtobufCollectionDecoder.java index 55df38de4..d97963694 100644 --- a/src/main/java/org/redkale/convert/pb/ProtobufCollectionDecoder.java +++ b/src/main/java/org/redkale/convert/pb/ProtobufCollectionDecoder.java @@ -34,12 +34,21 @@ public class ProtobufCollectionDecoder extends CollectionDecoder result = this.creator.create(); final int limit = in.limit(); while (in.hasNext()) { + boolean nodata = false; if (!simpled) { int contentLen = in.readRawVarint32(); - in.limit(in.position() + contentLen + 1); + if (contentLen == 0) { + nodata = true; + } else { + in.limit(in.position() + contentLen + 1); + } + } + if (nodata) { + result.add(null); + } else { + result.add(itemDecoder.convertFrom(in)); + in.limit(limit); } - result.add(itemDecoder.convertFrom(in)); - in.limit(limit); if (!in.readNextTag(member)) { // 元素结束 break; } diff --git a/src/main/java/org/redkale/convert/pb/ProtobufCollectionEncoder.java b/src/main/java/org/redkale/convert/pb/ProtobufCollectionEncoder.java index d4b384cae..750dc8ab0 100644 --- a/src/main/java/org/redkale/convert/pb/ProtobufCollectionEncoder.java +++ b/src/main/java/org/redkale/convert/pb/ProtobufCollectionEncoder.java @@ -31,7 +31,7 @@ public class ProtobufCollectionEncoder extends CollectionEncoder extends CollectionEncoder extends CollectionEncoder extends ProtobufObjectEncoder { protected static ProtobufDynEncoder generateDyncEncoder(final ProtobufFactory factory, final Class clazz) { final ObjectEncoder selfObjEncoder = factory.createObjectEncoder(clazz); selfObjEncoder.init(factory); // 必须执行，初始化EnMember内部信息 - // if (((ProtobufObjectEncoder) selfObjEncoder).requiredMemberSize()) { // 嵌套对象 - // return null; - // } + if (((ProtobufObjectEncoder) selfObjEncoder).requiredMemberSize()) { // 嵌套对象 + return null; + } final Map simpledCoders = new HashMap<>(); final Map otherMembers = new HashMap<>(); StringBuilder elementb = new StringBuilder(); @@ -254,12 +253,6 @@ public abstract class ProtobufDynEncoder extends ProtobufObjectEncoder { wmethodName = "writeFieldLongsValue"; } else if (componentType == Double.class) { wmethodName = "writeFieldDoublesValue"; - } else if (componentType == AtomicBoolean.class) { - wmethodName = "writeFieldAtomicBooleansValue"; - } else if (componentType == AtomicInteger.class) { - wmethodName = "writeFieldAtomicIntegersValue"; - } else if (componentType == AtomicLong.class) { - wmethodName = "writeFieldAtomicLongsValue"; } else if (componentType == String.class) { wmethodName = "writeFieldStringsValue"; } diff --git a/src/main/java/org/redkale/convert/pb/ProtobufEncodeable.java b/src/main/java/org/redkale/convert/pb/ProtobufEncodeable.java index d3d8fc47b..4aceb8e2c 100644 --- a/src/main/java/org/redkale/convert/pb/ProtobufEncodeable.java +++ b/src/main/java/org/redkale/convert/pb/ProtobufEncodeable.java @@ -31,4 +31,8 @@ public interface ProtobufEncodeable extends Encodeable Decodeable createCollectionDecoder(Type type) { - if (type instanceof ParameterizedType) { - ParameterizedType pt = (ParameterizedType) type; - Type componentType = pt.getActualTypeArguments()[0]; - if (componentType == Boolean.class) { - Creator creator = loadCreator((Class) pt.getRawType()); - return (Decodeable) new ProtobufCoders.ProtobufBoolCollectionSimpledCoder(creator); - } else if (componentType == Byte.class) { - Creator creator = loadCreator((Class) pt.getRawType()); - return (Decodeable) new ProtobufCoders.ProtobufByteCollectionSimpledCoder(creator); - } else if (componentType == Character.class) { - Creator creator = loadCreator((Class) pt.getRawType()); - return (Decodeable) new ProtobufCoders.ProtobufCharCollectionSimpledCoder(creator); - } else if (componentType == Short.class) { - Creator creator = loadCreator((Class) pt.getRawType()); - return (Decodeable) new ProtobufCoders.ProtobufShortCollectionSimpledCoder(creator); - } else if (componentType == Integer.class) { - Creator creator = loadCreator((Class) pt.getRawType()); - return (Decodeable) new ProtobufCoders.ProtobufIntCollectionSimpledCoder(creator); - } else if (componentType == Float.class) { - Creator creator = loadCreator((Class) pt.getRawType()); - return (Decodeable) new ProtobufCoders.ProtobufFloatCollectionSimpledCoder(creator); - } else if (componentType == Long.class) { - Creator creator = loadCreator((Class) pt.getRawType()); - return (Decodeable) new ProtobufCoders.ProtobufLongCollectionSimpledCoder(creator); - } else if (componentType == Double.class) { - Creator creator = loadCreator((Class) pt.getRawType()); - return (Decodeable) new ProtobufCoders.ProtobufDoubleCollectionSimpledCoder(creator); - } else if (componentType == AtomicBoolean.class) { - Creator creator = loadCreator((Class) pt.getRawType()); - return (Decodeable) new ProtobufCoders.ProtobufAtomicBooleanCollectionSimpledCoder(creator); - } else if (componentType == AtomicInteger.class) { - Creator creator = loadCreator((Class) pt.getRawType()); - return (Decodeable) new ProtobufCoders.ProtobufAtomicIntegerCollectionSimpledCoder(creator); - } else if (componentType == AtomicLong.class) { - Creator creator = loadCreator((Class) pt.getRawType()); - return (Decodeable) new ProtobufCoders.ProtobufAtomicLongCollectionSimpledCoder(creator); + Class createClazz = TypeToken.typeToClass(type); + Type componentType = getCollectionComponentType(type); + if (componentType == Boolean.class) { + Creator creator = loadCreator(createClazz); + return (Decodeable) new ProtobufCoders.ProtobufBoolCollectionSimpledCoder(creator); + } else if (componentType == Byte.class) { + Creator creator = loadCreator(createClazz); + return (Decodeable) new ProtobufCoders.ProtobufByteCollectionSimpledCoder(creator); + } else if (componentType == Character.class) { + Creator creator = loadCreator(createClazz); + return (Decodeable) new ProtobufCoders.ProtobufCharCollectionSimpledCoder(creator); + } else if (componentType == Short.class) { + Creator creator = loadCreator(createClazz); + return (Decodeable) new ProtobufCoders.ProtobufShortCollectionSimpledCoder(creator); + } else if (componentType == Integer.class) { + Creator creator = loadCreator(createClazz); + return (Decodeable) new ProtobufCoders.ProtobufIntCollectionSimpledCoder(creator); + } else if (componentType == Float.class) { + Creator creator = loadCreator(createClazz); + return (Decodeable) new ProtobufCoders.ProtobufFloatCollectionSimpledCoder(creator); + } else if (componentType == Long.class) { + Creator creator = loadCreator(createClazz); + return (Decodeable) new ProtobufCoders.ProtobufLongCollectionSimpledCoder(creator); + } else if (componentType == Double.class) { + Creator creator = loadCreator(createClazz); + return (Decodeable) new ProtobufCoders.ProtobufDoubleCollectionSimpledCoder(creator); + } else { + Decodeable componentCoder = findDecoder(componentType); + if (componentCoder instanceof ProtobufPrimitivable) { + Creator creator = loadCreator(createClazz); + ProtobufPrimitivable primCoder = (ProtobufPrimitivable) componentCoder; + return (Decodeable) new ProtobufCoders.ProtobufPrimitiveCollectionSimpledCoder(creator, primCoder); } } return new ProtobufCollectionDecoder(this, type); @@ -233,32 +227,29 @@ public class ProtobufFactory extends ConvertFactory Encodeable createCollectionEncoder(Type type) { - if (type instanceof ParameterizedType) { - ParameterizedType pt = (ParameterizedType) type; - Type componentType = pt.getActualTypeArguments()[0]; - Creator creator = ProtobufCoders.LIST_CREATOR; - if (componentType == Boolean.class) { - return (Encodeable) new ProtobufCoders.ProtobufBoolCollectionSimpledCoder(creator); - } else if (componentType == Byte.class) { - return (Encodeable) new ProtobufCoders.ProtobufByteCollectionSimpledCoder(creator); - } else if (componentType == Character.class) { - return (Encodeable) new ProtobufCoders.ProtobufCharCollectionSimpledCoder(creator); - } else if (componentType == Short.class) { - return (Encodeable) new ProtobufCoders.ProtobufShortCollectionSimpledCoder(creator); - } else if (componentType == Integer.class) { - return (Encodeable) new ProtobufCoders.ProtobufIntCollectionSimpledCoder(creator); - } else if (componentType == Float.class) { - return (Encodeable) new ProtobufCoders.ProtobufFloatCollectionSimpledCoder(creator); - } else if (componentType == Long.class) { - return (Encodeable) new ProtobufCoders.ProtobufLongCollectionSimpledCoder(creator); - } else if (componentType == Double.class) { - return (Encodeable) new ProtobufCoders.ProtobufDoubleCollectionSimpledCoder(creator); - } else if (componentType == AtomicBoolean.class) { - return (Encodeable) new ProtobufCoders.ProtobufAtomicBooleanCollectionSimpledCoder(creator); - } else if (componentType == AtomicInteger.class) { - return (Encodeable) new ProtobufCoders.ProtobufAtomicIntegerCollectionSimpledCoder(creator); - } else if (componentType == AtomicLong.class) { - return (Encodeable) new ProtobufCoders.ProtobufAtomicLongCollectionSimpledCoder(creator); + Creator creator = ProtobufCoders.LIST_CREATOR; + Type componentType = getCollectionComponentType(type); + if (componentType == Boolean.class) { + return (Encodeable) new ProtobufCoders.ProtobufBoolCollectionSimpledCoder(creator); + } else if (componentType == Byte.class) { + return (Encodeable) new ProtobufCoders.ProtobufByteCollectionSimpledCoder(creator); + } else if (componentType == Character.class) { + return (Encodeable) new ProtobufCoders.ProtobufCharCollectionSimpledCoder(creator); + } else if (componentType == Short.class) { + return (Encodeable) new ProtobufCoders.ProtobufShortCollectionSimpledCoder(creator); + } else if (componentType == Integer.class) { + return (Encodeable) new ProtobufCoders.ProtobufIntCollectionSimpledCoder(creator); + } else if (componentType == Float.class) { + return (Encodeable) new ProtobufCoders.ProtobufFloatCollectionSimpledCoder(creator); + } else if (componentType == Long.class) { + return (Encodeable) new ProtobufCoders.ProtobufLongCollectionSimpledCoder(creator); + } else if (componentType == Double.class) { + return (Encodeable) new ProtobufCoders.ProtobufDoubleCollectionSimpledCoder(creator); + } else { + Encodeable componentCoder = findEncoder(componentType); + if (componentCoder instanceof ProtobufPrimitivable) { + ProtobufPrimitivable primCoder = (ProtobufPrimitivable) componentCoder; + return (Encodeable) new ProtobufCoders.ProtobufPrimitiveCollectionSimpledCoder(creator, primCoder); } } return new ProtobufCollectionEncoder(this, type); @@ -266,31 +257,28 @@ public class ProtobufFactory extends ConvertFactory Decodeable createStreamDecoder(Type type) { - if (type instanceof ParameterizedType) { - ParameterizedType pt = (ParameterizedType) type; - Type componentType = pt.getActualTypeArguments()[0]; - if (componentType == Boolean.class) { - return (Decodeable) ProtobufCoders.ProtobufBoolStreamSimpledCoder.instance; - } else if (componentType == Byte.class) { - return (Decodeable) ProtobufCoders.ProtobufByteStreamSimpledCoder.instance; - } else if (componentType == Character.class) { - return (Decodeable) ProtobufCoders.ProtobufCharStreamSimpledCoder.instance; - } else if (componentType == Short.class) { - return (Decodeable) ProtobufCoders.ProtobufShortStreamSimpledCoder.instance; - } else if (componentType == Integer.class) { - return (Decodeable) ProtobufCoders.ProtobufIntStreamSimpledCoder.instance; - } else if (componentType == Float.class) { - return (Decodeable) ProtobufCoders.ProtobufFloatStreamSimpledCoder.instance; - } else if (componentType == Long.class) { - return (Decodeable) ProtobufCoders.ProtobufLongStreamSimpledCoder.instance; - } else if (componentType == Double.class) { - return (Decodeable) ProtobufCoders.ProtobufDoubleStreamSimpledCoder.instance; - } else if (componentType == AtomicBoolean.class) { - return (Decodeable) ProtobufCoders.ProtobufAtomicBooleanStreamSimpledCoder.instance; - } else if (componentType == AtomicInteger.class) { - return (Decodeable) ProtobufCoders.ProtobufAtomicIntegerStreamSimpledCoder.instance; - } else if (componentType == AtomicLong.class) { - return (Decodeable) ProtobufCoders.ProtobufAtomicLongStreamSimpledCoder.instance; + Type componentType = getStreamionComponentType(type); + if (componentType == Boolean.class) { + return (Decodeable) ProtobufCoders.ProtobufBoolStreamSimpledCoder.instance; + } else if (componentType == Byte.class) { + return (Decodeable) ProtobufCoders.ProtobufByteStreamSimpledCoder.instance; + } else if (componentType == Character.class) { + return (Decodeable) ProtobufCoders.ProtobufCharStreamSimpledCoder.instance; + } else if (componentType == Short.class) { + return (Decodeable) ProtobufCoders.ProtobufShortStreamSimpledCoder.instance; + } else if (componentType == Integer.class) { + return (Decodeable) ProtobufCoders.ProtobufIntStreamSimpledCoder.instance; + } else if (componentType == Float.class) { + return (Decodeable) ProtobufCoders.ProtobufFloatStreamSimpledCoder.instance; + } else if (componentType == Long.class) { + return (Decodeable) ProtobufCoders.ProtobufLongStreamSimpledCoder.instance; + } else if (componentType == Double.class) { + return (Decodeable) ProtobufCoders.ProtobufDoubleStreamSimpledCoder.instance; + } else { + Decodeable componentCoder = findDecoder(componentType); + if (componentCoder instanceof ProtobufPrimitivable) { + ProtobufPrimitivable primCoder = (ProtobufPrimitivable) componentCoder; + return (Decodeable) new ProtobufCoders.ProtobufPrimitiveStreamSimpledCoder(primCoder); } } return new ProtobufStreamDecoder(this, type); @@ -298,31 +286,28 @@ public class ProtobufFactory extends ConvertFactory Encodeable createStreamEncoder(Type type) { - if (type instanceof ParameterizedType) { - ParameterizedType pt = (ParameterizedType) type; - Type componentType = pt.getActualTypeArguments()[0]; - if (componentType == Boolean.class) { - return (Encodeable) ProtobufCoders.ProtobufBoolStreamSimpledCoder.instance; - } else if (componentType == Byte.class) { - return (Encodeable) ProtobufCoders.ProtobufByteStreamSimpledCoder.instance; - } else if (componentType == Character.class) { - return (Encodeable) ProtobufCoders.ProtobufCharStreamSimpledCoder.instance; - } else if (componentType == Short.class) { - return (Encodeable) ProtobufCoders.ProtobufShortStreamSimpledCoder.instance; - } else if (componentType == Integer.class) { - return (Encodeable) ProtobufCoders.ProtobufIntStreamSimpledCoder.instance; - } else if (componentType == Float.class) { - return (Encodeable) ProtobufCoders.ProtobufFloatStreamSimpledCoder.instance; - } else if (componentType == Long.class) { - return (Encodeable) ProtobufCoders.ProtobufLongStreamSimpledCoder.instance; - } else if (componentType == Double.class) { - return (Encodeable) ProtobufCoders.ProtobufDoubleStreamSimpledCoder.instance; - } else if (componentType == AtomicBoolean.class) { - return (Encodeable) ProtobufCoders.ProtobufAtomicBooleanStreamSimpledCoder.instance; - } else if (componentType == AtomicInteger.class) { - return (Encodeable) ProtobufCoders.ProtobufAtomicIntegerStreamSimpledCoder.instance; - } else if (componentType == AtomicLong.class) { - return (Encodeable) ProtobufCoders.ProtobufAtomicLongStreamSimpledCoder.instance; + Type componentType = getStreamionComponentType(type); + if (componentType == Boolean.class) { + return (Encodeable) ProtobufCoders.ProtobufBoolStreamSimpledCoder.instance; + } else if (componentType == Byte.class) { + return (Encodeable) ProtobufCoders.ProtobufByteStreamSimpledCoder.instance; + } else if (componentType == Character.class) { + return (Encodeable) ProtobufCoders.ProtobufCharStreamSimpledCoder.instance; + } else if (componentType == Short.class) { + return (Encodeable) ProtobufCoders.ProtobufShortStreamSimpledCoder.instance; + } else if (componentType == Integer.class) { + return (Encodeable) ProtobufCoders.ProtobufIntStreamSimpledCoder.instance; + } else if (componentType == Float.class) { + return (Encodeable) ProtobufCoders.ProtobufFloatStreamSimpledCoder.instance; + } else if (componentType == Long.class) { + return (Encodeable) ProtobufCoders.ProtobufLongStreamSimpledCoder.instance; + } else if (componentType == Double.class) { + return (Encodeable) ProtobufCoders.ProtobufDoubleStreamSimpledCoder.instance; + } else { + Encodeable componentCoder = findEncoder(componentType); + if (componentCoder instanceof ProtobufPrimitivable) { + ProtobufPrimitivable primCoder = (ProtobufPrimitivable) componentCoder; + return (Encodeable) new ProtobufCoders.ProtobufPrimitiveStreamSimpledCoder(primCoder); } } return new ProtobufStreamEncoder(this, type); @@ -366,6 +351,7 @@ public class ProtobufFactory extends ConvertFactory extends MapEncoder implements ProtobufEncodeable> { - private final boolean enumtostring; private final int keyTag; private final int valTag; public ProtobufMapEncoder(ConvertFactory factory, Type type) { super(factory, type); - this.enumtostring = ((ProtobufFactory) factory).enumtostring; - this.keyTag = 1 << 3 | ProtobufFactory.wireTypeBit(keyEncoder.getType(), enumtostring); - this.valTag = 2 << 3 | ProtobufFactory.wireTypeBit(valueEncoder.getType(), enumtostring); + this.keyTag = ProtobufFactory.getTag(1, ((ProtobufEncodeable) keyEncoder).typeEnum()); + this.valTag = ProtobufFactory.getTag(2, ((ProtobufEncodeable) valueEncoder).typeEnum()); } @Override public void convertTo(ProtobufWriter out, EnMember member, Map value) { this.checkInited(); final Map values = value; - if (values == null || values.isEmpty()) { + if (Utility.isEmpty(value)) { out.writeNull(); return; } @@ -64,14 +63,19 @@ public class ProtobufMapEncoder extends MapEncoder @Override public int computeSize(ProtobufWriter out, int tagLen, Map value) { - if (value == null || value.isEmpty()) { + if (Utility.isEmpty(value)) { return 0; } return 0; } @Override - public boolean requireSize() { + public final boolean requireSize() { return true; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } diff --git a/src/main/java/org/redkale/convert/pb/ProtobufObjectEncoder.java b/src/main/java/org/redkale/convert/pb/ProtobufObjectEncoder.java index 17916e328..765456080 100644 --- a/src/main/java/org/redkale/convert/pb/ProtobufObjectEncoder.java +++ b/src/main/java/org/redkale/convert/pb/ProtobufObjectEncoder.java @@ -107,11 +107,8 @@ public class ProtobufObjectEncoder extends ObjectEncoder int itemDataSize = encodeable.computeSize(out, itemTagSize, member.getFieldValue(value)); if (itemDataSize > 0) { size += itemTagSize + itemDataSize; - System.out.println( - "member: " + member.getFieldName() + ", tag: " + itemTagSize + ", data: " + itemDataSize); } } - System.out.println("对象: " + value + ", 大小: " + size); return size; } @@ -123,4 +120,9 @@ public class ProtobufObjectEncoder extends ObjectEncoder public final boolean requireSize() { return true; } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; + } } diff --git a/src/main/java/org/redkale/convert/pb/ProtobufPrimitivable.java b/src/main/java/org/redkale/convert/pb/ProtobufPrimitivable.java index b646dd37b..aec992431 100644 --- a/src/main/java/org/redkale/convert/pb/ProtobufPrimitivable.java +++ b/src/main/java/org/redkale/convert/pb/ProtobufPrimitivable.java @@ -7,7 +7,13 @@ package org.redkale.convert.pb; /** * 只能用于基本类型， 不能用于如String的其他类型 * @author zhangjx + * @param 基本类型泛型 */ -public interface ProtobufPrimitivable { - // +public interface ProtobufPrimitivable { + + // 获取java类型分类 + public Class primitiveType(); + + // 计算内容长度 + public int computeSize(T value); } diff --git a/src/main/java/org/redkale/convert/pb/ProtobufReader.java b/src/main/java/org/redkale/convert/pb/ProtobufReader.java index 352b0b815..1e79eae08 100644 --- a/src/main/java/org/redkale/convert/pb/ProtobufReader.java +++ b/src/main/java/org/redkale/convert/pb/ProtobufReader.java @@ -7,7 +7,6 @@ package org.redkale.convert.pb; import java.nio.charset.StandardCharsets; import java.util.*; -import java.util.concurrent.atomic.*; import org.redkale.convert.*; import org.redkale.util.Creator; @@ -190,24 +189,6 @@ public class ProtobufReader extends Reader { return data; } - public final AtomicBoolean readAtomicBoolean() { - return new AtomicBoolean(readBoolean()); - } - - public final AtomicBoolean[] readAtomicBooleans() { - Collection data = readAtomicBooleans(LIS_CREATOR); - return data.toArray(new AtomicBoolean[data.size()]); - } - - public final Collection readAtomicBooleans(Creator creator) { - int size = readRawVarint32(); - Collection data = creator.create(); - for (int i = 0; i < size; i++) { - data.add(new AtomicBoolean(readBoolean())); - } - return data; - } - @Override public final byte readByte() { return (byte) readInt(); @@ -319,22 +300,6 @@ public class ProtobufReader extends Reader { return data; } - public final AtomicInteger[] readAtomicIntegers() { - Collection data = readAtomicIntegers(LIS_CREATOR); - return data.toArray(new AtomicInteger[data.size()]); - } - - public final Collection readAtomicIntegers(Creator creator) { - Collection data = creator.create(); - int len = readRawVarint32(); - while (len > 0) { - int val = readInt(); - data.add(new AtomicInteger(val)); - len -= ProtobufFactory.computeSInt32SizeNoTag(val); - } - return data; - } - @Override public final float readFloat() { return Float.intBitsToFloat(readRawLittleEndian32()); @@ -390,22 +355,6 @@ public class ProtobufReader extends Reader { return data; } - public final AtomicLong[] readAtomicLongs() { - Collection data = readAtomicLongs(LIS_CREATOR); - return data.toArray(new AtomicLong[data.size()]); - } - - public final Collection readAtomicLongs(Creator creator) { - Collection data = creator.create(); - int len = readRawVarint32(); - while (len > 0) { - long val = readLong(); - data.add(new AtomicLong(val)); - len -= ProtobufFactory.computeSInt64SizeNoTag(val); - } - return data; - } - public final String[] readStrings(int tag) { Collection data = readStrings(tag, LIS_CREATOR); return data.toArray(new String[data.size()]); @@ -428,8 +377,8 @@ public class ProtobufReader extends Reader { } public final double[] readDoubles() { - int len = readRawVarint32(); - double[] rs = new double[len / 8]; + int size = readRawVarint32(); + double[] rs = new double[size / 8]; for (int i = 0; i < rs.length; i++) { rs[i] = readDouble(); } @@ -438,8 +387,8 @@ public class ProtobufReader extends Reader { public final Collection readDoubles(Creator creator) { Collection data = creator.create(); - int len = readRawVarint32() / 8; - for (int i = 0; i < len; i++) { + int size = readRawVarint32() / 8; + for (int i = 0; i < size; i++) { data.add(readDouble()); } return data; @@ -626,14 +575,14 @@ public class ProtobufReader extends Reader { throw new ConvertException("readRawVarint64SlowPath error"); } - protected int readRawLittleEndian32() { //float + protected int readRawLittleEndian32() { // float return ((content[++this.position] & 0xff) | ((content[++this.position] & 0xff) << 8) | ((content[++this.position] & 0xff) << 16) | ((content[++this.position] & 0xff) << 24)); } - protected long readRawLittleEndian64() { //double + protected long readRawLittleEndian64() { // double return ((content[++this.position] & 0xffL) | ((content[++this.position] & 0xffL) << 8) | ((content[++this.position] & 0xffL) << 16) diff --git a/src/main/java/org/redkale/convert/pb/ProtobufStreamDecoder.java b/src/main/java/org/redkale/convert/pb/ProtobufStreamDecoder.java index 19da1cc19..45c7a4105 100644 --- a/src/main/java/org/redkale/convert/pb/ProtobufStreamDecoder.java +++ b/src/main/java/org/redkale/convert/pb/ProtobufStreamDecoder.java @@ -33,12 +33,21 @@ public class ProtobufStreamDecoder extends StreamDecoder final List result = new ArrayList(); final int limit = in.limit(); while (in.hasNext()) { + boolean nodata = false; if (!simpled) { int contentLen = in.readRawVarint32(); - in.limit(in.position() + contentLen + 1); + if (contentLen == 0) { + nodata = true; + } else { + in.limit(in.position() + contentLen + 1); + } + } + if (nodata) { + result.add(null); + } else { + result.add(itemDecoder.convertFrom(in)); + in.limit(limit); } - result.add(itemDecoder.convertFrom(in)); - in.limit(limit); if (!in.readNextTag(member)) { // 元素结束 break; } diff --git a/src/main/java/org/redkale/convert/pb/ProtobufStreamEncoder.java b/src/main/java/org/redkale/convert/pb/ProtobufStreamEncoder.java index 97ba81cd6..43d8e94f1 100644 --- a/src/main/java/org/redkale/convert/pb/ProtobufStreamEncoder.java +++ b/src/main/java/org/redkale/convert/pb/ProtobufStreamEncoder.java @@ -32,12 +32,12 @@ public class ProtobufStreamEncoder extends StreamEncoder if (array == null || array.length < 1) { return; } - ProtobufEncodeable itemEncoder = (ProtobufEncodeable)this.componentEncoder; + ProtobufEncodeable itemEncoder = (ProtobufEncodeable) this.componentEncoder; out.writeArrayB(array.length, itemEncoder, array); for (Object item : array) { out.writeField(member); if (item == null) { - out.writeUInt32(0); + out.writeLength(0); } else if (componentSimpled) { itemEncoder.convertTo(out, item); } else { @@ -58,6 +58,11 @@ public class ProtobufStreamEncoder extends StreamEncoder @Override public boolean requireSize() { - return componentSizeRequired; + return !componentSimpled; + } + + @Override + public final ProtobufTypeEnum typeEnum() { + return ProtobufTypeEnum.BYTES; } } diff --git a/src/main/java/org/redkale/convert/pb/ProtobufTypeEnum.java b/src/main/java/org/redkale/convert/pb/ProtobufTypeEnum.java new file mode 100644 index 000000000..99ba6c339 --- /dev/null +++ b/src/main/java/org/redkale/convert/pb/ProtobufTypeEnum.java @@ -0,0 +1,56 @@ +/* + * Copyright (c) 2016-2116 Redkale + * All rights reserved. + */ +package org.redkale.convert.pb; + +import java.lang.reflect.Type; +import java.util.concurrent.atomic.AtomicBoolean; +import java.util.concurrent.atomic.AtomicInteger; +import java.util.concurrent.atomic.AtomicLong; + +/** + * + * @author zhangjx + */ +public enum ProtobufTypeEnum { + // boolean/byte/char/short/int/long + INT(0), + // double + DOUBLE(1), + // float + FLOAT(5), + // byte[] + BYTES(2); + + private int value; + + private ProtobufTypeEnum(int v) { + this.value = v; + } + + public int getValue() { + return value; + } + + public static ProtobufTypeEnum valueOf(Type type, boolean enumtostring) { + if (type == double.class || type == Double.class) { + return DOUBLE; + } else if (type == float.class || type == Float.class) { + return FLOAT; + } else if ((type == boolean.class || type == Boolean.class) + || (type == byte.class || type == Byte.class) + || (type == char.class || type == Character.class) + || (type == short.class || type == Short.class) + || (type == int.class || type == Integer.class) + || (type == long.class || type == Long.class) + || (type == AtomicBoolean.class || type == AtomicInteger.class) + || type == AtomicLong.class) { + return INT; + } else if (!enumtostring && (type instanceof Class) && ((Class) type).isEnum()) { + return INT; + } else { // byte[] + return BYTES; + } + } +} diff --git a/src/main/java/org/redkale/convert/pb/ProtobufWriter.java b/src/main/java/org/redkale/convert/pb/ProtobufWriter.java index eb2d1f493..5a448e9ed 100644 --- a/src/main/java/org/redkale/convert/pb/ProtobufWriter.java +++ b/src/main/java/org/redkale/convert/pb/ProtobufWriter.java @@ -9,7 +9,6 @@ import java.lang.reflect.Type; import java.nio.ByteBuffer; import java.nio.charset.StandardCharsets; import java.util.*; -import java.util.concurrent.atomic.*; import java.util.function.*; import java.util.stream.Stream; import org.redkale.annotation.ClassDepends; @@ -73,7 +72,9 @@ public class ProtobufWriter extends Writer implements ByteTuple { private byte[] content; - private ArrayDeque childWriters; + private List children; + + private ArrayDeque pool; protected ProtobufWriter(ProtobufWriter parent) { this(); @@ -156,14 +157,20 @@ public class ProtobufWriter extends Writer implements ByteTuple { if (this.content.length > DEFAULT_SIZE) { this.content = new byte[DEFAULT_SIZE]; } + if (this.children != null) { + for (ProtobufWriter child : children) { + offerChild2(child); + } + this.children = null; + } return true; } public final ProtobufWriter pollChild() { - Queue queue = this.childWriters; + Queue queue = this.pool; if (queue == null) { - this.childWriters = new ArrayDeque<>(CHILD_SIZE); - queue = this.childWriters; + this.pool = new ArrayDeque<>(CHILD_SIZE); + queue = this.pool; } ProtobufWriter result = queue.poll(); if (result == null) { @@ -172,8 +179,33 @@ public class ProtobufWriter extends Writer implements ByteTuple { return result.configFieldFunc(this); } - public final void offerChild(final ProtobufWriter child) { - Queue queue = this.childWriters; + public void offerChild(final ProtobufWriter child) { + Queue queue = this.pool; + if (child != null && queue != null && queue.size() < CHILD_SIZE) { + child.recycle(); + queue.offer(child); + } + } + + public final ProtobufWriter createChild2() { + Queue queue = this.pool; + if (queue == null) { + this.pool = new ArrayDeque<>(CHILD_SIZE); + queue = this.pool; + } + ProtobufWriter result = queue.poll(); + if (result == null) { + result = new ProtobufWriter(); + } + if (this.children == null) { + this.children = new ArrayList<>(); + } + this.children.add(result); + return result.configFieldFunc(this); + } + + private void offerChild2(final ProtobufWriter child) { + Queue queue = this.pool; if (child != null && queue != null && queue.size() < CHILD_SIZE) { child.recycle(); queue.offer(child); @@ -182,11 +214,32 @@ public class ProtobufWriter extends Writer implements ByteTuple { @Override public final int length() { - return count; + int total = count; + if (children != null) { + for (ProtobufWriter child : children) { + int len = child.length(); + total += ProtobufFactory.computeSInt32SizeNoTag(len) + len; + } + } + return total; } @Override public byte[] content() { + if (children != null) { + byte[] data = new byte[length()]; + System.arraycopy(content, 0, data, 0, count); + int pos = count; + Utility.println("自身对象: ", content, 0, count); + for (ProtobufWriter child : children) { + int len = child.length(); + data[pos++] = (byte) len; + Utility.println("子对象: ", child.content(), 0, child.length()); + System.arraycopy(child.content(), 0, data, pos, len); + pos += len; + } + return data; + } return content; } @@ -214,6 +267,9 @@ public class ProtobufWriter extends Writer implements ByteTuple { @Override public byte[] toArray() { + if (children != null) { + return content(); + } byte[] copy = new byte[count]; System.arraycopy(content, 0, copy, 0, count); return copy; @@ -257,7 +313,7 @@ public class ProtobufWriter extends Writer implements ByteTuple { @Override public String toString() { - return this.getClass().getSimpleName() + "[count=" + this.count + "]"; + return this.getClass().getSimpleName() + "@" + Objects.hashCode(this) + "[count=" + this.count + "]"; } // ------------------------------------------------------------------------ @@ -764,100 +820,6 @@ public class ProtobufWriter extends Writer implements ByteTuple { } } - public final void writeAtomicBooleans(AtomicBoolean[] value) { - AtomicBoolean[] array = value; - if (array != null && array.length > 0) { - writeLength(array.length); - for (AtomicBoolean item : array) { - writeTo(item != null && item.get() ? (byte) 1 : (byte) 0); - } - } - } - - public final void writeAtomicBooleans(Collection value) { - Collection array = value; - if (array != null && !array.isEmpty()) { - writeLength(array.size()); - for (AtomicBoolean item : array) { - writeTo(item != null && item.get() ? (byte) 1 : (byte) 0); - } - } - } - - public final void writeAtomicBooleans(Stream value) { - if (value != null) { - writeAtomicBooleans(value.toArray(s -> new AtomicBoolean[s])); - } - } - - public final void writeAtomicIntegers(AtomicInteger[] value) { - AtomicInteger[] array = value; - if (array != null && array.length > 0) { - int len = 0; - for (AtomicInteger item : array) { - len += ProtobufFactory.computeSInt32SizeNoTag(item == null ? 0 : item.get()); - } - writeLength(len); - for (AtomicInteger item : array) { - writeInt(item == null ? 0 : item.get()); - } - } - } - - public final void writeAtomicIntegers(Collection value) { - Collection array = value; - if (array != null && !array.isEmpty()) { - int len = 0; - for (AtomicInteger item : array) { - len += ProtobufFactory.computeSInt32SizeNoTag(item == null ? 0 : item.get()); - } - writeLength(len); - for (AtomicInteger item : array) { - writeInt(item == null ? 0 : item.get()); - } - } - } - - public final void writeAtomicIntegers(Stream value) { - if (value != null) { - writeAtomicIntegers(value.toArray(s -> new AtomicInteger[s])); - } - } - - public final void writeAtomicLongs(AtomicLong[] value) { - AtomicLong[] array = value; - if (array != null && array.length > 0) { - int len = 0; - for (AtomicLong item : array) { - len += ProtobufFactory.computeSInt64SizeNoTag(item == null ? 0 : item.get()); - } - writeLength(len); - for (AtomicLong item : array) { - writeLong(item == null ? 0 : item.get()); - } - } - } - - public final void writeAtomicLongs(Collection value) { - Collection array = value; - if (array != null && !array.isEmpty()) { - int len = 0; - for (AtomicLong item : array) { - len += ProtobufFactory.computeSInt64SizeNoTag(item == null ? 0 : item.get()); - } - writeLength(len); - for (AtomicLong item : array) { - writeLong(item == null ? 0 : item.get()); - } - } - } - - public final void writeAtomicLongs(Stream value) { - if (value != null) { - writeAtomicLongs(value.toArray(s -> new AtomicLong[s])); - } - } - @Override public final void writeWrapper(StringWrapper value) { if (value != null) { @@ -993,30 +955,6 @@ public class ProtobufWriter extends Writer implements ByteTuple { } } - @ClassDepends - public final void writeFieldValue(int tag, AtomicBoolean value) { - if (value != null && value.get()) { - writeTag(tag); - writeBoolean(value.get()); - } - } - - @ClassDepends - public final void writeFieldValue(int tag, AtomicInteger value) { - if (value != null && value.get() != 0) { - writeTag(tag); - writeInt(value.get()); - } - } - - @ClassDepends - public final void writeFieldValue(int tag, AtomicLong value) { - if (value != null && value.get() != 0) { - writeTag(tag); - writeLong(value.get()); - } - } - @ClassDepends public final void writeFieldValue(int tag, boolean[] value) { if (value != null && value.length > 0) { @@ -1145,30 +1083,6 @@ public class ProtobufWriter extends Writer implements ByteTuple { } } - @ClassDepends - public final void writeFieldValue(int tag, AtomicBoolean[] value) { - if (value != null && value.length > 0) { - writeTag(tag); - writeAtomicBooleans(value); - } - } - - @ClassDepends - public final void writeFieldValue(int tag, AtomicInteger[] value) { - if (value != null && value.length > 0) { - writeTag(tag); - writeAtomicIntegers(value); - } - } - - @ClassDepends - public final void writeFieldValue(int tag, AtomicLong[] value) { - if (value != null && value.length > 0) { - writeTag(tag); - writeAtomicLongs(value); - } - } - @ClassDepends public final void writeFieldValue(int tag, String[] value) { if (value != null && value.length > 0) { @@ -1240,30 +1154,6 @@ public class ProtobufWriter extends Writer implements ByteTuple { } } - @ClassDepends - public final void writeFieldAtomicBooleansValue(int tag, Collection value) { - if (value != null && !value.isEmpty()) { - writeTag(tag); - writeAtomicBooleans(value); - } - } - - @ClassDepends - public final void writeFieldAtomicIntegersValue(int tag, Collection value) { - if (value != null && !value.isEmpty()) { - writeTag(tag); - writeAtomicIntegers(value); - } - } - - @ClassDepends - public final void writeFieldAtomicLongsValue(int tag, Collection value) { - if (value != null && !value.isEmpty()) { - writeTag(tag); - writeAtomicLongs(value); - } - } - @ClassDepends public final void writeFieldStringsValue(int tag, Collection value) { if (value != null && !value.isEmpty()) { diff --git a/src/test/java/org/redkale/test/convert/pb/RequiredBeanTest.java b/src/test/java/org/redkale/test/convert/pb/RequiredBeanTest.java index 1250a8e8d..c86e8d47a 100644 --- a/src/test/java/org/redkale/test/convert/pb/RequiredBeanTest.java +++ b/src/test/java/org/redkale/test/convert/pb/RequiredBeanTest.java @@ -33,10 +33,15 @@ public class RequiredBeanTest { + "0x1a,0x03,0x63,0x63,0x63,0x1a,0x03,0x64,0x64,0x64,0x22,0x02,0x02,0x04]"); Utility.println("序列化0: ", bytes); RequiredArray array = new RequiredArray(); - array.beans = new RequiredBean[] {bean}; + array.id = 32; + array.beans = new RequiredBean[] {bean, null, bean}; byte[] bytes2 = convert.convertTo(array); - System.out.println("序列化s: 29.[0x1f,0x0a,0x1a,0x08,0x0c,0x12,0x03,0x61,0x61,0x61,0x12,0x03,0x62,0x62,0x62," - + "0x1a,0x03,0x63,0x63,0x63,0x1a,0x03,0x64,0x64,0x64,0x22,0x02,0x02,0x04]"); + System.out.println("序列化s: 60.[0x0a,0x1a,0x08,0x0c,0x12,0x03,0x61,0x61,0x61,0x12,0x03,0x62,0x62,0x62," + + "0x1a,0x03,0x63,0x63,0x63,0x1a,0x03,0x64,0x64,0x64,0x22,0x02,0x02,0x04," + + "0x0a,0x00," + + "0x0a,0x1a,0x08,0x0c,0x12,0x03,0x61,0x61,0x61,0x12,0x03,0x62,0x62,0x62," + + "0x1a,0x03,0x63,0x63,0x63,0x1a,0x03,0x64,0x64,0x64,0x22,0x02,0x02,0x04," + + "0x10,0x40]"); Utility.println("序列化s: ", bytes2); System.out.println("-----------------------------------------------"); String jsons1 = JsonConvert.root().convertTo(array); @@ -51,6 +56,9 @@ public class RequiredBeanTest { @ConvertColumn(index = 1) private RequiredBean[] beans; + @ConvertColumn(index = 2) + private int id; + public RequiredBean[] getBeans() { return beans; } @@ -58,6 +66,14 @@ public class RequiredBeanTest { public void setBeans(RequiredBean[] beans) { this.beans = beans; } + + public int getId() { + return id; + } + + public void setId(int id) { + this.id = id; + } } public static class RequiredBean { diff --git a/src/test/java/org/redkale/test/convert/pb/UserBean.java b/src/test/java/org/redkale/test/convert/pb/UserBean.java index 38cc6f382..14d9afe60 100644 --- a/src/test/java/org/redkale/test/convert/pb/UserBean.java +++ b/src/test/java/org/redkale/test/convert/pb/UserBean.java @@ -7,7 +7,6 @@ package org.redkale.test.convert.pb; import java.math.BigDecimal; import java.math.BigInteger; import java.util.List; -import java.util.Map; import java.util.Set; import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.atomic.AtomicLong; @@ -142,28 +141,17 @@ public class UserBean { private List bit6; @ConvertColumn(index = 41) - private Map map; - - @ConvertColumn(index = 42) public UserKind kind; - @ConvertColumn(index = 43) + @ConvertColumn(index = 42) public AtomicInteger count; - @ConvertColumn(index = 44) + @ConvertColumn(index = 43) public AtomicLong[] count2; - @ConvertColumn(index = 45) + @ConvertColumn(index = 44) private List strs; - public Map getMap() { - return map; - } - - public void setMap(Map map) { - this.map = map; - } - public List getId6() { return id6; } diff --git a/src/test/java/org/redkale/test/convert/pb/UserBeanProtoDynEncoder.java b/src/test/java/org/redkale/test/convert/pb/UserBeanProtoDynEncoder.java index f86e188d5..c1a041cc3 100644 --- a/src/test/java/org/redkale/test/convert/pb/UserBeanProtoDynEncoder.java +++ b/src/test/java/org/redkale/test/convert/pb/UserBeanProtoDynEncoder.java @@ -78,10 +78,6 @@ public class UserBeanProtoDynEncoder extends ProtobufDynEncoder { out.writeFieldBytesValue(23, value.getBit6()); out.writeFieldStringsValue(23, value.getStrs()); - out.writeFieldValue(100, value.kind); - out.writeFieldValue(101, value.count); - out.writeFieldValue(102, value.count2); - out.writeObjectField(mapEnMember, value); out.writeObjectE(value); offerWriter(out0, out);