AssetEditorAssetListUpdate.java

package com.hypixel.hytale.protocol.packets.asseteditor;

import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.io.PacketIO;
import com.hypixel.hytale.protocol.io.ProtocolException;
import com.hypixel.hytale.protocol.io.ValidationResult;
import com.hypixel.hytale.protocol.io.VarInt;
import io.netty.buffer.ByteBuf;
import java.util.Arrays;
import java.util.Objects;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class AssetEditorAssetListUpdate implements Packet {
   public static final int PACKET_ID = 320;
   public static final boolean IS_COMPRESSED = true;
   public static final int NULLABLE_BIT_FIELD_SIZE = 1;
   public static final int   ;
         ;
         ;
         ;
   
    String pack;
   
    AssetEditorFileEntry[] additions;
   
    AssetEditorFileEntry[] deletions;

      {
       ;
   }

     {
   }

     {
      .pack = pack;
      .additions = additions;
      .deletions = deletions;
   }

     {
      .pack = other.pack;
      .additions = other.additions;
      .deletions = other.deletions;
   }

   
     AssetEditorAssetListUpdate  {
          ();
         buf.getByte(offset);
       ((nullBits & ) != ) {
            offset +  + buf.getIntLE(offset + );
            VarInt.peek(buf, varPos0);
          (packLen < ) {
             ProtocolException.negativeLength(, packLen);
         }

          (packLen > ) {
             ProtocolException.stringTooLong(, packLen, );
         }

         obj.pack = PacketIO.readVarString(buf, varPos0, PacketIO.UTF8);
      }

       ((nullBits & ) != ) {
            offset +  + buf.getIntLE(offset + );
            VarInt.peek(buf, varPos1);
          (additionsCount < ) {
             ProtocolException.negativeLength(, additionsCount);
         }

          (additionsCount > ) {
             ProtocolException.arrayTooLong(, additionsCount, );
         }

            VarInt.length(buf, varPos1);
          (()(varPos1 + varIntLen) + ()additionsCount *  > ()buf.readableBytes()) {
             ProtocolException.bufferTooSmall(, varPos1 + varIntLen + additionsCount * , buf.readableBytes());
         }

         obj.additions =  [additionsCount];
            varPos1 + varIntLen;

         (   ; i < additionsCount; ++i) {
            obj.additions[i] = AssetEditorFileEntry.deserialize(buf, elemPos);
            elemPos += AssetEditorFileEntry.computeBytesConsumed(buf, elemPos);
         }
      }

       ((nullBits & ) != ) {
            offset +  + buf.getIntLE(offset + );
            VarInt.peek(buf, varPos2);
          (deletionsCount < ) {
             ProtocolException.negativeLength(, deletionsCount);
         }

          (deletionsCount > ) {
             ProtocolException.arrayTooLong(, deletionsCount, );
         }

            VarInt.length(buf, varPos2);
          (()(varPos2 + varIntLen) + ()deletionsCount *  > ()buf.readableBytes()) {
             ProtocolException.bufferTooSmall(, varPos2 + varIntLen + deletionsCount * , buf.readableBytes());
         }

         obj.deletions =  [deletionsCount];
            varPos2 + varIntLen;

         (   ; i < deletionsCount; ++i) {
            obj.deletions[i] = AssetEditorFileEntry.deserialize(buf, elemPos);
            elemPos += AssetEditorFileEntry.computeBytesConsumed(buf, elemPos);
         }
      }

       obj;
   }

       {
         buf.getByte(offset);
         ;
       ((nullBits & ) != ) {
            buf.getIntLE(offset + );
            offset +  + fieldOffset0;
            VarInt.peek(buf, pos0);
         pos0 += VarInt.length(buf, pos0) + sl;
          (pos0 - offset > maxEnd) {
            maxEnd = pos0 - offset;
         }
      }

       ((nullBits & ) != ) {
            buf.getIntLE(offset + );
            offset +  + fieldOffset1;
            VarInt.peek(buf, pos1);
         pos1 += VarInt.length(buf, pos1);

         (   ; i < arrLen; ++i) {
            pos1 += AssetEditorFileEntry.computeBytesConsumed(buf, pos1);
         }

          (pos1 - offset > maxEnd) {
            maxEnd = pos1 - offset;
         }
      }

       ((nullBits & ) != ) {
            buf.getIntLE(offset + );
            offset +  + fieldOffset2;
            VarInt.peek(buf, pos2);
         pos2 += VarInt.length(buf, pos2);

         (   ; i < arrLen; ++i) {
            pos2 += AssetEditorFileEntry.computeBytesConsumed(buf, pos2);
         }

          (pos2 - offset > maxEnd) {
            maxEnd = pos2 - offset;
         }
      }

       maxEnd;
   }

      {
         buf.writerIndex();
         ;
       (.pack != ) {
         nullBits = ()(nullBits | );
      }

       (.additions != ) {
         nullBits = ()(nullBits | );
      }

       (.deletions != ) {
         nullBits = ()(nullBits | );
      }

      buf.writeByte(nullBits);
         buf.writerIndex();
      buf.writeIntLE();
         buf.writerIndex();
      buf.writeIntLE();
         buf.writerIndex();
      buf.writeIntLE();
         buf.writerIndex();
       (.pack != ) {
         buf.setIntLE(packOffsetSlot, buf.writerIndex() - varBlockStart);
         PacketIO.writeVarString(buf, .pack, );
      }  {
         buf.setIntLE(packOffsetSlot, -);
      }

       (.additions != ) {
         buf.setIntLE(additionsOffsetSlot, buf.writerIndex() - varBlockStart);
          (.additions.length > ) {
             ProtocolException.arrayTooLong(, .additions.length, );
         }

         VarInt.write(buf, .additions.length);

         (AssetEditorFileEntry item : .additions) {
            item.serialize(buf);
         }
      }  {
         buf.setIntLE(additionsOffsetSlot, -);
      }

       (.deletions != ) {
         buf.setIntLE(deletionsOffsetSlot, buf.writerIndex() - varBlockStart);
          (.deletions.length > ) {
             ProtocolException.arrayTooLong(, .deletions.length, );
         }

         VarInt.write(buf, .deletions.length);

         (AssetEditorFileEntry item : .deletions) {
            item.serialize(buf);
         }
      }  {
         buf.setIntLE(deletionsOffsetSlot, -);
      }

   }

      {
         ;
       (.pack != ) {
         size += PacketIO.stringSize(.pack);
      }

       (.additions != ) {
            ;

         (AssetEditorFileEntry elem : .additions) {
            additionsSize += elem.computeSize();
         }

         size += VarInt.size(.additions.length) + additionsSize;
      }

       (.deletions != ) {
            ;

         (AssetEditorFileEntry elem : .deletions) {
            deletionsSize += elem.computeSize();
         }

         size += VarInt.size(.deletions.length) + deletionsSize;
      }

       size;
   }

     ValidationResult  {
       (buffer.readableBytes() - offset < ) {
          ValidationResult.error();
      }  {
            buffer.getByte(offset);
          ((nullBits & ) != ) {
               buffer.getIntLE(offset + );
             (packOffset < ) {
                ValidationResult.error();
            }

               offset +  + packOffset;
             (pos >= buffer.writerIndex()) {
                ValidationResult.error();
            }

               VarInt.peek(buffer, pos);
             (packLen < ) {
                ValidationResult.error();
            }

             (packLen > ) {
                ValidationResult.error();
            }

            pos += VarInt.length(buffer, pos);
            pos += packLen;
             (pos > buffer.writerIndex()) {
                ValidationResult.error();
            }
         }

          ((nullBits & ) != ) {
               buffer.getIntLE(offset + );
             (additionsOffset < ) {
                ValidationResult.error();
            }

               offset +  + additionsOffset;
             (pos >= buffer.writerIndex()) {
                ValidationResult.error();
            }

               VarInt.peek(buffer, pos);
             (additionsCount < ) {
                ValidationResult.error();
            }

             (additionsCount > ) {
                ValidationResult.error();
            }

            pos += VarInt.length(buffer, pos);

            (   ; i < additionsCount; ++i) {
                  AssetEditorFileEntry.validateStructure(buffer, pos);
                (!structResult.isValid()) {
                   ValidationResult.error( + i +  + structResult.error());
               }

               pos += AssetEditorFileEntry.computeBytesConsumed(buffer, pos);
            }
         }

          ((nullBits & ) != ) {
               buffer.getIntLE(offset + );
             (deletionsOffset < ) {
                ValidationResult.error();
            }

               offset +  + deletionsOffset;
             (pos >= buffer.writerIndex()) {
                ValidationResult.error();
            }

               VarInt.peek(buffer, pos);
             (deletionsCount < ) {
                ValidationResult.error();
            }

             (deletionsCount > ) {
                ValidationResult.error();
            }

            pos += VarInt.length(buffer, pos);

            (   ; i < deletionsCount; ++i) {
                  AssetEditorFileEntry.validateStructure(buffer, pos);
                (!structResult.isValid()) {
                   ValidationResult.error( + i +  + structResult.error());
               }

               pos += AssetEditorFileEntry.computeBytesConsumed(buffer, pos);
            }
         }

          ValidationResult.OK;
      }
   }

    AssetEditorAssetListUpdate  {
          ();
      copy.pack = .pack;
      copy.additions = .additions !=  ? (AssetEditorFileEntry[])Arrays.stream(.additions).map((e) -> e.clone()).toArray((x$) ->  [x$]) : ;
      copy.deletions = .deletions !=  ? (AssetEditorFileEntry[])Arrays.stream(.deletions).map((e) -> e.clone()).toArray((x$) ->  [x$]) : ;
       copy;
   }

      {
       ( == obj) {
          ;
      }   (!(obj  AssetEditorAssetListUpdate)) {
          ;
      }  {
            (AssetEditorAssetListUpdate)obj;
          Objects.equals(.pack, other.pack) && Arrays.equals(.additions, other.additions) && Arrays.equals(.deletions, other.deletions);
      }
   }

      {
         ;
      result =  * result + Objects.hashCode(.pack);
      result =  * result + Arrays.hashCode(.additions);
      result =  * result + Arrays.hashCode(.deletions);
       result;
   }
}