public static ArrayEncoder arrayEncoder()

in java/fury-format/src/main/java/org/apache/fury/format/encoder/Encoders.java [314:391]
69 lines of code
2 McCabe index (conditional complexity)

  public static <T extends Collection, B> ArrayEncoder<T> arrayEncoder(
      TypeRef<? extends Collection> arrayToken,
      TypeRef<B> elementType,
      BinaryArrayWriter writer,
      Fury fury) {
    Field field = writer.getField();
    try {
      Class<?> rowCodecClass = loadOrGenArrayCodecClass(arrayToken, elementType);
      Object references = new Object[] {field, writer, fury};
      GeneratedArrayEncoder codec =
          rowCodecClass
              .asSubclass(GeneratedArrayEncoder.class)
              .getConstructor(Object[].class)
              .newInstance(references);

      return new ArrayEncoder<T>() {

        @Override
        public Field field() {
          return field;
        }

        @SuppressWarnings("unchecked")
        @Override
        public T fromArray(BinaryArray array) {
          return (T) codec.fromArray(array);
        }

        @Override
        public BinaryArray toArray(T obj) {
          return codec.toArray(obj);
        }

        @Override
        public T decode(MemoryBuffer buffer) {
          return decode(buffer, buffer.readInt32());
        }

        public T decode(MemoryBuffer buffer, int size) {
          BinaryArray array = new BinaryArray(field);
          int readerIndex = buffer.readerIndex();
          array.pointTo(buffer, readerIndex, size);
          buffer.readerIndex(readerIndex + size);
          return fromArray(array);
        }

        @Override
        public T decode(byte[] bytes) {
          return decode(MemoryUtils.wrap(bytes), bytes.length);
        }

        @Override
        public byte[] encode(T obj) {
          BinaryArray array = toArray(obj);
          return writer.getBuffer().getBytes(0, 8 + array.getSizeInBytes());
        }

        @Override
        public void encode(MemoryBuffer buffer, T obj) {
          MemoryBuffer prevBuffer = writer.getBuffer();
          int writerIndex = buffer.writerIndex();
          buffer.writeInt32(-1);
          try {
            writer.setBuffer(buffer);
            BinaryArray array = toArray(obj);
            int size = buffer.writerIndex() - writerIndex - 4;
            assert size == array.getSizeInBytes();
            buffer.putInt32(writerIndex, size);
          } finally {
            writer.setBuffer(prevBuffer);
          }
        }
      };
    } catch (Exception e) {
      String msg = String.format("Create encoder failed, \nelementType: %s", elementType);
      throw new EncoderException(msg, e);
    }
  }