gen-go/module1/ttypes.go

// Autogenerated by Thrift Compiler (facebook)
// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
// @generated

package module1

import (
	"bytes"
	"context"
	"sync"
	"fmt"
	thrift "github.com/facebook/fbthrift/thrift/lib/go/thrift"
	module00 "module0"

)

// (needed to ensure safety because of naive import list construction.)
var _ = thrift.ZERO
var _ = fmt.Printf
var _ = sync.Mutex{}
var _ = bytes.Equal
var _ = context.Background

var _ = module00.GoUnusedProtection__
var GoUnusedProtection__ int;

type Plate = string

func PlatePtr(v Plate) *Plate { return &v }

type State = string

func StatePtr(v State) *State { return &v }

type Year = int32

func YearPtr(v Year) *Year { return &v }

type Drivers = []string

func DriversPtr(v Drivers) *Drivers { return &v }

type Accessory = module00.Accessory

func AccessoryPtr(v Accessory) *Accessory { return &v }

func NewAccessory() *Accessory { return module00.NewAccessory() }

type PartName = module00.PartName

func PartNamePtr(v PartName) *PartName { return &v }

func NewPartName() *PartName { return module00.NewPartName() }

type Car = Automobile

func CarPtr(v Car) *Car { return &v }

func NewCar() *Car { return NewAutomobile() }

// Attributes:
//  - Plate
//  - PreviousPlate
//  - FirstPlate
//  - Year
//  - Drivers
//  - Accessories
//  - PartNames
type Automobile struct {
  Plate Plate `thrift:"plate,1" db:"plate" json:"plate"`
  PreviousPlate *Plate `thrift:"previous_plate,2,optional" db:"previous_plate" json:"previous_plate,omitempty"`
  FirstPlate Plate `thrift:"first_plate,3,optional" db:"first_plate" json:"first_plate,omitempty"`
  Year Year `thrift:"year,4" db:"year" json:"year"`
  Drivers Drivers `thrift:"drivers,5" db:"drivers" json:"drivers"`
  Accessories []*Accessory `thrift:"Accessories,6" db:"Accessories" json:"Accessories"`
  PartNames map[int32]*PartName `thrift:"PartNames,7" db:"PartNames" json:"PartNames"`
}

func NewAutomobile() *Automobile {
  return &Automobile{
    FirstPlate: "0000",
  }
}


func (p *Automobile) GetPlate() Plate {
  return p.Plate
}
var Automobile_PreviousPlate_DEFAULT Plate
func (p *Automobile) GetPreviousPlate() Plate {
  if !p.IsSetPreviousPlate() {
    return Automobile_PreviousPlate_DEFAULT
  }
return *p.PreviousPlate
}
var Automobile_FirstPlate_DEFAULT Plate = "0000"

func (p *Automobile) GetFirstPlate() Plate {
  return p.FirstPlate
}

func (p *Automobile) GetYear() Year {
  return p.Year
}

func (p *Automobile) GetDrivers() Drivers {
  return p.Drivers
}

func (p *Automobile) GetAccessories() []*Accessory {
  return p.Accessories
}

func (p *Automobile) GetPartNames() map[int32]*PartName {
  return p.PartNames
}
func (p *Automobile) IsSetPreviousPlate() bool {
  return p != nil && p.PreviousPlate != nil
}

func (p *Automobile) IsSetFirstPlate() bool {
  return p != nil && p.FirstPlate != Automobile_FirstPlate_DEFAULT
}

type AutomobileBuilder struct {
  obj *Automobile
}

func NewAutomobileBuilder() *AutomobileBuilder{
  return &AutomobileBuilder{
    obj: NewAutomobile(),
  }
}

func (p AutomobileBuilder) Emit() *Automobile{
  return &Automobile{
    Plate: p.obj.Plate,
    PreviousPlate: p.obj.PreviousPlate,
    FirstPlate: p.obj.FirstPlate,
    Year: p.obj.Year,
    Drivers: p.obj.Drivers,
    Accessories: p.obj.Accessories,
    PartNames: p.obj.PartNames,
  }
}

func (a *AutomobileBuilder) Plate(plate Plate) *AutomobileBuilder {
  a.obj.Plate = plate
  return a
}

func (a *AutomobileBuilder) PreviousPlate(previousPlate *Plate) *AutomobileBuilder {
  a.obj.PreviousPlate = previousPlate
  return a
}

func (a *AutomobileBuilder) FirstPlate(firstPlate Plate) *AutomobileBuilder {
  a.obj.FirstPlate = firstPlate
  return a
}

func (a *AutomobileBuilder) Year(year Year) *AutomobileBuilder {
  a.obj.Year = year
  return a
}

func (a *AutomobileBuilder) Drivers(drivers Drivers) *AutomobileBuilder {
  a.obj.Drivers = drivers
  return a
}

func (a *AutomobileBuilder) Accessories(accessories []*Accessory) *AutomobileBuilder {
  a.obj.Accessories = accessories
  return a
}

func (a *AutomobileBuilder) PartNames(partNames map[int32]*PartName) *AutomobileBuilder {
  a.obj.PartNames = partNames
  return a
}

func (a *Automobile) SetPlate(plate Plate) *Automobile {
  a.Plate = plate
  return a
}

func (a *Automobile) SetPreviousPlate(previousPlate *Plate) *Automobile {
  a.PreviousPlate = previousPlate
  return a
}

func (a *Automobile) SetFirstPlate(firstPlate Plate) *Automobile {
  a.FirstPlate = firstPlate
  return a
}

func (a *Automobile) SetYear(year Year) *Automobile {
  a.Year = year
  return a
}

func (a *Automobile) SetDrivers(drivers Drivers) *Automobile {
  a.Drivers = drivers
  return a
}

func (a *Automobile) SetAccessories(accessories []*Accessory) *Automobile {
  a.Accessories = accessories
  return a
}

func (a *Automobile) SetPartNames(partNames map[int32]*PartName) *Automobile {
  a.PartNames = partNames
  return a
}

func (p *Automobile) Read(iprot thrift.Protocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if err := p.ReadField1(iprot); err != nil {
        return err
      }
    case 2:
      if err := p.ReadField2(iprot); err != nil {
        return err
      }
    case 3:
      if err := p.ReadField3(iprot); err != nil {
        return err
      }
    case 4:
      if err := p.ReadField4(iprot); err != nil {
        return err
      }
    case 5:
      if err := p.ReadField5(iprot); err != nil {
        return err
      }
    case 6:
      if err := p.ReadField6(iprot); err != nil {
        return err
      }
    case 7:
      if err := p.ReadField7(iprot); err != nil {
        return err
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *Automobile)  ReadField1(iprot thrift.Protocol) error {
  if v, err := iprot.ReadString(); err != nil {
    return thrift.PrependError("error reading field 1: ", err)
  } else {
    temp := Plate(v)
    p.Plate = temp
  }
  return nil
}

func (p *Automobile)  ReadField2(iprot thrift.Protocol) error {
  if v, err := iprot.ReadString(); err != nil {
    return thrift.PrependError("error reading field 2: ", err)
  } else {
    temp := Plate(v)
    p.PreviousPlate = &temp
  }
  return nil
}

func (p *Automobile)  ReadField3(iprot thrift.Protocol) error {
  if v, err := iprot.ReadString(); err != nil {
    return thrift.PrependError("error reading field 3: ", err)
  } else {
    temp := Plate(v)
    p.FirstPlate = temp
  }
  return nil
}

func (p *Automobile)  ReadField4(iprot thrift.Protocol) error {
  if v, err := iprot.ReadI32(); err != nil {
    return thrift.PrependError("error reading field 4: ", err)
  } else {
    temp := Year(v)
    p.Year = temp
  }
  return nil
}

func (p *Automobile)  ReadField5(iprot thrift.Protocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make(Drivers, 0, size)
  p.Drivers =  tSlice
  for i := 0; i < size; i ++ {
    var _elem1 string
    if v, err := iprot.ReadString(); err != nil {
      return thrift.PrependError("error reading field 0: ", err)
    } else {
      _elem1 = v
    }
    p.Drivers = append(p.Drivers, _elem1)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *Automobile)  ReadField6(iprot thrift.Protocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make([]*Accessory, 0, size)
  p.Accessories =  tSlice
  for i := 0; i < size; i ++ {
    _elem2 := NewAccessory()
    if err := _elem2.Read(iprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem2), err)
    }
    p.Accessories = append(p.Accessories, _elem2)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *Automobile)  ReadField7(iprot thrift.Protocol) error {
  _, _, size, err := iprot.ReadMapBegin()
  if err != nil {
    return thrift.PrependError("error reading map begin: ", err)
  }
  tMap := make(map[int32]*PartName, size)
  p.PartNames =  tMap
  for i := 0; i < size; i ++ {
    var _key3 int32
    if v, err := iprot.ReadI32(); err != nil {
      return thrift.PrependError("error reading field 0: ", err)
    } else {
      _key3 = v
    }
    _val4 := NewPartName()
    if err := _val4.Read(iprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _val4), err)
    }
    p.PartNames[_key3] = _val4
  }
  if err := iprot.ReadMapEnd(); err != nil {
    return thrift.PrependError("error reading map end: ", err)
  }
  return nil
}

func (p *Automobile) Write(oprot thrift.Protocol) error {
  if err := oprot.WriteStructBegin("Automobile"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if err := p.writeField1(oprot); err != nil { return err }
  if err := p.writeField2(oprot); err != nil { return err }
  if err := p.writeField3(oprot); err != nil { return err }
  if err := p.writeField4(oprot); err != nil { return err }
  if err := p.writeField5(oprot); err != nil { return err }
  if err := p.writeField6(oprot); err != nil { return err }
  if err := p.writeField7(oprot); err != nil { return err }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *Automobile) writeField1(oprot thrift.Protocol) (err error) {
  if err := oprot.WriteFieldBegin("plate", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:plate: ", p), err) }
  if err := oprot.WriteString(string(p.Plate)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.plate (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:plate: ", p), err) }
  return err
}

func (p *Automobile) writeField2(oprot thrift.Protocol) (err error) {
  if p.IsSetPreviousPlate() {
    if err := oprot.WriteFieldBegin("previous_plate", thrift.STRING, 2); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:previous_plate: ", p), err) }
    if err := oprot.WriteString(string(*p.PreviousPlate)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.previous_plate (2) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 2:previous_plate: ", p), err) }
  }
  return err
}

func (p *Automobile) writeField3(oprot thrift.Protocol) (err error) {
  if p.IsSetFirstPlate() {
    if err := oprot.WriteFieldBegin("first_plate", thrift.STRING, 3); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:first_plate: ", p), err) }
    if err := oprot.WriteString(string(p.FirstPlate)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.first_plate (3) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 3:first_plate: ", p), err) }
  }
  return err
}

func (p *Automobile) writeField4(oprot thrift.Protocol) (err error) {
  if err := oprot.WriteFieldBegin("year", thrift.I32, 4); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:year: ", p), err) }
  if err := oprot.WriteI32(int32(p.Year)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.year (4) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 4:year: ", p), err) }
  return err
}

func (p *Automobile) writeField5(oprot thrift.Protocol) (err error) {
  if err := oprot.WriteFieldBegin("drivers", thrift.LIST, 5); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:drivers: ", p), err) }
  if err := oprot.WriteListBegin(thrift.STRING, len(p.Drivers)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.Drivers {
    if err := oprot.WriteString(string(v)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
  }
  if err := oprot.WriteListEnd(); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 5:drivers: ", p), err) }
  return err
}

func (p *Automobile) writeField6(oprot thrift.Protocol) (err error) {
  if err := oprot.WriteFieldBegin("Accessories", thrift.LIST, 6); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 6:Accessories: ", p), err) }
  if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Accessories)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.Accessories {
    if err := v.Write(oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
    }
  }
  if err := oprot.WriteListEnd(); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 6:Accessories: ", p), err) }
  return err
}

func (p *Automobile) writeField7(oprot thrift.Protocol) (err error) {
  if err := oprot.WriteFieldBegin("PartNames", thrift.MAP, 7); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 7:PartNames: ", p), err) }
  if err := oprot.WriteMapBegin(thrift.I32, thrift.STRUCT, len(p.PartNames)); err != nil {
    return thrift.PrependError("error writing map begin: ", err)
  }
  for k, v := range p.PartNames {
    if err := oprot.WriteI32(int32(k)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
    if err := v.Write(oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
    }
  }
  if err := oprot.WriteMapEnd(); err != nil {
    return thrift.PrependError("error writing map end: ", err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 7:PartNames: ", p), err) }
  return err
}

func (p *Automobile) String() string {
  if p == nil {
    return "<nil>"
  }

  plateVal := fmt.Sprintf("%v", p.Plate)
  var previousPlateVal string
  if p.PreviousPlate == nil {
    previousPlateVal = "<nil>"
  } else {
    previousPlateVal = fmt.Sprintf("%v", *p.PreviousPlate)
  }
  firstPlateVal := fmt.Sprintf("%v", p.FirstPlate)
  yearVal := fmt.Sprintf("%v", p.Year)
  driversVal := fmt.Sprintf("%v", p.Drivers)
  accessoriesVal := fmt.Sprintf("%v", p.Accessories)
  partNamesVal := fmt.Sprintf("%v", p.PartNames)
  return fmt.Sprintf("Automobile({Plate:%s PreviousPlate:%s FirstPlate:%s Year:%s Drivers:%s Accessories:%s PartNames:%s})", plateVal, previousPlateVal, firstPlateVal, yearVal, driversVal, accessoriesVal, partNamesVal)
}

// Attributes:
//  - Num
//  - Strval
type MapKey struct {
  Num int64 `thrift:"num,1" db:"num" json:"num"`
  Strval string `thrift:"strval,2" db:"strval" json:"strval"`
}

func NewMapKey() *MapKey {
  return &MapKey{}
}


func (p *MapKey) GetNum() int64 {
  return p.Num
}

func (p *MapKey) GetStrval() string {
  return p.Strval
}
type MapKeyBuilder struct {
  obj *MapKey
}

func NewMapKeyBuilder() *MapKeyBuilder{
  return &MapKeyBuilder{
    obj: NewMapKey(),
  }
}

func (p MapKeyBuilder) Emit() *MapKey{
  return &MapKey{
    Num: p.obj.Num,
    Strval: p.obj.Strval,
  }
}

func (m *MapKeyBuilder) Num(num int64) *MapKeyBuilder {
  m.obj.Num = num
  return m
}

func (m *MapKeyBuilder) Strval(strval string) *MapKeyBuilder {
  m.obj.Strval = strval
  return m
}

func (m *MapKey) SetNum(num int64) *MapKey {
  m.Num = num
  return m
}

func (m *MapKey) SetStrval(strval string) *MapKey {
  m.Strval = strval
  return m
}

func (p *MapKey) Read(iprot thrift.Protocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if err := p.ReadField1(iprot); err != nil {
        return err
      }
    case 2:
      if err := p.ReadField2(iprot); err != nil {
        return err
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *MapKey)  ReadField1(iprot thrift.Protocol) error {
  if v, err := iprot.ReadI64(); err != nil {
    return thrift.PrependError("error reading field 1: ", err)
  } else {
    p.Num = v
  }
  return nil
}

func (p *MapKey)  ReadField2(iprot thrift.Protocol) error {
  if v, err := iprot.ReadString(); err != nil {
    return thrift.PrependError("error reading field 2: ", err)
  } else {
    p.Strval = v
  }
  return nil
}

func (p *MapKey) Write(oprot thrift.Protocol) error {
  if err := oprot.WriteStructBegin("MapKey"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if err := p.writeField1(oprot); err != nil { return err }
  if err := p.writeField2(oprot); err != nil { return err }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *MapKey) writeField1(oprot thrift.Protocol) (err error) {
  if err := oprot.WriteFieldBegin("num", thrift.I64, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:num: ", p), err) }
  if err := oprot.WriteI64(int64(p.Num)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.num (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:num: ", p), err) }
  return err
}

func (p *MapKey) writeField2(oprot thrift.Protocol) (err error) {
  if err := oprot.WriteFieldBegin("strval", thrift.STRING, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:strval: ", p), err) }
  if err := oprot.WriteString(string(p.Strval)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.strval (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:strval: ", p), err) }
  return err
}

func (p *MapKey) String() string {
  if p == nil {
    return "<nil>"
  }

  numVal := fmt.Sprintf("%v", p.Num)
  strvalVal := fmt.Sprintf("%v", p.Strval)
  return fmt.Sprintf("MapKey({Num:%s Strval:%s})", numVal, strvalVal)
}

// Attributes:
//  - Mapval
type MapContainer struct {
  Mapval map[MapKey]string `thrift:"mapval,1" db:"mapval" json:"mapval"`
}

func NewMapContainer() *MapContainer {
  return &MapContainer{}
}


func (p *MapContainer) GetMapval() map[MapKey]string {
  return p.Mapval
}
type MapContainerBuilder struct {
  obj *MapContainer
}

func NewMapContainerBuilder() *MapContainerBuilder{
  return &MapContainerBuilder{
    obj: NewMapContainer(),
  }
}

func (p MapContainerBuilder) Emit() *MapContainer{
  return &MapContainer{
    Mapval: p.obj.Mapval,
  }
}

func (m *MapContainerBuilder) Mapval(mapval map[MapKey]string) *MapContainerBuilder {
  m.obj.Mapval = mapval
  return m
}

func (m *MapContainer) SetMapval(mapval map[MapKey]string) *MapContainer {
  m.Mapval = mapval
  return m
}

func (p *MapContainer) Read(iprot thrift.Protocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if err := p.ReadField1(iprot); err != nil {
        return err
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *MapContainer)  ReadField1(iprot thrift.Protocol) error {
  _, _, size, err := iprot.ReadMapBegin()
  if err != nil {
    return thrift.PrependError("error reading map begin: ", err)
  }
  tMap := make(map[MapKey]string, size)
  p.Mapval =  tMap
  for i := 0; i < size; i ++ {
    _key5 := NewMapKey()
    if err := _key5.Read(iprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _key5), err)
    }
    var _val6 string
    if v, err := iprot.ReadString(); err != nil {
      return thrift.PrependError("error reading field 0: ", err)
    } else {
      _val6 = v
    }
    p.Mapval[*_key5] = _val6
  }
  if err := iprot.ReadMapEnd(); err != nil {
    return thrift.PrependError("error reading map end: ", err)
  }
  return nil
}

func (p *MapContainer) Write(oprot thrift.Protocol) error {
  if err := oprot.WriteStructBegin("MapContainer"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if err := p.writeField1(oprot); err != nil { return err }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *MapContainer) writeField1(oprot thrift.Protocol) (err error) {
  if err := oprot.WriteFieldBegin("mapval", thrift.MAP, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:mapval: ", p), err) }
  if err := oprot.WriteMapBegin(thrift.STRUCT, thrift.STRING, len(p.Mapval)); err != nil {
    return thrift.PrependError("error writing map begin: ", err)
  }
  for k, v := range p.Mapval {
    if err := k.Write(oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", k), err)
    }
    if err := oprot.WriteString(string(v)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) }
  }
  if err := oprot.WriteMapEnd(); err != nil {
    return thrift.PrependError("error writing map end: ", err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:mapval: ", p), err) }
  return err
}

func (p *MapContainer) String() string {
  if p == nil {
    return "<nil>"
  }

  mapvalVal := fmt.Sprintf("%v", p.Mapval)
  return fmt.Sprintf("MapContainer({Mapval:%s})", mapvalVal)
}

// Attributes:
//  - Automobile
//  - Car
type Pair struct {
  Automobile *Automobile `thrift:"automobile,1" db:"automobile" json:"automobile"`
  Car *Car `thrift:"car,2" db:"car" json:"car"`
}

func NewPair() *Pair {
  return &Pair{
    Automobile: NewAutomobile(),
    Car: NewCar(),
  }
}

var Pair_Automobile_DEFAULT *Automobile
func (p *Pair) GetAutomobile() *Automobile {
  if !p.IsSetAutomobile() {
    return Pair_Automobile_DEFAULT
  }
return p.Automobile
}
var Pair_Car_DEFAULT *Car
func (p *Pair) GetCar() *Car {
  if !p.IsSetCar() {
    return Pair_Car_DEFAULT
  }
return p.Car
}
func (p *Pair) IsSetAutomobile() bool {
  return p != nil && p.Automobile != nil
}

func (p *Pair) IsSetCar() bool {
  return p != nil && p.Car != nil
}

type PairBuilder struct {
  obj *Pair
}

func NewPairBuilder() *PairBuilder{
  return &PairBuilder{
    obj: NewPair(),
  }
}

func (p PairBuilder) Emit() *Pair{
  return &Pair{
    Automobile: p.obj.Automobile,
    Car: p.obj.Car,
  }
}

func (p *PairBuilder) Automobile(automobile *Automobile) *PairBuilder {
  p.obj.Automobile = automobile
  return p
}

func (p *PairBuilder) Car(car *Car) *PairBuilder {
  p.obj.Car = car
  return p
}

func (p *Pair) SetAutomobile(automobile *Automobile) *Pair {
  p.Automobile = automobile
  return p
}

func (p *Pair) SetCar(car *Car) *Pair {
  p.Car = car
  return p
}

func (p *Pair) Read(iprot thrift.Protocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if err := p.ReadField1(iprot); err != nil {
        return err
      }
    case 2:
      if err := p.ReadField2(iprot); err != nil {
        return err
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *Pair)  ReadField1(iprot thrift.Protocol) error {
  p.Automobile = NewAutomobile()
  if err := p.Automobile.Read(iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Automobile), err)
  }
  return nil
}

func (p *Pair)  ReadField2(iprot thrift.Protocol) error {
  p.Car = NewCar()
  if err := p.Car.Read(iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Car), err)
  }
  return nil
}

func (p *Pair) Write(oprot thrift.Protocol) error {
  if err := oprot.WriteStructBegin("Pair"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if err := p.writeField1(oprot); err != nil { return err }
  if err := p.writeField2(oprot); err != nil { return err }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *Pair) writeField1(oprot thrift.Protocol) (err error) {
  if err := oprot.WriteFieldBegin("automobile", thrift.STRUCT, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:automobile: ", p), err) }
  if err := p.Automobile.Write(oprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Automobile), err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:automobile: ", p), err) }
  return err
}

func (p *Pair) writeField2(oprot thrift.Protocol) (err error) {
  if err := oprot.WriteFieldBegin("car", thrift.STRUCT, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:car: ", p), err) }
  if err := p.Car.Write(oprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Car), err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:car: ", p), err) }
  return err
}

func (p *Pair) String() string {
  if p == nil {
    return "<nil>"
  }

  var automobileVal string
  if p.Automobile == nil {
    automobileVal = "<nil>"
  } else {
    automobileVal = fmt.Sprintf("%v", p.Automobile)
  }
  var carVal string
  if p.Car == nil {
    carVal = "<nil>"
  } else {
    carVal = fmt.Sprintf("%v", p.Car)
  }
  return fmt.Sprintf("Pair({Automobile:%s Car:%s})", automobileVal, carVal)
}

// Attributes:
//  - Automobiles
//  - Cars
type Collection struct {
  Automobiles []*Automobile `thrift:"automobiles,1" db:"automobiles" json:"automobiles"`
  Cars []*Car `thrift:"cars,2" db:"cars" json:"cars"`
}

func NewCollection() *Collection {
  return &Collection{}
}


func (p *Collection) GetAutomobiles() []*Automobile {
  return p.Automobiles
}

func (p *Collection) GetCars() []*Car {
  return p.Cars
}
type CollectionBuilder struct {
  obj *Collection
}

func NewCollectionBuilder() *CollectionBuilder{
  return &CollectionBuilder{
    obj: NewCollection(),
  }
}

func (p CollectionBuilder) Emit() *Collection{
  return &Collection{
    Automobiles: p.obj.Automobiles,
    Cars: p.obj.Cars,
  }
}

func (c *CollectionBuilder) Automobiles(automobiles []*Automobile) *CollectionBuilder {
  c.obj.Automobiles = automobiles
  return c
}

func (c *CollectionBuilder) Cars(cars []*Car) *CollectionBuilder {
  c.obj.Cars = cars
  return c
}

func (c *Collection) SetAutomobiles(automobiles []*Automobile) *Collection {
  c.Automobiles = automobiles
  return c
}

func (c *Collection) SetCars(cars []*Car) *Collection {
  c.Cars = cars
  return c
}

func (p *Collection) Read(iprot thrift.Protocol) error {
  if _, err := iprot.ReadStructBegin(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
  }


  for {
    _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
    if err != nil {
      return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
    }
    if fieldTypeId == thrift.STOP { break; }
    switch fieldId {
    case 1:
      if err := p.ReadField1(iprot); err != nil {
        return err
      }
    case 2:
      if err := p.ReadField2(iprot); err != nil {
        return err
      }
    default:
      if err := iprot.Skip(fieldTypeId); err != nil {
        return err
      }
    }
    if err := iprot.ReadFieldEnd(); err != nil {
      return err
    }
  }
  if err := iprot.ReadStructEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
  }
  return nil
}

func (p *Collection)  ReadField1(iprot thrift.Protocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make([]*Automobile, 0, size)
  p.Automobiles =  tSlice
  for i := 0; i < size; i ++ {
    _elem7 := NewAutomobile()
    if err := _elem7.Read(iprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem7), err)
    }
    p.Automobiles = append(p.Automobiles, _elem7)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *Collection)  ReadField2(iprot thrift.Protocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make([]*Car, 0, size)
  p.Cars =  tSlice
  for i := 0; i < size; i ++ {
    _elem8 := NewCar()
    if err := _elem8.Read(iprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem8), err)
    }
    p.Cars = append(p.Cars, _elem8)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *Collection) Write(oprot thrift.Protocol) error {
  if err := oprot.WriteStructBegin("Collection"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if err := p.writeField1(oprot); err != nil { return err }
  if err := p.writeField2(oprot); err != nil { return err }
  if err := oprot.WriteFieldStop(); err != nil {
    return thrift.PrependError("write field stop error: ", err) }
  if err := oprot.WriteStructEnd(); err != nil {
    return thrift.PrependError("write struct stop error: ", err) }
  return nil
}

func (p *Collection) writeField1(oprot thrift.Protocol) (err error) {
  if err := oprot.WriteFieldBegin("automobiles", thrift.LIST, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:automobiles: ", p), err) }
  if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Automobiles)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.Automobiles {
    if err := v.Write(oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
    }
  }
  if err := oprot.WriteListEnd(); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:automobiles: ", p), err) }
  return err
}

func (p *Collection) writeField2(oprot thrift.Protocol) (err error) {
  if err := oprot.WriteFieldBegin("cars", thrift.LIST, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:cars: ", p), err) }
  if err := oprot.WriteListBegin(thrift.STRUCT, len(p.Cars)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.Cars {
    if err := v.Write(oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
    }
  }
  if err := oprot.WriteListEnd(); err != nil {
    return thrift.PrependError("error writing list end: ", err)
  }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:cars: ", p), err) }
  return err
}

func (p *Collection) String() string {
  if p == nil {
    return "<nil>"
  }

  automobilesVal := fmt.Sprintf("%v", p.Automobiles)
  carsVal := fmt.Sprintf("%v", p.Cars)
  return fmt.Sprintf("Collection({Automobiles:%s Cars:%s})", automobilesVal, carsVal)
}