Protobuf: removed trash files from ProtoKot Runtime sources folder

2016-07-20 15:35:05 +03:00
parent bee4c839d2
commit 8566ccdfe3
6 changed files with 0 additions and 1028 deletions
@@ -1,14 +0,0 @@
 /**
 * Created by user on 7/8/16.
 */
 interface Message {
    fun writeTo(output: CodedOutputStream)
    fun getBuilder() : Builder
    //TODO: think about something similar to static method getDefaultInstance()
    interface Builder {
        fun build(): Message
    }
 }
@@ -1,54 +0,0 @@
 import java.io.ByteArrayInputStream
 import java.io.ByteArrayOutputStream
 /**
 * Created by user on 7/8/16.
 */
 object AddressbookTests {
    fun testMessageSerialization() {
        // Messages work only with CodedStream classes, provided by ProtoKot-runtime library.
        // One can create CodedStream passing any instance of corresponding Stream from Java's library.
        val s = ByteArrayOutputStream()
        val outs = CodedOutputStream(s)
        // All messages are immutable. Use Builders for creating new messages
        val msg = Person.BuilderPerson()
                .setEmail("wtf@dasda.com")  // all setters return this builder, so you could chain modifiers in LINQ-style
                .setId(42)
                .setName("John Doe")
                .addPhoneNumber(// repeated fields stored as Array<>, so use arrayOf() for creating repeated fields
                        Person.PhoneNumber.BuilderPhoneNumber()
                                .setNumber("342143-23423-42")
                                .setType(Person.PhoneType.HOME)
                                .build()
                )
                .addPhoneNumber(
                        Person.PhoneNumber.BuilderPhoneNumber()
                                .setNumber("8-800-555-35-35")
                                .setType(Person.PhoneType.WORK)
                                .build()
                )
                .build()    // don't forget to call build() to produce message
        msg.writeTo(outs)
        // Now let's use output stream as input to read our message from it!
        var ins = CodedInputStream(ByteArrayInputStream(s.toByteArray()))
        // Create default instance of message
        var readMsg = Person.BuilderPerson().build()
        // Read in that message data from input stream.
        readMsg.mergeFrom(ins)
        // Note, that currently mergeFrom is the only way to mutate instance of message.
        // Don't rely on it, probably mergeFrom will be refactored lately to guarantee full immutability of mesages.
        // Better way to read a message:
        ins = CodedInputStream(ByteArrayInputStream(s.toByteArray()))
        readMsg = Person.BuilderPerson().readFrom(ins).build()
        assert(msg == readMsg)
    }
 }
 fun main(args: Array<String>) {
    AddressbookTests.testMessageSerialization()
    println("OK")
 }
@@ -1,37 +0,0 @@
 import java.io.ByteArrayOutputStream
 /**
 * Created by user on 7/18/16.
 */
 object NestedMsgTests {
    val msg1 = Level1.BuilderLevel1()
            .setField1(
                    Level1.Level2.BuilderLevel2()
                    .setField2(
                            Level1.Level2.Level3.BuilderLevel3()
                            .setField3(
                                    Level1.Level2.Level3.Level4.BuilderLevel4()
                                    .setField4("Hello!")
                                    .build()
                            )
                            .build()
                    )
                    .build()
            )
            .build()
    fun testMessageSerialization() {
        val s = ByteArrayOutputStream()
        val output = CodedOutputStream(s)
        msg1.writeTo(output)
        val readMsg = Level1.BuilderLevel1().build()
    }
 }
 fun main(args: Array<String>) {
    NestedMsgTests.testMessageSerialization()
    println("OK")
 }
@@ -1,157 +0,0 @@
 import java.io.ByteArrayInputStream
 import java.io.ByteArrayOutputStream
 /**
 * Created by user on 7/7/16.
 */
 fun testTrivialPositiveVarInts() {
    val s = ByteArrayOutputStream()
    val outs = CodedOutputStream(s)
    outs.writeInt32(1, 42)
    outs.writeInt32(16, 1)
    outs.writeInt32(2, -2)
    outs.writeInt32(3, -21321)
    outs.writeInt64(5, 42L)
    outs.writeInt64(6, 1232132131212321L)
    outs.writeInt64(7, -2)
    outs.writeInt64(8, -21321L)
    outs.writeInt64(9, -32132132132131L)
    val ins = CodedInputStream(ByteArrayInputStream(s.toByteArray()))
    assertSuccessfulRead(42, ins.readInt32(1))
    assertSuccessfulRead(1, ins.readInt32(16))
    assertSuccessfulRead(-2, ins.readInt32(2))
    assertSuccessfulRead(-21321, ins.readInt32(3))
    assertSuccessfulRead(42L, ins.readInt64(5))
    assertSuccessfulRead(1232132131212321L, ins.readInt64(6))
    assertSuccessfulRead(-2, ins.readInt64(7))
    assertSuccessfulRead(-21321L, ins.readInt64(8))
    assertSuccessfulRead(-32132132132131L, ins.readInt64(9))
 }
 fun testMinPossibleVarInts() {
    val s = ByteArrayOutputStream()
    val outs = CodedOutputStream(s)
    outs.writeInt32(1, Int.MIN_VALUE)
    outs.writeInt64(2, Long.MIN_VALUE)
    val ins = CodedInputStream(ByteArrayInputStream(s.toByteArray()))
    assertSuccessfulRead(Int.MIN_VALUE, ins.readInt32(1))
    assertSuccessfulRead(Long.MIN_VALUE, ins.readInt64(2))
 }
 fun testMaxPossibleVarInts() {
    val s = ByteArrayOutputStream()
    val outs = CodedOutputStream(s)
    outs.writeInt32(1, Int.MAX_VALUE)
    outs.writeInt64(2, Long.MAX_VALUE)
    val ins = CodedInputStream(ByteArrayInputStream(s.toByteArray()))
    assertSuccessfulRead(Int.MAX_VALUE, ins.readInt32(1))
    assertSuccessfulRead(Long.MAX_VALUE, ins.readInt64(2))
 }
 fun testMaxPossibleFieldNumber() {
    val s = ByteArrayOutputStream()
    val outs = CodedOutputStream(s)
    outs.writeInt64(536870911, Long.MAX_VALUE)
    val ins = CodedInputStream(ByteArrayInputStream(s.toByteArray()))
    assertSuccessfulRead(Long.MAX_VALUE, ins.readInt64(536870911))
 }
 fun testZigZag32() {
    val s = ByteArrayOutputStream()
    val outs = CodedOutputStream(s)
    outs.writeSInt32(5, -213123)
    outs.writeSInt32(1, 3123123)
    outs.writeSInt32(4, -12345675)
    val ins = CodedInputStream(ByteArrayInputStream(s.toByteArray()))
    assertSuccessfulRead(-213123, ins.readSInt32(5))
    assertSuccessfulRead(3123123, ins.readSInt32(1))
    assertSuccessfulRead(-12345675, ins.readSInt32(4))
 }
 fun testZigZag64() {
    val s = ByteArrayOutputStream()
    val outs = CodedOutputStream(s)
    outs.writeSInt64(5, -213123L)
    outs.writeSInt64(1, 3123123L)
    outs.writeSInt64(4, -12345675L)
    outs.writeSInt64(12, -123456789012L)
    outs.writeSInt64(42, 483567314231L)
    val ins = CodedInputStream(ByteArrayInputStream(s.toByteArray()))
    assertSuccessfulRead(-213123L, ins.readSInt64(5))
    assertSuccessfulRead(3123123L, ins.readSInt64(1))
    assertSuccessfulRead(-12345675L, ins.readSInt64(4))
    assertSuccessfulRead(-123456789012L, ins.readSInt64(12))
    assertSuccessfulRead(483567314231L, ins.readSInt64(42))
 }
 fun testBoolean() {
    val s = ByteArrayOutputStream()
    val outs = CodedOutputStream(s)
    outs.writeBool(1, true)
    outs.writeBool(2, false)
    val ins = CodedInputStream(ByteArrayInputStream(s.toByteArray()))
    assertSuccessfulRead(true, ins.readBool(1))
    assertSuccessfulRead(false, ins.readBool(2))
 }
 fun testEnum() {
    val s = ByteArrayOutputStream()
    val outs = CodedOutputStream(s)
    outs.writeEnum(1, WireType.END_GROUP.ordinal)
    outs.writeEnum(2, WireType.FIX_64.ordinal)
    val ins = CodedInputStream(ByteArrayInputStream(s.toByteArray()))
    assertSuccessfulRead(WireType.END_GROUP.ordinal, ins.readEnum(1))
    assertSuccessfulRead(WireType.FIX_64.ordinal, ins.readEnum(2))
 }
 fun testFloatAndDouble() {
    val s = ByteArrayOutputStream()
    val outs = CodedOutputStream(s)
    outs.writeDouble(42, 123212.34282)
    outs.writeDouble(15, Math.PI)
    outs.writeFloat(14, -1.32131321f)
    val ins = CodedInputStream(ByteArrayInputStream(s.toByteArray()))
    assertSuccessfulRead(123212.34282, ins.readDouble(42))
    assertSuccessfulRead(Math.PI, ins.readDouble(15))
    assertSuccessfulRead(-1.32131321f, ins.readFloat(14))
 }
 fun testStrings() {
    val s = ByteArrayOutputStream()
    val outs = CodedOutputStream(s)
    outs.writeString(42, "dasddasd asd ")
    outs.writeString(15, """!@#$%^&*()QWERTYUI выфвфывфы""")
    val ins = CodedInputStream(ByteArrayInputStream(s.toByteArray()))
    assertSuccessfulRead("dasddasd asd ", ins.readString(42))
    assertSuccessfulRead("""!@#$%^&*()QWERTYUI выфвфывфы""", ins.readString(15))
 }
 fun <T> assertSuccessfulRead(value: T, actualValue: T) {
    assert(actualValue == value)
 }
 fun main(args: Array<String>) {
    testTrivialPositiveVarInts()
    testMinPossibleVarInts()
    testMaxPossibleVarInts()
    testMaxPossibleFieldNumber()
    testZigZag32()
    testZigZag64()
    testBoolean()
    testEnum()
    testFloatAndDouble()
    testStrings()
    print("OK")
 }
@@ -1,451 +0,0 @@
 class Person private constructor (name: String = "", id: Int = 0, email: String = "", phones: MutableList <Person.PhoneNumber> = mutableListOf(), someBytes: ByteArray = ByteArray(0)) {
  var name : String
    private set
  var id : Int
    private set
  var email : String
    private set
  var phones : MutableList <Person.PhoneNumber>
    private set
  var someBytes : ByteArray
    private set
  init {
    this.name = name
    this.id = id
    this.email = email
    this.phones = phones
    this.someBytes = someBytes
  }
  enum class PhoneType(val ord: Int) {
    MOBILE (0),
    HOME (1),
    WORK (2);
    companion object {
      fun fromIntToPhoneType (ord: Int): PhoneType {
        return when (ord) {
          0 -> PhoneType.MOBILE
          1 -> PhoneType.HOME
          2 -> PhoneType.WORK
          else -> throw InvalidProtocolBufferException("Error: got unexpected int ${ord} while parsing PhoneType ");
        }
      }
    }
  }
  class PhoneNumber private constructor (number: String = "", type: Person.PhoneType = Person.PhoneType.fromIntToPhoneType(0)) {
    var number : String
      private set
    var type : Person.PhoneType
      private set
    init {
      this.number = number
      this.type = type
    }
    fun writeTo (output: CodedOutputStream): Unit {
      output.writeString (1, number)
      output.writeEnum (2, type.ord)
    }
    class BuilderPhoneNumber constructor (number: String = "", type: Person.PhoneType = Person.PhoneType.fromIntToPhoneType(0)) {
      var number : String
        private set
      fun setNumber(value: String): Person.PhoneNumber.BuilderPhoneNumber {
        number = value
        return this
      }
      var type : Person.PhoneType
        private set
      fun setType(value: Person.PhoneType): Person.PhoneNumber.BuilderPhoneNumber {
        type = value
        return this
      }
      init {
        this.number = number
        this.type = type
      }
      fun readFrom (input: CodedInputStream): Person.PhoneNumber.BuilderPhoneNumber {
        number = input.readString(1)
        type = Person.PhoneType.fromIntToPhoneType(input.readEnum(2))
        return this
 }
      fun build(): Person.PhoneNumber {
        return Person.PhoneNumber(number, type)
      }
      fun parseFieldFrom(input: CodedInputStream): Boolean {
        if (input.isAtEnd()) { return false }
        val tag = input.readInt32NoTag()
        if (tag == 0) { return false } 
        val fieldNumber = WireFormat.getTagFieldNumber(tag)
        val wireType = WireFormat.getTagWireType(tag)
        when(fieldNumber) {
          1 -> number = input.readStringNoTag()
          2 -> type = Person.PhoneType.fromIntToPhoneType(input.readEnumNoTag())
        }
        return true}
      fun parseFrom(input: CodedInputStream): Person.PhoneNumber.BuilderPhoneNumber {
        while(parseFieldFrom(input)) {}
        return this
      }
      fun getSize(): Int {
        var size = 0
        size += WireFormat.getStringSize(1, number)
        size += WireFormat.getEnumSize(2, type.ord)
        return size
      }
    }
    fun mergeWith (other: Person.PhoneNumber) {
      number = other.number
      type = other.type
    }
    fun mergeFrom (input: CodedInputStream) {
      val builder = Person.PhoneNumber.BuilderPhoneNumber()
      mergeWith(builder.parseFrom(input).build())}
    fun getSize(): Int {
      var size = 0
      size += WireFormat.getStringSize(1, number)
      size += WireFormat.getEnumSize(2, type.ord)
      return size
    }
  }
  fun writeTo (output: CodedOutputStream): Unit {
    output.writeString (1, name)
    output.writeInt32 (2, id)
    output.writeString (3, email)
    if (phones.size > 0) {
      output.writeTag(4, WireType.LENGTH_DELIMITED)
      var arrayByteSize = 0
      run {
        var arraySize = 0
        for (item in phones) {
          arraySize += item.getSize() + WireFormat.getTagSize(4, WireType.LENGTH_DELIMITED) + WireFormat.getVarint32Size(item.getSize())
        }
        arrayByteSize += arraySize
      }
      output.writeInt32NoTag(arrayByteSize)
      for (item in phones) {
        output.writeTag(4, WireType.LENGTH_DELIMITED)
        output.writeInt32NoTag(item.getSize())
        item.writeTo(output)
      }
    }
    output.writeBytes (5, someBytes)
  }
  class BuilderPerson constructor (name: String = "", id: Int = 0, email: String = "", phones: MutableList <Person.PhoneNumber> = mutableListOf(), someBytes: ByteArray = ByteArray(0)) {
    var name : String
      private set
    fun setName(value: String): Person.BuilderPerson {
      name = value
      return this
    }
    var id : Int
      private set
    fun setId(value: Int): Person.BuilderPerson {
      id = value
      return this
    }
    var email : String
      private set
    fun setEmail(value: String): Person.BuilderPerson {
      email = value
      return this
    }
    var phones : MutableList <Person.PhoneNumber>
      private set
    fun setPhones(value: MutableList <Person.PhoneNumber>): Person.BuilderPerson {
      phones = value
      return this
    }
    fun setPhoneNumber(index: Int, value: PhoneNumber): Person.BuilderPerson {
      phones[index] = value
      return this
    }
    fun addPhoneNumber(value: PhoneNumber): Person.BuilderPerson {
      phones.add(value)
      return this
    }
    fun addAllPhoneNumber(value: Iterable<PhoneNumber>): Person.BuilderPerson {
      for (item in value) {
        phones.add(item)
      }
      return this
    }
    var someBytes : ByteArray
      private set
    fun setSomeBytes(value: ByteArray): Person.BuilderPerson {
      someBytes = value
      return this
    }
    init {
      this.name = name
      this.id = id
      this.email = email
      this.phones = phones
      this.someBytes = someBytes
    }
    fun readFrom (input: CodedInputStream): Person.BuilderPerson {
      name = input.readString(1)
      id = input.readInt32(2)
      email = input.readString(3)
      val tag = input.readTag(4, WireType.LENGTH_DELIMITED)
      val expectedSize = input.readInt32NoTag()
      var readSize = 0
      while(readSize != expectedSize) {
        val tmp: Person.PhoneNumber = Person.PhoneNumber.BuilderPhoneNumber().build()
        input.readTag(4, WireType.LENGTH_DELIMITED)
        val expectedSize = input.readInt32NoTag()
        tmp.mergeFrom(input)
        if (expectedSize != tmp.getSize()) { throw InvalidProtocolBufferException ("Expected size ${expectedSize} got ${tmp.getSize()}") }
        readSize += tmp.getSize() + WireFormat.getTagSize(4, WireType.LENGTH_DELIMITED) + WireFormat.getVarint32Size(tmp.getSize())
        phones.add(tmp)
      }
      someBytes = input.readBytes(5)
      return this
 }
    fun build(): Person {
      return Person(name, id, email, phones, someBytes)
    }
    fun parseFieldFrom(input: CodedInputStream): Boolean {
      if (input.isAtEnd()) { return false }
      val tag = input.readInt32NoTag()
      if (tag == 0) { return false } 
      val fieldNumber = WireFormat.getTagFieldNumber(tag)
      val wireType = WireFormat.getTagWireType(tag)
      when(fieldNumber) {
        1 -> name = input.readStringNoTag()
        2 -> id = input.readInt32NoTag()
        3 -> email = input.readStringNoTag()
        4 -> {
          val expectedSize = input.readInt32NoTag()
          var readSize = 0
          while(readSize != expectedSize) {
            val tmp: Person.PhoneNumber = Person.PhoneNumber.BuilderPhoneNumber().build()
            input.readTag(4, WireType.LENGTH_DELIMITED)
            val expectedSize = input.readInt32NoTag()
            tmp.mergeFrom(input)
            if (expectedSize != tmp.getSize()) { throw InvalidProtocolBufferException ("Expected size ${expectedSize} got ${tmp.getSize()}") }
            readSize += tmp.getSize() + WireFormat.getTagSize(4, WireType.LENGTH_DELIMITED) + WireFormat.getVarint32Size(tmp.getSize())
            phones.add(tmp)
          }
        }
        5 -> someBytes = input.readBytesNoTag()
      }
      return true}
    fun parseFrom(input: CodedInputStream): Person.BuilderPerson {
      while(parseFieldFrom(input)) {}
      return this
    }
    fun getSize(): Int {
      var size = 0
      size += WireFormat.getStringSize(1, name)
      size += WireFormat.getInt32Size(2, id)
      size += WireFormat.getStringSize(3, email)
      run {
        var arraySize = 0
        for (item in phones) {
          arraySize += item.getSize() + WireFormat.getTagSize(4, WireType.LENGTH_DELIMITED) + WireFormat.getVarint32Size(item.getSize())
        }
        size += arraySize + WireFormat.getTagSize(4, WireType.LENGTH_DELIMITED) + WireFormat.getVarint32Size(arraySize)
      }
      size += WireFormat.getBytesSize(5, someBytes)
      return size
    }
  }
  fun mergeWith (other: Person) {
    name = other.name
    id = other.id
    email = other.email
    phones.addAll(other.phones)
    someBytes.plus(other.someBytes)
  }
  fun mergeFrom (input: CodedInputStream) {
    val builder = Person.BuilderPerson()
    mergeWith(builder.parseFrom(input).build())}
  fun getSize(): Int {
    var size = 0
    size += WireFormat.getStringSize(1, name)
    size += WireFormat.getInt32Size(2, id)
    size += WireFormat.getStringSize(3, email)
    run {
      var arraySize = 0
      for (item in phones) {
        arraySize += item.getSize() + WireFormat.getTagSize(4, WireType.LENGTH_DELIMITED) + WireFormat.getVarint32Size(item.getSize())
      }
      size += arraySize + WireFormat.getTagSize(4, WireType.LENGTH_DELIMITED) + WireFormat.getVarint32Size(arraySize)
    }
    size += WireFormat.getBytesSize(5, someBytes)
    return size
  }
 }
 class AddressBook private constructor (people: MutableList <Person> = mutableListOf()) {
  var people : MutableList <Person>
    private set
  init {
    this.people = people
  }
  fun writeTo (output: CodedOutputStream): Unit {
    if (people.size > 0) {
      output.writeTag(1, WireType.LENGTH_DELIMITED)
      var arrayByteSize = 0
      run {
        var arraySize = 0
        for (item in people) {
          arraySize += item.getSize() + WireFormat.getTagSize(1, WireType.LENGTH_DELIMITED) + WireFormat.getVarint32Size(item.getSize())
        }
        arrayByteSize += arraySize
      }
      output.writeInt32NoTag(arrayByteSize)
      for (item in people) {
        output.writeTag(1, WireType.LENGTH_DELIMITED)
        output.writeInt32NoTag(item.getSize())
        item.writeTo(output)
      }
    }
  }
  class BuilderAddressBook constructor (people: MutableList <Person> = mutableListOf()) {
    var people : MutableList <Person>
      private set
    fun setPeople(value: MutableList <Person>): AddressBook.BuilderAddressBook {
      people = value
      return this
    }
    fun setPerson(index: Int, value: Person): AddressBook.BuilderAddressBook {
      people[index] = value
      return this
    }
    fun addPerson(value: Person): AddressBook.BuilderAddressBook {
      people.add(value)
      return this
    }
    fun addAllPerson(value: Iterable<Person>): AddressBook.BuilderAddressBook {
      for (item in value) {
        people.add(item)
      }
      return this
    }
    init {
      this.people = people
    }
    fun readFrom (input: CodedInputStream): AddressBook.BuilderAddressBook {
      val tag = input.readTag(1, WireType.LENGTH_DELIMITED)
      val expectedSize = input.readInt32NoTag()
      var readSize = 0
      while(readSize != expectedSize) {
        val tmp: Person = Person.BuilderPerson().build()
        input.readTag(1, WireType.LENGTH_DELIMITED)
        val expectedSize = input.readInt32NoTag()
        tmp.mergeFrom(input)
        if (expectedSize != tmp.getSize()) { throw InvalidProtocolBufferException ("Expected size ${expectedSize} got ${tmp.getSize()}") }
        readSize += tmp.getSize() + WireFormat.getTagSize(1, WireType.LENGTH_DELIMITED) + WireFormat.getVarint32Size(tmp.getSize())
        people.add(tmp)
      }
      return this
 }
    fun build(): AddressBook {
      return AddressBook(people)
    }
    fun parseFieldFrom(input: CodedInputStream): Boolean {
      if (input.isAtEnd()) { return false }
      val tag = input.readInt32NoTag()
      if (tag == 0) { return false } 
      val fieldNumber = WireFormat.getTagFieldNumber(tag)
      val wireType = WireFormat.getTagWireType(tag)
      when(fieldNumber) {
        1 -> {
          val expectedSize = input.readInt32NoTag()
          var readSize = 0
          while(readSize != expectedSize) {
            val tmp: Person = Person.BuilderPerson().build()
            input.readTag(1, WireType.LENGTH_DELIMITED)
            val expectedSize = input.readInt32NoTag()
            tmp.mergeFrom(input)
            if (expectedSize != tmp.getSize()) { throw InvalidProtocolBufferException ("Expected size ${expectedSize} got ${tmp.getSize()}") }
            readSize += tmp.getSize() + WireFormat.getTagSize(1, WireType.LENGTH_DELIMITED) + WireFormat.getVarint32Size(tmp.getSize())
            people.add(tmp)
          }
        }
      }
      return true}
    fun parseFrom(input: CodedInputStream): AddressBook.BuilderAddressBook {
      while(parseFieldFrom(input)) {}
      return this
    }
    fun getSize(): Int {
      var size = 0
      run {
        var arraySize = 0
        for (item in people) {
          arraySize += item.getSize() + WireFormat.getTagSize(1, WireType.LENGTH_DELIMITED) + WireFormat.getVarint32Size(item.getSize())
        }
        size += arraySize + WireFormat.getTagSize(1, WireType.LENGTH_DELIMITED) + WireFormat.getVarint32Size(arraySize)
      }
      return size
    }
  }
  fun mergeWith (other: AddressBook) {
    people.addAll(other.people)
  }
  fun mergeFrom (input: CodedInputStream) {
    val builder = AddressBook.BuilderAddressBook()
    mergeWith(builder.parseFrom(input).build())}
  fun getSize(): Int {
    var size = 0
    run {
      var arraySize = 0
      for (item in people) {
        arraySize += item.getSize() + WireFormat.getTagSize(1, WireType.LENGTH_DELIMITED) + WireFormat.getVarint32Size(item.getSize())
      }
      size += arraySize + WireFormat.getTagSize(1, WireType.LENGTH_DELIMITED) + WireFormat.getVarint32Size(arraySize)
    }
    return size
  }
 }
@@ -1,315 +0,0 @@
 class Level1 private constructor (field1: Level1.Level2 = Level1.Level2.BuilderLevel2().build()) {
  var field1 : Level1.Level2
    private set
  init {
    this.field1 = field1
  }
  class Level2 private constructor (field2: Level1.Level2.Level3 = Level1.Level2.Level3.BuilderLevel3().build()) {
    var field2 : Level1.Level2.Level3
      private set
    init {
      this.field2 = field2
    }
    class Level3 private constructor (field3: Level1.Level2.Level3.Level4 = Level1.Level2.Level3.Level4.BuilderLevel4().build()) {
      var field3 : Level1.Level2.Level3.Level4
        private set
      init {
        this.field3 = field3
      }
      class Level4 private constructor (field4: String = "") {
        var field4 : String
          private set
        init {
          this.field4 = field4
        }
        fun writeTo (output: CodedOutputStream): Unit {
          output.writeString (4, field4)
        }
        class BuilderLevel4 constructor (field4: String = "") {
          var field4 : String
            private set
          fun setField4(value: String): Level1.Level2.Level3.Level4.BuilderLevel4 {
            field4 = value
            return this
          }
          init {
            this.field4 = field4
          }
          fun readFrom (input: CodedInputStream): Level1.Level2.Level3.Level4.BuilderLevel4 {
            field4 = input.readString(4)
            return this
 }
          fun build(): Level1.Level2.Level3.Level4 {
            return Level1.Level2.Level3.Level4(field4)
          }
          fun parseFieldFrom(input: CodedInputStream): Boolean {
            if (input.isAtEnd()) { return false }
            val tag = input.readInt32NoTag()
            if (tag == 0) { return false } 
            val fieldNumber = WireFormat.getTagFieldNumber(tag)
            val wireType = WireFormat.getTagWireType(tag)
            when(fieldNumber) {
              4 -> field4 = input.readStringNoTag()
            }
            return true}
          fun parseFrom(input: CodedInputStream): Level1.Level2.Level3.Level4.BuilderLevel4 {
            while(parseFieldFrom(input)) {}
            return this
          }
          fun getSize(): Int {
            var size = 0
            size += WireFormat.getStringSize(4, field4)
            return size
          }
        }
        fun mergeWith (other: Level1.Level2.Level3.Level4) {
          field4 = other.field4
        }
        fun mergeFrom (input: CodedInputStream) {
          val builder = Level1.Level2.Level3.Level4.BuilderLevel4()
          mergeWith(builder.parseFrom(input).build())}
        fun getSize(): Int {
          var size = 0
          size += WireFormat.getStringSize(4, field4)
          return size
        }
      }
      fun writeTo (output: CodedOutputStream): Unit {
        output.writeTag(3, WireType.LENGTH_DELIMITED)
        output.writeInt32NoTag(field3.getSize())
        field3.writeTo(output)
      }
      class BuilderLevel3 constructor (field3: Level1.Level2.Level3.Level4 = Level1.Level2.Level3.Level4.BuilderLevel4().build()) {
        var field3 : Level1.Level2.Level3.Level4
          private set
        fun setField3(value: Level1.Level2.Level3.Level4): Level1.Level2.Level3.BuilderLevel3 {
          field3 = value
          return this
        }
        init {
          this.field3 = field3
        }
        fun readFrom (input: CodedInputStream): Level1.Level2.Level3.BuilderLevel3 {
          input.readTag(3, WireType.LENGTH_DELIMITED)
          val expectedSize = input.readInt32NoTag()
          field3.mergeFrom(input)
          if (expectedSize != field3.getSize()) { throw InvalidProtocolBufferException ("Expected size ${expectedSize} got ${field3.getSize()}") }
          return this
 }
        fun build(): Level1.Level2.Level3 {
          return Level1.Level2.Level3(field3)
        }
        fun parseFieldFrom(input: CodedInputStream): Boolean {
          if (input.isAtEnd()) { return false }
          val tag = input.readInt32NoTag()
          if (tag == 0) { return false } 
          val fieldNumber = WireFormat.getTagFieldNumber(tag)
          val wireType = WireFormat.getTagWireType(tag)
          when(fieldNumber) {
            3 -> {
              input.readTag(3, WireType.LENGTH_DELIMITED)
              val expectedSize = input.readInt32NoTag()
              field3.mergeFrom(input)
              if (expectedSize != field3.getSize()) { throw InvalidProtocolBufferException ("Expected size ${expectedSize} got ${field3.getSize()}") }
            }
          }
          return true}
        fun parseFrom(input: CodedInputStream): Level1.Level2.Level3.BuilderLevel3 {
          while(parseFieldFrom(input)) {}
          return this
        }
        fun getSize(): Int {
          var size = 0
          size += field3.getSize() + WireFormat.getTagSize(3, WireType.LENGTH_DELIMITED) + WireFormat.getVarint32Size(field3.getSize())
          return size
        }
      }
      fun mergeWith (other: Level1.Level2.Level3) {
        field3 = other.field3
      }
      fun mergeFrom (input: CodedInputStream) {
        val builder = Level1.Level2.Level3.BuilderLevel3()
        mergeWith(builder.parseFrom(input).build())}
      fun getSize(): Int {
        var size = 0
        size += field3.getSize() + WireFormat.getTagSize(3, WireType.LENGTH_DELIMITED) + WireFormat.getVarint32Size(field3.getSize())
        return size
      }
    }
    fun writeTo (output: CodedOutputStream): Unit {
      output.writeTag(2, WireType.LENGTH_DELIMITED)
      output.writeInt32NoTag(field2.getSize())
      field2.writeTo(output)
    }
    class BuilderLevel2 constructor (field2: Level1.Level2.Level3 = Level1.Level2.Level3.BuilderLevel3().build()) {
      var field2 : Level1.Level2.Level3
        private set
      fun setField2(value: Level1.Level2.Level3): Level1.Level2.BuilderLevel2 {
        field2 = value
        return this
      }
      init {
        this.field2 = field2
      }
      fun readFrom (input: CodedInputStream): Level1.Level2.BuilderLevel2 {
        input.readTag(2, WireType.LENGTH_DELIMITED)
        val expectedSize = input.readInt32NoTag()
        field2.mergeFrom(input)
        if (expectedSize != field2.getSize()) { throw InvalidProtocolBufferException ("Expected size ${expectedSize} got ${field2.getSize()}") }
        return this
 }
      fun build(): Level1.Level2 {
        return Level1.Level2(field2)
      }
      fun parseFieldFrom(input: CodedInputStream): Boolean {
        if (input.isAtEnd()) { return false }
        val tag = input.readInt32NoTag()
        if (tag == 0) { return false } 
        val fieldNumber = WireFormat.getTagFieldNumber(tag)
        val wireType = WireFormat.getTagWireType(tag)
        when(fieldNumber) {
          2 -> {
            input.readTag(2, WireType.LENGTH_DELIMITED)
            val expectedSize = input.readInt32NoTag()
            field2.mergeFrom(input)
            if (expectedSize != field2.getSize()) { throw InvalidProtocolBufferException ("Expected size ${expectedSize} got ${field2.getSize()}") }
          }
        }
        return true}
      fun parseFrom(input: CodedInputStream): Level1.Level2.BuilderLevel2 {
        while(parseFieldFrom(input)) {}
        return this
      }
      fun getSize(): Int {
        var size = 0
        size += field2.getSize() + WireFormat.getTagSize(2, WireType.LENGTH_DELIMITED) + WireFormat.getVarint32Size(field2.getSize())
        return size
      }
    }
    fun mergeWith (other: Level1.Level2) {
      field2 = other.field2
    }
    fun mergeFrom (input: CodedInputStream) {
      val builder = Level1.Level2.BuilderLevel2()
      mergeWith(builder.parseFrom(input).build())}
    fun getSize(): Int {
      var size = 0
      size += field2.getSize() + WireFormat.getTagSize(2, WireType.LENGTH_DELIMITED) + WireFormat.getVarint32Size(field2.getSize())
      return size
    }
  }
  fun writeTo (output: CodedOutputStream): Unit {
    output.writeTag(1, WireType.LENGTH_DELIMITED)
    output.writeInt32NoTag(field1.getSize())
    field1.writeTo(output)
  }
  class BuilderLevel1 constructor (field1: Level1.Level2 = Level1.Level2.BuilderLevel2().build()) {
    var field1 : Level1.Level2
      private set
    fun setField1(value: Level1.Level2): Level1.BuilderLevel1 {
      field1 = value
      return this
    }
    init {
      this.field1 = field1
    }
    fun readFrom (input: CodedInputStream): Level1.BuilderLevel1 {
      input.readTag(1, WireType.LENGTH_DELIMITED)
      val expectedSize = input.readInt32NoTag()
      field1.mergeFrom(input)
      if (expectedSize != field1.getSize()) { throw InvalidProtocolBufferException ("Expected size ${expectedSize} got ${field1.getSize()}") }
      return this
 }
    fun build(): Level1 {
      return Level1(field1)
    }
    fun parseFieldFrom(input: CodedInputStream): Boolean {
      if (input.isAtEnd()) { return false }
      val tag = input.readInt32NoTag()
      if (tag == 0) { return false } 
      val fieldNumber = WireFormat.getTagFieldNumber(tag)
      val wireType = WireFormat.getTagWireType(tag)
      when(fieldNumber) {
        1 -> {
          input.readTag(1, WireType.LENGTH_DELIMITED)
          val expectedSize = input.readInt32NoTag()
          field1.mergeFrom(input)
          if (expectedSize != field1.getSize()) { throw InvalidProtocolBufferException ("Expected size ${expectedSize} got ${field1.getSize()}") }
        }
      }
      return true}
    fun parseFrom(input: CodedInputStream): Level1.BuilderLevel1 {
      while(parseFieldFrom(input)) {}
      return this
    }
    fun getSize(): Int {
      var size = 0
      size += field1.getSize() + WireFormat.getTagSize(1, WireType.LENGTH_DELIMITED) + WireFormat.getVarint32Size(field1.getSize())
      return size
    }
  }
  fun mergeWith (other: Level1) {
    field1 = other.field1
  }
  fun mergeFrom (input: CodedInputStream) {
    val builder = Level1.BuilderLevel1()
    mergeWith(builder.parseFrom(input).build())}
  fun getSize(): Int {
    var size = 0
    size += field1.getSize() + WireFormat.getTagSize(1, WireType.LENGTH_DELIMITED) + WireFormat.getVarint32Size(field1.getSize())
    return size
  }
 }