persolijn

ProtobufWriter.java (15470B)

---

 package protobuf;
 
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
 import java.util.Iterator;
 import java.util.function.BinaryOperator;
 import java.util.function.Consumer;
 import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.function.UnaryOperator;
 
 import protobuf.exception.InputException;
 import protobuf.exception.OverflowException;
 import protobuf.exception.UnexpectedTagException;
 import protobuf.exception.WireTypeException;
 
 /**
  * Represents an interface for parsing Protobuf wire elements, providing methods
  * for reading various Protobuf data types.
  */
 public class ProtobufWriter {
     private final MessageIterator message;
     private final WireType type;
     private final int tag;
     private boolean resetType = false;
 
     public ProtobufReader(MessageIterator message, WireType type, int tag) {
         this.message = message;
         this.type = type;
         this.tag = tag;
     }
 
     /**
      * Gets the underlying input stream.
      *
      * @return The input stream.
      */
     public InputStream getInputStream() {
         return message.input;
     }
 
     /**
      * Gets the Protobuf wire type.
      *
      * @return The wire type.
      */
     public WireType getType() {
         return resetType ? null : type;
     }
 
     /**
      * Resets the Protobuf wire type.
      * Useful for parsing packed streams.
      */
     public void resetType() {
         resetType = true;
     }
 
     /**
      * Gets the tag associated with the wire element.
      *
      * @return The wire tag.
      */
     public int tag() {
         return tag;
     }
 
     /**
      * Reads a signed variable-length integer as a 64-bit integer.
      *
      * @return The parsed signed 64-bit integer.
      */
     public long svarint64() {
         long n = varint64();
         return (n & 0x01) == 0
                 ? (n >> 1)
                 : -(n >> 1) - 1;
     }
 
     /**
      * Parses a variable-length integer as a signed 64-bit integer.
      *
      * @return The parsed signed 64-bit integer.
      */
     public long varint64() {
         return varint64(false);
     }
 
     /**
      * Reads a signed variable-length integer as a 32-bit integer.
      *
      * @return The parsed signed 32-bit integer.
      */
     public long varint64(boolean ignoreType) {
         if (!ignoreType && getType() != null && getType() != WireType.VARINT)
             throw new WireTypeException(WireType.VARINT, getType());
 
         long result = 0;
         long b = 0;
         int shift = 0;
         while (shift < 64 && message.length > 0) {
             try {
                 b = message.input.read();
             } catch (IOException exc) {
                 throw new InputException(exc);
             }
             if (b == -1)
                 break;
 
             message.length--;
 
             result |= (b & 0x7f) << shift;
             shift += 7;
             if ((b & 0x80) == 0)
                 return result;
         }
 
         throw new OverflowException("input exceed");
     }
 
     public long svarint32() {
         int n = varint32();
         return (n & 0x01) == 0
                 ? (n >> 1)
                 : -(n >> 1);
 
     }
 
     /**
      * Parses a variable-length integer as a signed 32-bit integer.
      *
      * @return The parsed signed 32-bit integer.
      */
     public int varint32() {
         return varint32(false);
     }
 
     private int varint32(boolean ignoreType) {
         if (!ignoreType && getType() != null && getType() != WireType.VARINT)
             throw new WireTypeException(WireType.VARINT, getType());
 
         int result = 0;
         int b = 0;
         int shift = 0;
         while (shift < 32 && message.length > 0) {
             try {
                 b = message.input.read();
             } catch (IOException exc) {
                 throw new InputException(exc);
             }
             if (b == -1)
                 break;
 
             message.length--;
 
             result |= (b & 0x7f) << shift;
             shift += 7;
             if ((b & 0x80) == 0)
                 return result;
         }
         throw new OverflowException("input exceed");
     }
 
     /**
      * Skips the variable-length integer.
      */
     public void skipVarint() {
         if (getType() != null && getType() != WireType.VARINT)
             throw new WireTypeException(WireType.VARINT, getType());
 
         int b = 0;
         while (message.length > 0) {
             try {
                 b = message.input.read();
             } catch (IOException exc) {
                 throw new InputException(exc);
             }
             if (b == -1)
                 break;
 
             message.length--;
             if ((b & 0x80) == 0)
                 return;
         }
         throw new OverflowException("input exceed");
     }
 
     /**
      * Reads a fixed 64-bit integer.
      *
      * @return The parsed 64-bit integer.
      */
     public long fixed64() {
         if (getType() != null && getType() != WireType.I64)
             throw new WireTypeException(WireType.I64, getType());
 
         if (message.length < 8)
             throw new OverflowException("input exceed");
 
         byte[] bytes;
         try {
             bytes = message.input.readNBytes(8);
         } catch (IOException exc) {
             throw new InputException(exc);
         }
         long result = 0;
 
         for (int i = bytes.length - 1; i >= 0; i--) {
             result <<= 8;
             result |= bytes[i];
         }
 
         return result;
     }
 
     /**
      * Skips a fixed 64-bit integer.
      */
     public void skip64() {
         if (getType() != null && getType() != WireType.I64)
             throw new WireTypeException(WireType.I64, getType());
 
         if (message.length < 8)
             throw new OverflowException("input exceed");
 
         message.length -= 8;
         try {
             message.input.skipNBytes(8);
         } catch (IOException exc) {
             throw new InputException(exc);
         }
     }
 
     /**
      * Reads a fixed 32-bit integer.
      *
      * @return The parsed 32-bit integer.
      */
     public int fixed32() {
         if (getType() != null && getType() != WireType.I32)
             throw new WireTypeException(WireType.I32, getType());
 
         if (message.length < 4)
             throw new OverflowException("input exceed");
 
         byte[] bytes;
         try {
             bytes = message.input.readNBytes(4);
         } catch (IOException exc) {
             throw new InputException(exc);
         }
         int result = 0;
 
         for (int i = bytes.length - 1; i >= 0; i--) {
             result <<= 8;
             result |= bytes[i];
         }
 
         return result;
     }
 
     /**
      * Skips a fixed 32-bit integer.
      */
     public void skip32() {
         if (getType() != null && getType() != WireType.I32)
             throw new WireTypeException(WireType.I32, getType());
 
         if (message.length < 4)
             throw new OverflowException("input exceed");
 
         message.length -= 4;
         try {
             message.input.skipNBytes(4);
         } catch (IOException exc) {
             throw new InputException(exc);
         }
     }
 
     /**
      * Reads a byte array.
      *
      * @return The read byte array.
      */
     public byte[] bytes() {
         if (getType() != null && getType() != WireType.LEN)
             throw new WireTypeException(WireType.LEN, getType());
 
         int len = varint32(true);
         if (message.length < len)
             throw new OverflowException("input exceed");
 
         message.length -= len;
         try {
             return message.input.readNBytes(len);
         } catch (IOException exc) {
             throw new InputException(exc);
         }
     }
 
     /**
      * Skips a byte array.
      */
     public void skipBytes() {
         if (getType() != null && getType() != WireType.LEN)
             throw new WireTypeException(WireType.LEN, getType());
 
         int len = varint32(true);
         if (message.length < len)
             throw new OverflowException("input exceed");
 
         message.length -= len;
         try {
             message.input.skipNBytes(len);
         } catch (IOException exc) {
             throw new InputException(exc);
         }
     }
 
     /**
      * Reads a string.
      *
      * @return The read string.
      */
     public String string() {
         return new String(bytes(), StandardCharsets.UTF_8);
     }
 
     /**
      * Reads a message using the provided handler.
      *
      * @param handler The message handler.
      * @param <T>     The type of the parsed message.
      * @return The parsed message.
      */
     public <T> T message(Message<T> handler) {
         if (getType() != null && getType() != WireType.LEN)
             throw new WireTypeException(WireType.LEN, getType());
 
         int len = varint32(true);
         if (message.length < len)
             throw new OverflowException("input exceed");
 
         message.length -= len;
 
         return handler.parse(message.input, len);
     }
 
     /**
      * Reads a message using the provided handler and applies a mapping function to
      * the byte array.
      *
      * @param handler The message handler.
      * @param map     The mapping function for the byte array.
      * @param <T>     The type of the parsed message.
      * @return The parsed message.
      */
     public <T> T message(Message<T> handler, UnaryOperator<byte[]> map) {
         byte[] buffer = bytes();
         return handler.parse(map.apply(buffer));
     }
 
     /**
      * Creates an iterator for packed values.
      *
      * @param scalar The scalar supplier.
      * @param <T>    The type of the scalar values.
      * @return The iterator for packed values.
      */
     public <T> Iterator<T> packed(Supplier<T> scalar) {
         return packed(scalar, v -> v);
     }
 
     /**
      * Creates an iterator for packed values, applying a mapping function to each
      * scalar value.
      *
      * @param scalar The scalar supplier.
      * @param map    The mapping function for scalar values.
      * @param <T>    The type of the scalar values.
      * @param <M>    The type of the mapped values.
      * @return The iterator for packed values.
      */
     public <T, M> Iterator<M> packed(Supplier<T> scalar, Function<T, M> map) {
         if (getType() != null && getType() != WireType.LEN)
             throw new WireTypeException(WireType.LEN, getType());
 
         int len = varint32(true);
         if (message.length < len)
             throw new OverflowException("input exceed");
 
         int end = message.length - len;
 
         resetType();
 
         return new Iterator<>() {
             public boolean hasNext() {
                 if (message.length < end)
                     throw new OverflowException("packed string overused");
                 return message.length > end;
             }
 
             public M next() {
                 return map.apply(scalar.get());
             }
         };
     }
 
     /**
      * Creates an iterator for packed values with an initial value and a binary
      * operator.
      *
      * @param scalar   The scalar supplier.
      * @param init     The initial value.
      * @param operator The binary operator.
      * @param <T>      The type of the scalar values.
      * @return The iterator for packed values.
      */
     public <T> Iterator<T> packed(Supplier<T> scalar, T init, BinaryOperator<T> operator) {
         return packed(scalar, v -> v, init, operator);
     }
 
     /**
      * Creates an iterator for packed values with an initial value, a binary
      * operator, and a mapping function.
      *
      * @param scalar   The scalar supplier.
      * @param map      The mapping function for scalar values.
      * @param init     The initial value.
      * @param operator The binary operator.
      * @param <T>      The type of the scalar values.
      * @param <M>      The type of the mapped values.
      * @return The iterator for packed values.
      */
     public <T, M> Iterator<M> packed(Supplier<T> scalar, Function<T, M> map, M init, BinaryOperator<M> operator) {
         if (getType() != null && getType() != WireType.LEN)
             throw new WireTypeException(WireType.LEN, getType());
 
         int len = varint32(true);
         if (message.length < len)
             throw new OverflowException("input exceed");
 
         int end = message.length - len;
 
         resetType();
 
         return new Iterator<>() {
             M value = init;
 
             public boolean hasNext() {
                 if (message.length < end)
                     throw new OverflowException("packed string overused");
                 return message.length > end;
             }
 
             public M next() {
                 return value = operator.apply(value, map.apply(scalar.get()));
             }
         };
     }
 
     /**
      * Defers the execution of a consumer with a supplied value.
      *
      * @param supplier The value supplier.
      * @param defer    The consumer to be deferred.
      * @param <T>      The type of the supplied value.
      */
     public <T> void delayed(Supplier<T> supplier, Consumer<T> defer) {
         T buffer = supplier.get();
         message.delayed.add(() -> defer.accept(buffer));
     }
 
     /**
      * Defers the execution of a consumer with a mapped supplied value.
      *
      * @param supplier The value supplier.
      * @param map      The mapping function for the supplied value.
      * @param defer    The consumer to be deferred.
      * @param <T>      The type of the supplied value.
      */
     public <T> void delayed(Supplier<T> supplier, UnaryOperator<T> map, Consumer<T> defer) {
         T buffer = supplier.get();
         message.delayed.add(() -> defer.accept(map.apply(buffer)));
     }
 
     /**
      * Defers the execution of a consumer with a parsed message using the provided
      * handler.
      *
      * @param handler The message handler.
      * @param defer   The consumer to be deferred.
      * @param <T>     The type of the parsed message.
      */
     public <T> void delayed(Message<T> handler, Consumer<T> defer) {
         byte[] buffer = bytes();
         message.delayed.add(() -> defer.accept(handler.parse(buffer)));
     }
 
     /**
      * Defers the execution of a consumer with a mapped parsed message using the
      * provided handler.
      *
      * @param handler The message handler.
      * @param map     The mapping function for the parsed message.
      * @param defer   The consumer to be deferred.
      * @param <T>     The type of the parsed message.
      */
     public <T> void delayed(Message<T> handler, UnaryOperator<byte[]> map, Consumer<T> defer) {
         byte[] buffer = bytes();
         message.delayed.add(() -> defer.accept(handler.parse(map.apply(buffer))));
     }
 
     /**
      * Skips the current wire element based on its type.
      */
     public void skip() {
         switch (getType()) {
             case VARINT:
                 skipVarint();
                 break;
             case I64:
                 skip64();
                 break;
             case LEN:
                 skipBytes();
                 break;
             case I32:
                 skip32();
                 break;
             case SGROUP:
             case EGROUP:
                 throw new UnsupportedOperationException("cannot skip sgroup of egroup");
         }
     }
 
     /**
      * Throws an {@link UnexpectedTagException} for the current tag.
      */
     public void throwUnexpected() {
         throw new UnexpectedTagException(tag);
     }
 }
 }