Coverage Summary for Class: SseEventEnvelopeSerializer (com.ghost.serialization.integration.model)

 @file:OptIn(InternalGhostApi::class)
 
 package com.ghost.serialization.integration.model
 
 import com.ghost.serialization.Ghost
 import com.ghost.serialization.InternalGhostApi
 import com.ghost.serialization.contract.GhostSerializer
 import com.ghost.serialization.parser.GhostJsonFlatReader
 import com.ghost.serialization.parser.GhostJsonReader
 import com.ghost.serialization.parser.JsonReaderOptions
 import com.ghost.serialization.parser.beginObject
 import com.ghost.serialization.parser.captureRawJson
 import com.ghost.serialization.parser.consumeNull
 import com.ghost.serialization.parser.endObject
 import com.ghost.serialization.parser.isNextNullValue
 import com.ghost.serialization.parser.nextLong
 import com.ghost.serialization.parser.nextString
 import com.ghost.serialization.parser.selectNameAndConsume
 import com.ghost.serialization.parser.skipValue
 import com.ghost.serialization.types.RawJson
 import com.ghost.serialization.types.RawJsonDecode
 import com.ghost.serialization.writer.GhostJsonFlatWriter
 import com.ghost.serialization.writer.GhostJsonWriter
 import kotlin.ByteArray
 import okio.ByteString
 import okio.ByteString.Companion.encodeUtf8
 
 /**
  * High-performance serializer for [SseEventEnvelope].
  * Generated by GhostSerialization. Do not modify manually.
  */
 public object SseEventEnvelopeSerializer : GhostSerializer<SseEventEnvelope> {
   override val typeName: String = "SseEventEnvelope"
 
   private val OPTIONS: JsonReaderOptions =
       JsonReaderOptions.of(0, 31, 128, false, "eventType", "eventTime", "deviceEvent", "modeEvent", "unknownEvent")
 
   private val H_DEVICEEVENT: ByteString = "\"deviceEvent\":".encodeUtf8()
 
   private val H_EVENTTIME: ByteString = "\"eventTime\":".encodeUtf8()
 
   private val H_EVENTTYPE: ByteString = "\"eventType\":".encodeUtf8()
 
   private val H_MODEEVENT: ByteString = "\"modeEvent\":".encodeUtf8()
 
   private val H_UNKNOWNEVENT: ByteString = "\"unknownEvent\":".encodeUtf8()
 
   private const val MASK_EVENTTYPE: Long = 1L
 
   private const val MASK_TIMEMILLIS: Long = 2L
 
   private const val MASK_DEVICEEVENT: Long = 4L
 
   private const val MASK_MODEEVENT: Long = 8L
 
   private const val MASK_UNKNOWNEVENT: Long = 16L
 
   private const val MASK_DEFAULTS_0: Long = 31L
 
   private val deviceEventTargetSerializer: GhostSerializer<DeviceEventPayload> =
       Ghost.getSerializer(DeviceEventPayload::class)!!
 
   private val modeEventTargetSerializer: GhostSerializer<ModeEventPayload> =
       Ghost.getSerializer(ModeEventPayload::class)!!
 
   private fun createInstance(
     mask0: Long,
     eventTypeValue: String?,
     timeMillisValue: Long,
     deviceEventValue: RawJson?,
     modeEventValue: RawJson?,
     unknownEventValue: RawJson?,
   ): SseEventEnvelope {
     val result = SseEventEnvelope(
     )
     if ((mask0 and MASK_DEFAULTS_0) != 0L) {
       return result.copy(
         eventType = if ((mask0 and MASK_EVENTTYPE) != 0L) eventTypeValue!! else result.eventType,
         timeMillis = if ((mask0 and MASK_TIMEMILLIS) != 0L) timeMillisValue else result.timeMillis,
         deviceEvent = if ((mask0 and MASK_DEVICEEVENT) != 0L) deviceEventValue else result.deviceEvent,
         modeEvent = if ((mask0 and MASK_MODEEVENT) != 0L) modeEventValue else result.modeEvent,
         unknownEvent = if ((mask0 and MASK_UNKNOWNEVENT) != 0L) unknownEventValue else result.unknownEvent,
       )
     } else {
       return result
     }
   }
 
   /**
    * Robust deserialization for [SseEventEnvelope].
    */
   override fun deserialize(reader: GhostJsonReader): SseEventEnvelope {
     var eventTypeValue: String? = null
     var timeMillisValue: Long = 0L
     var deviceEventValue: RawJson? = null
     var modeEventValue: RawJson? = null
     var unknownEventValue: RawJson? = null
     var mask0 = 0L
     reader.beginObject()
     while (true) {
       val index = reader.selectNameAndConsume(OPTIONS)
       when (index) {
         0 -> {
           eventTypeValue = reader.nextString()
           mask0 = mask0 or MASK_EVENTTYPE
         }
         1 -> {
           timeMillisValue = reader.nextLong()
           mask0 = mask0 or MASK_TIMEMILLIS
         }
         2 -> {
           deviceEventValue = if (reader.isNextNullValue()) { reader.consumeNull(); null } else reader.captureRawJson()
           mask0 = mask0 or MASK_DEVICEEVENT
         }
         3 -> {
           modeEventValue = if (reader.isNextNullValue()) { reader.consumeNull(); null } else reader.captureRawJson()
           mask0 = mask0 or MASK_MODEEVENT
         }
         4 -> {
           unknownEventValue = if (reader.isNextNullValue()) { reader.consumeNull(); null } else reader.captureRawJson()
           mask0 = mask0 or MASK_UNKNOWNEVENT
         }
         -1 -> break
         -2 -> {
           reader.skipValue()
         }
       }
     }
     reader.endObject()
     return createInstance(mask0, eventTypeValue, timeMillisValue, deviceEventValue, modeEventValue, unknownEventValue)
   }
 
   /**
    * Robust deserialization for [SseEventEnvelope].
    */
   override fun deserialize(reader: GhostJsonFlatReader): SseEventEnvelope {
     var eventTypeValue: String? = null
     var timeMillisValue: Long = 0L
     var deviceEventValue: RawJson? = null
     var modeEventValue: RawJson? = null
     var unknownEventValue: RawJson? = null
     var mask0 = 0L
     reader.beginObject()
     while (true) {
       val index = reader.selectNameAndConsume(OPTIONS)
       when (index) {
         0 -> {
           eventTypeValue = reader.nextString()
           mask0 = mask0 or MASK_EVENTTYPE
         }
         1 -> {
           timeMillisValue = reader.nextLong()
           mask0 = mask0 or MASK_TIMEMILLIS
         }
         2 -> {
           deviceEventValue = if (reader.isNextNullValue()) { reader.consumeNull(); null } else reader.captureRawJson()
           mask0 = mask0 or MASK_DEVICEEVENT
         }
         3 -> {
           modeEventValue = if (reader.isNextNullValue()) { reader.consumeNull(); null } else reader.captureRawJson()
           mask0 = mask0 or MASK_MODEEVENT
         }
         4 -> {
           unknownEventValue = if (reader.isNextNullValue()) { reader.consumeNull(); null } else reader.captureRawJson()
           mask0 = mask0 or MASK_UNKNOWNEVENT
         }
         -1 -> break
         -2 -> {
           reader.skipValue()
         }
       }
     }
     reader.endObject()
     return createInstance(mask0, eventTypeValue, timeMillisValue, deviceEventValue, modeEventValue, unknownEventValue)
   }
 
   /**
    * Routes [SseEventEnvelope] to its matching opaque JSON payload without re-parsing.
    */
   public fun routePayload(envelope: SseEventEnvelope): RawJson? = when (envelope.eventType) {
   "DEVICE_EVENT" -> envelope.deviceEvent
   "MODE_EVENT" -> envelope.modeEvent
   else -> envelope.unknownEvent
   }
 
   /**
    * Deserializes [SseEventEnvelope] from bytes and routes to payload (zero-copy RawJson slice on flat reader).
    */
   public fun parsePayload(bytes: ByteArray): RawJson? {
     val envelope = deserialize(GhostJsonFlatReader(bytes))
     return routePayload(envelope)
   }
 
   /**
    * Routes [SseEventEnvelope] and decodes annotated payload targets.
    */
   public fun routeTyped(envelope: SseEventEnvelope): Any? = when (envelope.eventType) {
   "DEVICE_EVENT" -> envelope.deviceEvent?.let { RawJsonDecode.decode(it, deviceEventTargetSerializer) }
   "MODE_EVENT" -> envelope.modeEvent?.let { RawJsonDecode.decode(it, modeEventTargetSerializer) }
   else -> envelope.unknownEvent
   }
 
   /**
    * Deserializes [SseEventEnvelope] from bytes and returns typed payload when configured.
    */
   public fun parseTyped(bytes: ByteArray): Any? {
     val envelope = deserialize(GhostJsonFlatReader(bytes))
     return routeTyped(envelope)
   }
 
   override fun serialize(writer: GhostJsonWriter, `value`: SseEventEnvelope) {
     writer.beginObject()
     writer.writeField(H_EVENTTYPE, value.eventType)
     writer.writeField(H_EVENTTIME, value.timeMillis)
     if (value.deviceEvent != null) {
       writer.writeNameRaw(H_DEVICEEVENT)
       writer.rawValue(value.deviceEvent.storage, value.deviceEvent.storageOffset, value.deviceEvent.storageLength)
     }
     if (value.modeEvent != null) {
       writer.writeNameRaw(H_MODEEVENT)
       writer.rawValue(value.modeEvent.storage, value.modeEvent.storageOffset, value.modeEvent.storageLength)
     }
     if (value.unknownEvent != null) {
       writer.writeNameRaw(H_UNKNOWNEVENT)
       writer.rawValue(value.unknownEvent.storage, value.unknownEvent.storageOffset, value.unknownEvent.storageLength)
     }
     writer.endObject()
   }
 
   override fun serialize(writer: GhostJsonFlatWriter, `value`: SseEventEnvelope) {
     writer.beginObject()
     writer.writeField(H_EVENTTYPE, value.eventType)
     writer.writeField(H_EVENTTIME, value.timeMillis)
     if (value.deviceEvent != null) {
       writer.writeNameRaw(H_DEVICEEVENT)
       writer.rawValue(value.deviceEvent.storage, value.deviceEvent.storageOffset, value.deviceEvent.storageLength)
     }
     if (value.modeEvent != null) {
       writer.writeNameRaw(H_MODEEVENT)
       writer.rawValue(value.modeEvent.storage, value.modeEvent.storageOffset, value.modeEvent.storageLength)
     }
     if (value.unknownEvent != null) {
       writer.writeNameRaw(H_UNKNOWNEVENT)
       writer.rawValue(value.unknownEvent.storage, value.unknownEvent.storageOffset, value.unknownEvent.storageLength)
     }
     writer.endObject()
   }
 
   override fun warmUp() {
     try {
       val reader1 = GhostJsonReader("{}".encodeToByteArray())
       deserialize(reader1)
     } catch (_: Exception) {
     }
     try {
       val reader2 = GhostJsonFlatReader("{}".encodeToByteArray())
       deserialize(reader2)
     } catch (_: Exception) {
     }
   }
 }