UpdateTrails.java

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

import com.hypixel.hytale.protocol.Packet;
import com.hypixel.hytale.protocol.Trail;
import com.hypixel.hytale.protocol.UpdateType;
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.HashMap;
import java.util.Map;
import java.util.Objects;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class UpdateTrails implements Packet {
   public static final int PACKET_ID = 48;
   public static final boolean IS_COMPRESSED = true;
   public static final int NULLABLE_BIT_FIELD_SIZE = 1;
         ;
         ;
         ;
         ;
   
    UpdateType type;
   
    Map<String, Trail> trails;

      {
       ;
   }

     {
      .type = UpdateType.Init;
   }

     {
      .type = UpdateType.Init;
      .type = type;
      .trails = trails;
   }

     {
      .type = UpdateType.Init;
      .type = other.type;
      .trails = other.trails;
   }

   
     UpdateTrails  {
          ();
         buf.getByte(offset);
      obj.type = UpdateType.fromValue(buf.getByte(offset + ));
         offset + ;
       ((nullBits & ) != ) {
            VarInt.peek(buf, pos);
          (trailsCount < ) {
             ProtocolException.negativeLength(, trailsCount);
         }

          (trailsCount > ) {
             ProtocolException.dictionaryTooLarge(, trailsCount, );
         }

         pos += VarInt.size(trailsCount);
         obj.trails =  (trailsCount);

         (   ; i < trailsCount; ++i) {
               VarInt.peek(buf, pos);
             (keyLen < ) {
                ProtocolException.negativeLength(, keyLen);
            }

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

               VarInt.length(buf, pos);
               PacketIO.readVarString(buf, pos);
            pos += keyVarLen + keyLen;
               Trail.deserialize(buf, pos);
            pos += Trail.computeBytesConsumed(buf, pos);
             (obj.trails.put(key, val) != ) {
                ProtocolException.duplicateKey(, key);
            }
         }
      }

       obj;
   }

       {
         buf.getByte(offset);
         offset + ;
       ((nullBits & ) != ) {
            VarInt.peek(buf, pos);
         pos += VarInt.length(buf, pos);

         (   ; i < dictLen; ++i) {
               VarInt.peek(buf, pos);
            pos += VarInt.length(buf, pos) + sl;
            pos += Trail.computeBytesConsumed(buf, pos);
         }
      }

       pos - offset;
   }

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

      buf.writeByte(nullBits);
      buf.writeByte(.type.getValue());
       (.trails != ) {
          (.trails.size() > ) {
             ProtocolException.dictionaryTooLarge(, .trails.size(), );
         }

         VarInt.write(buf, .trails.size());

         (Map.Entry<String, Trail> e : .trails.entrySet()) {
            PacketIO.writeVarString(buf, (String)e.getKey(), );
            ((Trail)e.getValue()).serialize(buf);
         }
      }

   }

      {
         ;
       (.trails != ) {
            ;

         (Map.Entry<String, Trail> kvp : .trails.entrySet()) {
            trailsSize += PacketIO.stringSize((String)kvp.getKey()) + ((Trail)kvp.getValue()).computeSize();
         }

         size += VarInt.size(.trails.size()) + trailsSize;
      }

       size;
   }

     ValidationResult  {
       (buffer.readableBytes() - offset < ) {
          ValidationResult.error();
      }  {
            buffer.getByte(offset);
            offset + ;
          ((nullBits & ) != ) {
               VarInt.peek(buffer, pos);
             (trailsCount < ) {
                ValidationResult.error();
            }

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

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

            (   ; i < trailsCount; ++i) {
                  VarInt.peek(buffer, pos);
                (keyLen < ) {
                   ValidationResult.error();
               }

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

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

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

          ValidationResult.OK;
      }
   }

    UpdateTrails  {
          ();
      copy.type = .type;
       (.trails != ) {
         Map<String, Trail> m =  ();

         (Map.Entry<String, Trail> e : .trails.entrySet()) {
            m.put((String)e.getKey(), ((Trail)e.getValue()).clone());
         }

         copy.trails = m;
      }

       copy;
   }

      {
       ( == obj) {
          ;
      }   (!(obj  UpdateTrails)) {
          ;
      }  {
            (UpdateTrails)obj;
          Objects.equals(.type, other.type) && Objects.equals(.trails, other.trails);
      }
   }

      {
       Objects.hash( []{.type, .trails});
   }
}