car.go

// Code generated by thriftgo (0.2.5). DO NOT EDIT.

package base

import (
	"database/sql"
	"database/sql/driver"
	"fmt"
	"github.com/apache/thrift/lib/go/thrift"
	"strings"
)

type CarStatus int64

const (
	CarStatus_CS_NOT_SPECIFIED CarStatus = 0
	CarStatus_LOCKED           CarStatus = 1
	CarStatus_UNLOCKING        CarStatus = 2
	CarStatus_UNLOCKED         CarStatus = 3
	CarStatus_LOCKING          CarStatus = 4
)

func (p CarStatus) String() string {
	switch p {
	case CarStatus_CS_NOT_SPECIFIED:
		return "CS_NOT_SPECIFIED"
	case CarStatus_LOCKED:
		return "LOCKED"
	case CarStatus_UNLOCKING:
		return "UNLOCKING"
	case CarStatus_UNLOCKED:
		return "UNLOCKED"
	case CarStatus_LOCKING:
		return "LOCKING"
	}
	return "<UNSET>"
}

func CarStatusFromString(s string) (CarStatus, error) {
	switch s {
	case "CS_NOT_SPECIFIED":
		return CarStatus_CS_NOT_SPECIFIED, nil
	case "LOCKED":
		return CarStatus_LOCKED, nil
	case "UNLOCKING":
		return CarStatus_UNLOCKING, nil
	case "UNLOCKED":
		return CarStatus_UNLOCKED, nil
	case "LOCKING":
		return CarStatus_LOCKING, nil
	}
	return CarStatus(0), fmt.Errorf("not a valid CarStatus string")
}

func CarStatusPtr(v CarStatus) *CarStatus { return &v }
func (p *CarStatus) Scan(value interface{}) (err error) {
	var result sql.NullInt64
	err = result.Scan(value)
	*p = CarStatus(result.Int64)
	return
}

func (p *CarStatus) Value() (driver.Value, error) {
	if p == nil {
		return nil, nil
	}
	return int64(*p), nil
}

type CarEntity struct {
	Id  string `thrift:"id,1" frugal:"1,default,string" json:"id"`
	Car *Car   `thrift:"car,2" frugal:"2,default,Car" json:"car"`
}

func NewCarEntity() *CarEntity {
	return &CarEntity{}
}

func (p *CarEntity) InitDefault() {
	*p = CarEntity{}
}

func (p *CarEntity) GetId() (v string) {
	return p.Id
}

var CarEntity_Car_DEFAULT *Car

func (p *CarEntity) GetCar() (v *Car) {
	if !p.IsSetCar() {
		return CarEntity_Car_DEFAULT
	}
	return p.Car
}
func (p *CarEntity) SetId(val string) {
	p.Id = val
}
func (p *CarEntity) SetCar(val *Car) {
	p.Car = val
}

var fieldIDToName_CarEntity = map[int16]string{
	1: "id",
	2: "car",
}

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

func (p *CarEntity) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 2:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_CarEntity[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *CarEntity) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return err
	} else {
		p.Id = v
	}
	return nil
}

func (p *CarEntity) ReadField2(iprot thrift.TProtocol) error {
	p.Car = NewCar()
	if err := p.Car.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *CarEntity) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("CarEntity"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}
		if err = p.writeField2(oprot); err != nil {
			fieldId = 2
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *CarEntity) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("id", thrift.STRING, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.Id); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

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

func (p *CarEntity) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("CarEntity(%+v)", *p)
}

func (p *CarEntity) DeepEqual(ano *CarEntity) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Id) {
		return false
	}
	if !p.Field2DeepEqual(ano.Car) {
		return false
	}
	return true
}

func (p *CarEntity) Field1DeepEqual(src string) bool {

	if strings.Compare(p.Id, src) != 0 {
		return false
	}
	return true
}
func (p *CarEntity) Field2DeepEqual(src *Car) bool {

	if !p.Car.DeepEqual(src) {
		return false
	}
	return true
}

type Driver struct {
	Id        string `thrift:"id,1" frugal:"1,default,string" json:"id"`
	AvatarUrl string `thrift:"avatar_url,2" frugal:"2,default,string" json:"avatar_url"`
}

func NewDriver() *Driver {
	return &Driver{}
}

func (p *Driver) InitDefault() {
	*p = Driver{}
}

func (p *Driver) GetId() (v string) {
	return p.Id
}

func (p *Driver) GetAvatarUrl() (v string) {
	return p.AvatarUrl
}
func (p *Driver) SetId(val string) {
	p.Id = val
}
func (p *Driver) SetAvatarUrl(val string) {
	p.AvatarUrl = val
}

var fieldIDToName_Driver = map[int16]string{
	1: "id",
	2: "avatar_url",
}

func (p *Driver) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 2:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_Driver[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *Driver) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return err
	} else {
		p.Id = v
	}
	return nil
}

func (p *Driver) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return err
	} else {
		p.AvatarUrl = v
	}
	return nil
}

func (p *Driver) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("Driver"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}
		if err = p.writeField2(oprot); err != nil {
			fieldId = 2
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *Driver) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("id", thrift.STRING, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.Id); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *Driver) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("avatar_url", thrift.STRING, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.AvatarUrl); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err)
}

func (p *Driver) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("Driver(%+v)", *p)
}

func (p *Driver) DeepEqual(ano *Driver) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Id) {
		return false
	}
	if !p.Field2DeepEqual(ano.AvatarUrl) {
		return false
	}
	return true
}

func (p *Driver) Field1DeepEqual(src string) bool {

	if strings.Compare(p.Id, src) != 0 {
		return false
	}
	return true
}
func (p *Driver) Field2DeepEqual(src string) bool {

	if strings.Compare(p.AvatarUrl, src) != 0 {
		return false
	}
	return true
}

type Position struct {
	Latitude  float64 `thrift:"latitude,1" frugal:"1,default,double" json:"latitude"`
	Longitude float64 `thrift:"longitude,2" frugal:"2,default,double" json:"longitude"`
}

func NewPosition() *Position {
	return &Position{}
}

func (p *Position) InitDefault() {
	*p = Position{}
}

func (p *Position) GetLatitude() (v float64) {
	return p.Latitude
}

func (p *Position) GetLongitude() (v float64) {
	return p.Longitude
}
func (p *Position) SetLatitude(val float64) {
	p.Latitude = val
}
func (p *Position) SetLongitude(val float64) {
	p.Longitude = val
}

var fieldIDToName_Position = map[int16]string{
	1: "latitude",
	2: "longitude",
}

func (p *Position) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.DOUBLE {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 2:
			if fieldTypeId == thrift.DOUBLE {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_Position[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *Position) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadDouble(); err != nil {
		return err
	} else {
		p.Latitude = v
	}
	return nil
}

func (p *Position) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadDouble(); err != nil {
		return err
	} else {
		p.Longitude = v
	}
	return nil
}

func (p *Position) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("Position"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}
		if err = p.writeField2(oprot); err != nil {
			fieldId = 2
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *Position) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("latitude", thrift.DOUBLE, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteDouble(p.Latitude); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *Position) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("longitude", thrift.DOUBLE, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteDouble(p.Longitude); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err)
}

func (p *Position) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("Position(%+v)", *p)
}

func (p *Position) DeepEqual(ano *Position) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Latitude) {
		return false
	}
	if !p.Field2DeepEqual(ano.Longitude) {
		return false
	}
	return true
}

func (p *Position) Field1DeepEqual(src float64) bool {

	if p.Latitude != src {
		return false
	}
	return true
}
func (p *Position) Field2DeepEqual(src float64) bool {

	if p.Longitude != src {
		return false
	}
	return true
}

type Car struct {
	Status   CarStatus `thrift:"status,1" frugal:"1,default,CarStatus" json:"status"`
	Driver   *Driver   `thrift:"driver,2" frugal:"2,default,Driver" json:"driver"`
	Position *Position `thrift:"position,3" frugal:"3,default,Position" json:"position"`
	TripId   string    `thrift:"trip_id,4" frugal:"4,default,string" json:"trip_id"`
	Power    float64   `thrift:"power,5" frugal:"5,default,double" json:"power"`
	PlateNum string    `thrift:"plate_num,6" frugal:"6,default,string" json:"plate_num"`
}

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

func (p *Car) InitDefault() {
	*p = Car{}
}

func (p *Car) GetStatus() (v CarStatus) {
	return p.Status
}

var Car_Driver_DEFAULT *Driver

func (p *Car) GetDriver() (v *Driver) {
	if !p.IsSetDriver() {
		return Car_Driver_DEFAULT
	}
	return p.Driver
}

var Car_Position_DEFAULT *Position

func (p *Car) GetPosition() (v *Position) {
	if !p.IsSetPosition() {
		return Car_Position_DEFAULT
	}
	return p.Position
}

func (p *Car) GetTripId() (v string) {
	return p.TripId
}

func (p *Car) GetPower() (v float64) {
	return p.Power
}

func (p *Car) GetPlateNum() (v string) {
	return p.PlateNum
}
func (p *Car) SetStatus(val CarStatus) {
	p.Status = val
}
func (p *Car) SetDriver(val *Driver) {
	p.Driver = val
}
func (p *Car) SetPosition(val *Position) {
	p.Position = val
}
func (p *Car) SetTripId(val string) {
	p.TripId = val
}
func (p *Car) SetPower(val float64) {
	p.Power = val
}
func (p *Car) SetPlateNum(val string) {
	p.PlateNum = val
}

var fieldIDToName_Car = map[int16]string{
	1: "status",
	2: "driver",
	3: "position",
	4: "trip_id",
	5: "power",
	6: "plate_num",
}

func (p *Car) IsSetDriver() bool {
	return p.Driver != nil
}

func (p *Car) IsSetPosition() bool {
	return p.Position != nil
}

func (p *Car) Read(iprot thrift.TProtocol) (err error) {

	var fieldTypeId thrift.TType
	var fieldId int16

	if _, err = iprot.ReadStructBegin(); err != nil {
		goto ReadStructBeginError
	}

	for {
		_, fieldTypeId, fieldId, err = iprot.ReadFieldBegin()
		if err != nil {
			goto ReadFieldBeginError
		}
		if fieldTypeId == thrift.STOP {
			break
		}

		switch fieldId {
		case 1:
			if fieldTypeId == thrift.I32 {
				if err = p.ReadField1(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 2:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField2(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 3:
			if fieldTypeId == thrift.STRUCT {
				if err = p.ReadField3(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 4:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField4(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 5:
			if fieldTypeId == thrift.DOUBLE {
				if err = p.ReadField5(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		case 6:
			if fieldTypeId == thrift.STRING {
				if err = p.ReadField6(iprot); err != nil {
					goto ReadFieldError
				}
			} else {
				if err = iprot.Skip(fieldTypeId); err != nil {
					goto SkipFieldError
				}
			}
		default:
			if err = iprot.Skip(fieldTypeId); err != nil {
				goto SkipFieldError
			}
		}

		if err = iprot.ReadFieldEnd(); err != nil {
			goto ReadFieldEndError
		}
	}
	if err = iprot.ReadStructEnd(); err != nil {
		goto ReadStructEndError
	}

	return nil
ReadStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read struct begin error: ", p), err)
ReadFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d begin error: ", p, fieldId), err)
ReadFieldError:
	return thrift.PrependError(fmt.Sprintf("%T read field %d '%s' error: ", p, fieldId, fieldIDToName_Car[fieldId]), err)
SkipFieldError:
	return thrift.PrependError(fmt.Sprintf("%T field %d skip type %d error: ", p, fieldId, fieldTypeId), err)

ReadFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T read field end error", p), err)
ReadStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
}

func (p *Car) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return err
	} else {
		p.Status = CarStatus(v)
	}
	return nil
}

func (p *Car) ReadField2(iprot thrift.TProtocol) error {
	p.Driver = NewDriver()
	if err := p.Driver.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *Car) ReadField3(iprot thrift.TProtocol) error {
	p.Position = NewPosition()
	if err := p.Position.Read(iprot); err != nil {
		return err
	}
	return nil
}

func (p *Car) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return err
	} else {
		p.TripId = v
	}
	return nil
}

func (p *Car) ReadField5(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadDouble(); err != nil {
		return err
	} else {
		p.Power = v
	}
	return nil
}

func (p *Car) ReadField6(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadString(); err != nil {
		return err
	} else {
		p.PlateNum = v
	}
	return nil
}

func (p *Car) Write(oprot thrift.TProtocol) (err error) {
	var fieldId int16
	if err = oprot.WriteStructBegin("Car"); err != nil {
		goto WriteStructBeginError
	}
	if p != nil {
		if err = p.writeField1(oprot); err != nil {
			fieldId = 1
			goto WriteFieldError
		}
		if err = p.writeField2(oprot); err != nil {
			fieldId = 2
			goto WriteFieldError
		}
		if err = p.writeField3(oprot); err != nil {
			fieldId = 3
			goto WriteFieldError
		}
		if err = p.writeField4(oprot); err != nil {
			fieldId = 4
			goto WriteFieldError
		}
		if err = p.writeField5(oprot); err != nil {
			fieldId = 5
			goto WriteFieldError
		}
		if err = p.writeField6(oprot); err != nil {
			fieldId = 6
			goto WriteFieldError
		}

	}
	if err = oprot.WriteFieldStop(); err != nil {
		goto WriteFieldStopError
	}
	if err = oprot.WriteStructEnd(); err != nil {
		goto WriteStructEndError
	}
	return nil
WriteStructBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err)
WriteFieldError:
	return thrift.PrependError(fmt.Sprintf("%T write field %d error: ", p, fieldId), err)
WriteFieldStopError:
	return thrift.PrependError(fmt.Sprintf("%T write field stop error: ", p), err)
WriteStructEndError:
	return thrift.PrependError(fmt.Sprintf("%T write struct end error: ", p), err)
}

func (p *Car) writeField1(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("status", thrift.I32, 1); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteI32(int32(p.Status)); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 1 end error: ", p), err)
}

func (p *Car) writeField2(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("driver", thrift.STRUCT, 2); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.Driver.Write(oprot); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 2 end error: ", p), err)
}

func (p *Car) writeField3(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("position", thrift.STRUCT, 3); err != nil {
		goto WriteFieldBeginError
	}
	if err := p.Position.Write(oprot); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 3 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 3 end error: ", p), err)
}

func (p *Car) writeField4(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("trip_id", thrift.STRING, 4); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.TripId); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 4 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 4 end error: ", p), err)
}

func (p *Car) writeField5(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("power", thrift.DOUBLE, 5); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteDouble(p.Power); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 5 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 5 end error: ", p), err)
}

func (p *Car) writeField6(oprot thrift.TProtocol) (err error) {
	if err = oprot.WriteFieldBegin("plate_num", thrift.STRING, 6); err != nil {
		goto WriteFieldBeginError
	}
	if err := oprot.WriteString(p.PlateNum); err != nil {
		return err
	}
	if err = oprot.WriteFieldEnd(); err != nil {
		goto WriteFieldEndError
	}
	return nil
WriteFieldBeginError:
	return thrift.PrependError(fmt.Sprintf("%T write field 6 begin error: ", p), err)
WriteFieldEndError:
	return thrift.PrependError(fmt.Sprintf("%T write field 6 end error: ", p), err)
}

func (p *Car) String() string {
	if p == nil {
		return "<nil>"
	}
	return fmt.Sprintf("Car(%+v)", *p)
}

func (p *Car) DeepEqual(ano *Car) bool {
	if p == ano {
		return true
	} else if p == nil || ano == nil {
		return false
	}
	if !p.Field1DeepEqual(ano.Status) {
		return false
	}
	if !p.Field2DeepEqual(ano.Driver) {
		return false
	}
	if !p.Field3DeepEqual(ano.Position) {
		return false
	}
	if !p.Field4DeepEqual(ano.TripId) {
		return false
	}
	if !p.Field5DeepEqual(ano.Power) {
		return false
	}
	if !p.Field6DeepEqual(ano.PlateNum) {
		return false
	}
	return true
}

func (p *Car) Field1DeepEqual(src CarStatus) bool {

	if p.Status != src {
		return false
	}
	return true
}
func (p *Car) Field2DeepEqual(src *Driver) bool {

	if !p.Driver.DeepEqual(src) {
		return false
	}
	return true
}
func (p *Car) Field3DeepEqual(src *Position) bool {

	if !p.Position.DeepEqual(src) {
		return false
	}
	return true
}
func (p *Car) Field4DeepEqual(src string) bool {

	if strings.Compare(p.TripId, src) != 0 {
		return false
	}
	return true
}
func (p *Car) Field5DeepEqual(src float64) bool {

	if p.Power != src {
		return false
	}
	return true
}
func (p *Car) Field6DeepEqual(src string) bool {

	if strings.Compare(p.PlateNum, src) != 0 {
		return false
	}
	return true
}