Generated MediaFuryCodec serializer code for jvm-serializers data

MediaFuryCodec.java

package data.media;

import java.util.List;
import java.util.Map;
import java.util.Set;
import io.fury.Fury;
import io.fury.memory.MemoryBuffer;
import io.fury.resolver.NoRefResolver;
import io.fury.resolver.ClassInfo;
import io.fury.resolver.ClassInfoHolder;
import io.fury.resolver.ClassResolver;
import io.fury.builder.Generated;
import io.fury.serializer.CodegenSerializer.LazyInitBeanSerializer;
import io.fury.serializer.Serializers.EnumSerializer;
import io.fury.serializer.Serializer;
import io.fury.serializer.StringSerializer;
import io.fury.serializer.ObjectSerializer;
import io.fury.serializer.CompatibleSerializer;
import io.fury.serializer.CollectionSerializers.CollectionSerializer;
import io.fury.serializer.MapSerializers.MapSerializer;
import io.fury.builder.Generated.GeneratedObjectSerializer;

public final class MediaFuryCodec_1137563540 extends GeneratedObjectSerializer {

  private final NoRefResolver refResolver;
  private final ClassResolver classResolver;
  private final StringSerializer strSerializer;
  private final Fury fury;
  private final EnumSerializer enumSerializer;
  private ClassInfo listClassInfo;
  private final ClassInfoHolder list1ClassInfoHolder;

  public MediaFuryCodec_1137563540(Fury fury, Class classType) {
      super(fury, classType);
      this.fury = fury;
      fury.getClassResolver().setSerializerIfAbsent(classType, this);
  
      io.fury.resolver.RefResolver refResolver0 = fury.getRefResolver();
      refResolver = ((NoRefResolver)refResolver0);
      classResolver = fury.getClassResolver();
      strSerializer = fury.getStringSerializer();
      enumSerializer = ((EnumSerializer)classResolver.getRawSerializer(data.media.Media.Player.class));
      listClassInfo = classResolver.nilClassInfo();
      list1ClassInfoHolder = classResolver.nilClassInfoHolder();
  }

  private void writeFields(data.media.Media media1, MemoryBuffer memoryBuffer, byte[] arr) {
      long writerAddr = memoryBuffer.getUnsafeWriterAddress();
      MemoryBuffer.unsafePutBoolean(arr, writerAddr, media1.hasBitrate);
      memoryBuffer.increaseWriterIndexUnsafe(1);
      memoryBuffer.unsafeWriteSliLong(media1.duration);
      memoryBuffer.unsafeWriteSliLong(media1.size);
      memoryBuffer.unsafeWriteVarInt(media1.bitrate);
      memoryBuffer.unsafeWriteVarInt(media1.height);
      memoryBuffer.unsafeWriteVarInt(media1.width);
  }

  private void writeFields1(MemoryBuffer memoryBuffer1, data.media.Media media2) {
      StringSerializer strSerializer = this.strSerializer;
      data.media.Media.Player player = media2.player;
      if ((player == null)) {
          memoryBuffer1.writeByte(((byte)-3));
      } else {
          memoryBuffer1.writeByte(((byte)0));
          enumSerializer.write(memoryBuffer1, player);
      }
      java.lang.String copyright = media2.copyright;
      if ((copyright == null)) {
          memoryBuffer1.writeByte(((byte)-3));
      } else {
          memoryBuffer1.writeByte(((byte)0));
          strSerializer.writeJava8StringCompressed(memoryBuffer1, copyright);
      }
      java.lang.String format = media2.format;
      if ((format == null)) {
          memoryBuffer1.writeByte(((byte)-3));
      } else {
          memoryBuffer1.writeByte(((byte)0));
          strSerializer.writeJava8StringCompressed(memoryBuffer1, format);
      }
      java.lang.String title = media2.title;
      if ((title == null)) {
          memoryBuffer1.writeByte(((byte)-3));
      } else {
          memoryBuffer1.writeByte(((byte)0));
          strSerializer.writeJava8StringCompressed(memoryBuffer1, title);
      }
      java.lang.String uri = media2.uri;
      if ((uri == null)) {
          memoryBuffer1.writeByte(((byte)-3));
      } else {
          memoryBuffer1.writeByte(((byte)0));
          strSerializer.writeJava8StringCompressed(memoryBuffer1, uri);
      }
  }

  private CollectionSerializer writeCollectionClassInfo(MemoryBuffer memoryBuffer2, List list) {
      ClassResolver classResolver = this.classResolver;
      Class value0 = listClassInfo.getCls();
      Class cls = list.getClass();
      if ((value0 != cls)) {
          listClassInfo = classResolver.getClassInfo(cls);
      }
      short value1 = listClassInfo.getClassId();
      if ((value1 == ((short)0))) {
          memoryBuffer2.writeByte(((byte)1));
          classResolver.writeEnumStringBytes(memoryBuffer2, listClassInfo.getPackageNameBytes());
          classResolver.writeEnumStringBytes(memoryBuffer2, listClassInfo.getClassNameBytes());
      } else {
          memoryBuffer2.writePositiveVarInt((value1 << 1));
      }
      Serializer serializer = listClassInfo.getSerializer();
      return ((CollectionSerializer)serializer);
  }

  private void writeFields2(MemoryBuffer memoryBuffer3, data.media.Media media3) {
      StringSerializer strSerializer = this.strSerializer;
      java.util.List persons = media3.persons;
      if ((persons == null)) {
          memoryBuffer3.writeByte(((byte)-3));
      } else {
          memoryBuffer3.writeByte(((byte)0));
          CollectionSerializer collectionSerializer = this.writeCollectionClassInfo(memoryBuffer3, persons);
          if (collectionSerializer.supportCodegenHook()) {
              int value2 = persons.size();
              memoryBuffer3.writePositiveVarInt(value2);
              collectionSerializer.writeHeader(memoryBuffer3, persons);
              if ((value2 > 0)) {
                  int value3 = collectionSerializer.writeNullabilityHeader(memoryBuffer3, persons);
                  boolean hasNull = (value3 & 2) == 2;
                  for (int i = 0; i < value2; i+=1) {
                    Object object = persons.get(i);
                    String castedValue = (String)object;
                    if (hasNull) {
                        if ((castedValue == null)) {
                            memoryBuffer3.writeByte(((byte)-3));
                        } else {
                            memoryBuffer3.writeByte(((byte)0));
                            strSerializer.writeJava8StringCompressed(memoryBuffer3, castedValue);
                        }
                    } else {
                        strSerializer.writeJava8StringCompressed(memoryBuffer3, castedValue);
                    }
                  }
              }
          } else {
              collectionSerializer.write(memoryBuffer3, persons);
          }
      }
  }

  private void readFields(data.media.Media media4, MemoryBuffer memoryBuffer4, byte[] arr1) {
      long readerAddr = memoryBuffer4.getUnsafeReaderAddress();
      media4.hasBitrate = MemoryBuffer.unsafeGetBoolean(arr1, readerAddr);
      memoryBuffer4.increaseReaderIndexUnsafe(1);
      media4.duration = memoryBuffer4.readSliLong();
      media4.size = memoryBuffer4.readSliLong();
      media4.bitrate = memoryBuffer4.readVarInt();
      media4.height = memoryBuffer4.readVarInt();
      media4.width = memoryBuffer4.readVarInt();
  }

  private void readFields1(data.media.Media media5, MemoryBuffer memoryBuffer5) {
      StringSerializer strSerializer = this.strSerializer;
      if ((memoryBuffer5.readByte() != ((byte)-3))) {
          Enum value4 = enumSerializer.read(memoryBuffer5);
          media5.player = ((data.media.Media.Player)value4);
      } else {
          media5.player = null;
      }
      if ((memoryBuffer5.readByte() != ((byte)-3))) {
          media5.copyright = strSerializer.readJava8CompressedString(memoryBuffer5);
      } else {
          media5.copyright = null;
      }
      if ((memoryBuffer5.readByte() != ((byte)-3))) {
          media5.format = strSerializer.readJava8CompressedString(memoryBuffer5);
      } else {
          media5.format = null;
      }
      if ((memoryBuffer5.readByte() != ((byte)-3))) {
          media5.title = strSerializer.readJava8CompressedString(memoryBuffer5);
      } else {
          media5.title = null;
      }
      if ((memoryBuffer5.readByte() != ((byte)-3))) {
          media5.uri = strSerializer.readJava8CompressedString(memoryBuffer5);
      } else {
          media5.uri = null;
      }
  }

  private void readFields2(data.media.Media media6, MemoryBuffer memoryBuffer6) {
      StringSerializer strSerializer = this.strSerializer;
      if ((memoryBuffer6.readByte() != ((byte)-3))) {
          Serializer serializer0 = classResolver.readClassInfo(memoryBuffer6, list1ClassInfoHolder).getSerializer();
          CollectionSerializer collectionSerializer0 = (CollectionSerializer)serializer0;
          java.util.Collection collection3;
          if (collectionSerializer0.supportCodegenHook()) {
              int size0 = memoryBuffer6.readPositiveVarInt();
              java.util.Collection collection = collectionSerializer0.newCollection(memoryBuffer6, size0);
              if ((size0 > 0)) {
                  int flags = memoryBuffer6.readByte();
                  boolean hasNull0 = (flags & 2) == 2;
                  for (int i0 = 0; i0 < size0; i0+=1) {
                    if (hasNull0) {
                        if ((memoryBuffer6.readByte() != ((byte)-3))) {
                            String string = strSerializer.readJava8CompressedString(memoryBuffer6);
                            collection.add(string);
                        } else {
                            collection.add(null);
                        }
                    } else {
                        String string1 = strSerializer.readJava8CompressedString(memoryBuffer6);
                        collection.add(string1);
                    }
                  }
              }
              java.util.Collection collection1 = collectionSerializer0.onCollectionRead(collection);
              collection3 = collection1;
          } else {
              java.util.Collection collection2 = collectionSerializer0.read(memoryBuffer6);
              collection3 = collection2;
          }
          
          media6.persons = ((List)collection3);
      } else {
          media6.persons = null;
      }
  }

  @Override public final void write(MemoryBuffer buffer, Object obj) {
      data.media.Media media7 = (data.media.Media)obj;
      buffer.grow(43);
      byte[] base = buffer.getHeapMemory();
      this.writeFields(media7, buffer, base);
      this.writeFields1(buffer, media7);
      this.writeFields2(buffer, media7);
  }

  @Override public final Object read(MemoryBuffer buffer) {
      data.media.Media media8 = new data.media.Media();
      refResolver.reference(media8);
      byte[] heapBuffer = buffer.getHeapMemory();
      buffer.checkReadableBytes(1);
      this.readFields(media8, buffer, heapBuffer);
      this.readFields1(media8, buffer);
      this.readFields2(media8, buffer);
      return media8;
  }

}