Generated MediaContentFuryCodec serializer code for jvm-serializers data

MediaContentFuryCodec.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 MediaContentFuryCodec_1137563540 extends GeneratedObjectSerializer {

  private final NoRefResolver refResolver;
  private final ClassResolver classResolver;
  private final StringSerializer strSerializer;
  private final Fury fury;
  private ClassInfo mediaClassInfo;
  private ClassInfo listClassInfo;
  private final ClassInfoHolder imageClassInfoHolder;
  private final Serializer serializer0;
  private ClassInfo imageClassInfo;
  private final ClassInfoHolder media1ClassInfoHolder;
  private final ClassInfoHolder list2ClassInfoHolder;
  private final ClassInfoHolder image3ClassInfoHolder;

  public MediaContentFuryCodec_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();
      mediaClassInfo = classResolver.nilClassInfo();
      listClassInfo = classResolver.nilClassInfo();
      imageClassInfoHolder = classResolver.nilClassInfoHolder();
      serializer0 = classResolver.getRawSerializer(data.media.Image.class);
      imageClassInfo = classResolver.nilClassInfo();
      media1ClassInfoHolder = classResolver.nilClassInfoHolder();
      list2ClassInfoHolder = classResolver.nilClassInfoHolder();
      image3ClassInfoHolder = classResolver.nilClassInfoHolder();
  }

  private void writeClassAndObject(MemoryBuffer memoryBuffer, data.media.Media media) {
      ClassResolver classResolver = this.classResolver;
      Class value = mediaClassInfo.getCls();
      Class cls = media.getClass();
      if ((value != cls)) {
          mediaClassInfo = classResolver.getClassInfo(cls);
      }
      short value1 = mediaClassInfo.getClassId();
      if ((value1 == ((short)0))) {
          memoryBuffer.writeByte(((byte)1));
          classResolver.writeEnumStringBytes(memoryBuffer, mediaClassInfo.getPackageNameBytes());
          classResolver.writeEnumStringBytes(memoryBuffer, mediaClassInfo.getClassNameBytes());
      } else {
          memoryBuffer.writePositiveVarInt((value1 << 1));
      }
      mediaClassInfo.getSerializer().write(memoryBuffer, media);
  }

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

  private void sameElementClassWrite(int value3, boolean value4, int value5, MemoryBuffer memoryBuffer2, List list1) {
      boolean isDeclType = (value5 & 4) != 4;
      Serializer serializer1;
      if (isDeclType) {
          serializer1 = serializer0;
      } else {
          serializer1 = imageClassInfoHolder.getSerializer();
      }
      for (int i = 0; i < value3; i+=1) {
        Object object = list1.get(i);
        data.media.Image castedValue = (data.media.Image)object;
        if (value4) {
            if ((castedValue == null)) {
                memoryBuffer2.writeByte(((byte)-3));
            } else {
                memoryBuffer2.writeByte(((byte)0));
                serializer1.write(memoryBuffer2, castedValue);
            }
        } else {
            serializer1.write(memoryBuffer2, castedValue);
        }
      }
  }

  private void writeClassAndObject1(MemoryBuffer memoryBuffer4, data.media.Image image1) {
      ClassResolver classResolver = this.classResolver;
      Class value8 = imageClassInfo.getCls();
      Class cls1 = image1.getClass();
      if ((value8 != cls1)) {
          imageClassInfo = classResolver.getClassInfo(cls1);
      }
      short value9 = imageClassInfo.getClassId();
      if ((value9 == ((short)0))) {
          memoryBuffer4.writeByte(((byte)1));
          classResolver.writeEnumStringBytes(memoryBuffer4, imageClassInfo.getPackageNameBytes());
          classResolver.writeEnumStringBytes(memoryBuffer4, imageClassInfo.getClassNameBytes());
      } else {
          memoryBuffer4.writePositiveVarInt((value9 << 1));
      }
      imageClassInfo.getSerializer().write(memoryBuffer4, image1);
  }

  private void writeClassAndObject2(MemoryBuffer memoryBuffer5, data.media.Image image2) {
      ClassResolver classResolver = this.classResolver;
      Class value10 = imageClassInfo.getCls();
      Class cls2 = image2.getClass();
      if ((value10 != cls2)) {
          imageClassInfo = classResolver.getClassInfo(cls2);
      }
      short value11 = imageClassInfo.getClassId();
      if ((value11 == ((short)0))) {
          memoryBuffer5.writeByte(((byte)1));
          classResolver.writeEnumStringBytes(memoryBuffer5, imageClassInfo.getPackageNameBytes());
          classResolver.writeEnumStringBytes(memoryBuffer5, imageClassInfo.getClassNameBytes());
      } else {
          memoryBuffer5.writePositiveVarInt((value11 << 1));
      }
      imageClassInfo.getSerializer().write(memoryBuffer5, image2);
  }

  private void writeFields(data.media.MediaContent mediaContent1, MemoryBuffer memoryBuffer3) {
      java.util.List images = mediaContent1.images;
      if ((images == null)) {
          memoryBuffer3.writeByte(((byte)-3));
      } else {
          memoryBuffer3.writeByte(((byte)0));
          CollectionSerializer collectionSerializer = this.writeCollectionClassInfo(memoryBuffer3, images);
          if (collectionSerializer.supportCodegenHook()) {
              int value6 = images.size();
              memoryBuffer3.writePositiveVarInt(value6);
              collectionSerializer.writeHeader(memoryBuffer3, images);
              if ((value6 > 0)) {
                  int value7 = collectionSerializer.writeTypeNullabilityHeader(memoryBuffer3, images, data.media.Image.class, imageClassInfoHolder);
                  boolean sameElementClass = (value7 & 8) != 8;
                  boolean hasNull = (value7 & 2) == 2;
                  if (sameElementClass) {
                      this.sameElementClassWrite(value6, hasNull, value7, memoryBuffer3, images);
                  } else {
                      for (int i0 = 0; i0 < value6; i0+=1) {
                        Object object0 = images.get(i0);
                        data.media.Image castedValue0 = (data.media.Image)object0;
                        if (hasNull) {
                            if ((castedValue0 == null)) {
                                memoryBuffer3.writeByte(((byte)-3));
                            } else {
                                memoryBuffer3.writeByte(((byte)0));
                                this.writeClassAndObject1(memoryBuffer3, castedValue0);
                            }
                        } else {
                            this.writeClassAndObject2(memoryBuffer3, castedValue0);
                        }
                      }
                  }
              }
          } else {
              collectionSerializer.write(memoryBuffer3, images);
          }
      }
  }

  private void sameElementClassRead(MemoryBuffer memoryBuffer6, int value12, boolean value13, int value14, java.util.Collection collection) {
      boolean isDeclType0 = (value14 & 4) != 4;
      Serializer serializer2;
      if (isDeclType0) {
          serializer2 = serializer0;
      } else {
          serializer2 = classResolver.readClassInfo(memoryBuffer6, imageClassInfoHolder).getSerializer();
      }
      for (int i1 = 0; i1 < value12; i1+=1) {
        if (value13) {
            if ((memoryBuffer6.readByte() != ((byte)-3))) {
                Object object1 = serializer2.read(memoryBuffer6);
                collection.add(object1);
            } else {
                collection.add(null);
            }
        } else {
            Object object2 = serializer2.read(memoryBuffer6);
            collection.add(object2);
        }
      }
  }

  private void readFields(MemoryBuffer memoryBuffer7, data.media.MediaContent mediaContent2) {
      ClassResolver classResolver = this.classResolver;
      if ((memoryBuffer7.readByte() != ((byte)-3))) {
          Serializer serializer3 = classResolver.readClassInfo(memoryBuffer7, list2ClassInfoHolder).getSerializer();
          CollectionSerializer collectionSerializer0 = (CollectionSerializer)serializer3;
          java.util.Collection collection3;
          if (collectionSerializer0.supportCodegenHook()) {
              int size = memoryBuffer7.readPositiveVarInt();
              java.util.Collection collection0 = collectionSerializer0.newCollection(memoryBuffer7, size);
              if ((size > 0)) {
                  int flags = memoryBuffer7.readByte();
                  boolean sameElementClass0 = (flags & 8) != 8;
                  boolean hasNull0 = (flags & 2) == 2;
                  if (sameElementClass0) {
                      this.sameElementClassRead(memoryBuffer7, size, hasNull0, flags, collection0);
                  } else {
                      for (int i2 = 0; i2 < size; i2+=1) {
                        if (hasNull0) {
                            if ((memoryBuffer7.readByte() != ((byte)-3))) {
                                Object object3 = classResolver.readClassInfo(memoryBuffer7, image3ClassInfoHolder).getSerializer().read(memoryBuffer7);
                                collection0.add(object3);
                            } else {
                                collection0.add(null);
                            }
                        } else {
                            Object object4 = classResolver.readClassInfo(memoryBuffer7, image3ClassInfoHolder).getSerializer().read(memoryBuffer7);
                            collection0.add(object4);
                        }
                      }
                  }
              }
              java.util.Collection collection1 = collectionSerializer0.onCollectionRead(collection0);
              collection3 = collection1;
          } else {
              java.util.Collection collection2 = collectionSerializer0.read(memoryBuffer7);
              collection3 = collection2;
          }
          
          mediaContent2.images = ((List)collection3);
      } else {
          mediaContent2.images = null;
      }
  }

  @Override public final void write(MemoryBuffer buffer, Object obj) {
      data.media.MediaContent mediaContent3 = (data.media.MediaContent)obj;
      data.media.Media media2 = mediaContent3.media;
      if ((media2 == null)) {
          buffer.writeByte(((byte)-3));
      } else {
          buffer.writeByte(((byte)0));
          this.writeClassAndObject(buffer, media2);
      }
      this.writeFields(mediaContent3, buffer);
  }

  @Override public final Object read(MemoryBuffer buffer) {
      data.media.MediaContent mediaContent4 = new data.media.MediaContent();
      refResolver.reference(mediaContent4);
      if ((buffer.readByte() != ((byte)-3))) {
          Object object5 = classResolver.readClassInfo(buffer, media1ClassInfoHolder).getSerializer().read(buffer);
          mediaContent4.media = ((data.media.Media)object5);
      } else {
          mediaContent4.media = null;
      }
      this.readFields(buffer, mediaContent4);
      return mediaContent4;
  }

}