flink.go

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

package flink

import (
	"bytes"
	"database/sql/driver"
	"errors"
	"fmt"
	"git.apache.org/thrift.git/lib/go/thrift"
)

// (needed to ensure safety because of naive import list construction.)
var _ = thrift.ZERO
var _ = fmt.Printf
var _ = bytes.Equal

type TFJvmGcType int64
const (
  TFJvmGcType_UNKNOWN TFJvmGcType = 0
  TFJvmGcType_SERIAL TFJvmGcType = 1
  TFJvmGcType_PARALLEL TFJvmGcType = 2
  TFJvmGcType_CMS TFJvmGcType = 3
  TFJvmGcType_G1 TFJvmGcType = 4
)

func (p TFJvmGcType) String() string {
  switch p {
  case TFJvmGcType_UNKNOWN: return "UNKNOWN"
  case TFJvmGcType_SERIAL: return "SERIAL"
  case TFJvmGcType_PARALLEL: return "PARALLEL"
  case TFJvmGcType_CMS: return "CMS"
  case TFJvmGcType_G1: return "G1"
  }
  return "<UNSET>"
}

func TFJvmGcTypeFromString(s string) (TFJvmGcType, error) {
  switch s {
  case "UNKNOWN": return TFJvmGcType_UNKNOWN, nil 
  case "SERIAL": return TFJvmGcType_SERIAL, nil 
  case "PARALLEL": return TFJvmGcType_PARALLEL, nil 
  case "CMS": return TFJvmGcType_CMS, nil 
  case "G1": return TFJvmGcType_G1, nil 
  }
  return TFJvmGcType(0), fmt.Errorf("not a valid TFJvmGcType string")
}


func TFJvmGcTypePtr(v TFJvmGcType) *TFJvmGcType { return &v }

func (p TFJvmGcType) MarshalText() ([]byte, error) {
return []byte(p.String()), nil
}

func (p *TFJvmGcType) UnmarshalText(text []byte) error {
q, err := TFJvmGcTypeFromString(string(text))
if (err != nil) {
return err
}
*p = q
return nil
}

func (p *TFJvmGcType) Scan(value interface{}) error {
v, ok := value.(int64)
if !ok {
return errors.New("Scan value is not int64")
}
*p = TFJvmGcType(v)
return nil
}

func (p * TFJvmGcType) Value() (driver.Value, error) {
  if p == nil {
    return nil, nil
  }
return int64(*p), nil
}
// Attributes:
//  - ServiceName
//  - ServiceLibs
type TFServiceInfo struct {
  ServiceName *string `thrift:"serviceName,1" db:"serviceName" json:"serviceName,omitempty"`
  ServiceLibs []string `thrift:"serviceLibs,2" db:"serviceLibs" json:"serviceLibs,omitempty"`
}

func NewTFServiceInfo() *TFServiceInfo {
  return &TFServiceInfo{}
}

var TFServiceInfo_ServiceName_DEFAULT string
func (p *TFServiceInfo) GetServiceName() string {
  if !p.IsSetServiceName() {
    return TFServiceInfo_ServiceName_DEFAULT
  }
return *p.ServiceName
}
var TFServiceInfo_ServiceLibs_DEFAULT []string

func (p *TFServiceInfo) GetServiceLibs() []string {
  return p.ServiceLibs
}
func (p *TFServiceInfo) IsSetServiceName() bool {
  return p.ServiceName != nil
}

func (p *TFServiceInfo) IsSetServiceLibs() bool {
  return p.ServiceLibs != nil
}

func (p *TFServiceInfo) Read(iprot thrift.TProtocol) 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 *TFServiceInfo)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.ServiceName = &v
}
  return nil
}

func (p *TFServiceInfo)  ReadField2(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make([]string, 0, size)
  p.ServiceLibs =  tSlice
  for i := 0; i < size; i ++ {
var _elem0 string
    if v, err := iprot.ReadString(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    _elem0 = v
}
    p.ServiceLibs = append(p.ServiceLibs, _elem0)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *TFServiceInfo) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("TFServiceInfo"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    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 *TFServiceInfo) writeField1(oprot thrift.TProtocol) (err error) {
  if p.IsSetServiceName() {
    if err := oprot.WriteFieldBegin("serviceName", thrift.STRING, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:serviceName: ", p), err) }
    if err := oprot.WriteString(string(*p.ServiceName)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.serviceName (1) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:serviceName: ", p), err) }
  }
  return err
}

func (p *TFServiceInfo) writeField2(oprot thrift.TProtocol) (err error) {
  if p.IsSetServiceLibs() {
    if err := oprot.WriteFieldBegin("serviceLibs", thrift.LIST, 2); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:serviceLibs: ", p), err) }
    if err := oprot.WriteListBegin(thrift.STRING, len(p.ServiceLibs)); err != nil {
      return thrift.PrependError("error writing list begin: ", err)
    }
    for _, v := range p.ServiceLibs {
      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 2:serviceLibs: ", p), err) }
  }
  return err
}

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

// Attributes:
//  - ServerInfo
//  - VmArgs_
//  - ServiceInfos
type TFServerMetaData struct {
  ServerInfo *string `thrift:"serverInfo,1" db:"serverInfo" json:"serverInfo,omitempty"`
  VmArgs_ []string `thrift:"vmArgs,2" db:"vmArgs" json:"vmArgs,omitempty"`
  // unused fields # 3 to 9
  ServiceInfos []*TFServiceInfo `thrift:"serviceInfos,10" db:"serviceInfos" json:"serviceInfos,omitempty"`
}

func NewTFServerMetaData() *TFServerMetaData {
  return &TFServerMetaData{}
}

var TFServerMetaData_ServerInfo_DEFAULT string
func (p *TFServerMetaData) GetServerInfo() string {
  if !p.IsSetServerInfo() {
    return TFServerMetaData_ServerInfo_DEFAULT
  }
return *p.ServerInfo
}
var TFServerMetaData_VmArgs__DEFAULT []string

func (p *TFServerMetaData) GetVmArgs_() []string {
  return p.VmArgs_
}
var TFServerMetaData_ServiceInfos_DEFAULT []*TFServiceInfo

func (p *TFServerMetaData) GetServiceInfos() []*TFServiceInfo {
  return p.ServiceInfos
}
func (p *TFServerMetaData) IsSetServerInfo() bool {
  return p.ServerInfo != nil
}

func (p *TFServerMetaData) IsSetVmArgs_() bool {
  return p.VmArgs_ != nil
}

func (p *TFServerMetaData) IsSetServiceInfos() bool {
  return p.ServiceInfos != nil
}

func (p *TFServerMetaData) Read(iprot thrift.TProtocol) 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 10:
      if err := p.ReadField10(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 *TFServerMetaData)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.ServerInfo = &v
}
  return nil
}

func (p *TFServerMetaData)  ReadField2(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make([]string, 0, size)
  p.VmArgs_ =  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.VmArgs_ = append(p.VmArgs_, _elem1)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *TFServerMetaData)  ReadField10(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make([]*TFServiceInfo, 0, size)
  p.ServiceInfos =  tSlice
  for i := 0; i < size; i ++ {
    _elem2 := &TFServiceInfo{}
    if err := _elem2.Read(iprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem2), err)
    }
    p.ServiceInfos = append(p.ServiceInfos, _elem2)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *TFServerMetaData) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("TFServerMetaData"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
    if err := p.writeField10(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 *TFServerMetaData) writeField1(oprot thrift.TProtocol) (err error) {
  if p.IsSetServerInfo() {
    if err := oprot.WriteFieldBegin("serverInfo", thrift.STRING, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:serverInfo: ", p), err) }
    if err := oprot.WriteString(string(*p.ServerInfo)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.serverInfo (1) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:serverInfo: ", p), err) }
  }
  return err
}

func (p *TFServerMetaData) writeField2(oprot thrift.TProtocol) (err error) {
  if p.IsSetVmArgs_() {
    if err := oprot.WriteFieldBegin("vmArgs", thrift.LIST, 2); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:vmArgs: ", p), err) }
    if err := oprot.WriteListBegin(thrift.STRING, len(p.VmArgs_)); err != nil {
      return thrift.PrependError("error writing list begin: ", err)
    }
    for _, v := range p.VmArgs_ {
      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 2:vmArgs: ", p), err) }
  }
  return err
}

func (p *TFServerMetaData) writeField10(oprot thrift.TProtocol) (err error) {
  if p.IsSetServiceInfos() {
    if err := oprot.WriteFieldBegin("serviceInfos", thrift.LIST, 10); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 10:serviceInfos: ", p), err) }
    if err := oprot.WriteListBegin(thrift.STRUCT, len(p.ServiceInfos)); err != nil {
      return thrift.PrependError("error writing list begin: ", err)
    }
    for _, v := range p.ServiceInfos {
      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 10:serviceInfos: ", p), err) }
  }
  return err
}

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

// Attributes:
//  - Version
//  - VmVersion
//  - GcType
type TFJvmInfo struct {
  Version int16 `thrift:"version,1" db:"version" json:"version"`
  VmVersion *string `thrift:"vmVersion,2" db:"vmVersion" json:"vmVersion,omitempty"`
  GcType TFJvmGcType `thrift:"gcType,3" db:"gcType" json:"gcType,omitempty"`
}

func NewTFJvmInfo() *TFJvmInfo {
  return &TFJvmInfo{
GcType: 0,
}
}


func (p *TFJvmInfo) GetVersion() int16 {
  return p.Version
}
var TFJvmInfo_VmVersion_DEFAULT string
func (p *TFJvmInfo) GetVmVersion() string {
  if !p.IsSetVmVersion() {
    return TFJvmInfo_VmVersion_DEFAULT
  }
return *p.VmVersion
}
var TFJvmInfo_GcType_DEFAULT TFJvmGcType = 0

func (p *TFJvmInfo) GetGcType() TFJvmGcType {
  return p.GcType
}
func (p *TFJvmInfo) IsSetVmVersion() bool {
  return p.VmVersion != nil
}

func (p *TFJvmInfo) IsSetGcType() bool {
  return p.GcType != TFJvmInfo_GcType_DEFAULT
}

func (p *TFJvmInfo) Read(iprot thrift.TProtocol) 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
      }
    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 *TFJvmInfo)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI16(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.Version = v
}
  return nil
}

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

func (p *TFJvmInfo)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  temp := TFJvmGcType(v)
  p.GcType = temp
}
  return nil
}

func (p *TFJvmInfo) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("TFJvmInfo"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    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 := 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 *TFJvmInfo) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("version", thrift.I16, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:version: ", p), err) }
  if err := oprot.WriteI16(int16(p.Version)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.version (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:version: ", p), err) }
  return err
}

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

func (p *TFJvmInfo) writeField3(oprot thrift.TProtocol) (err error) {
  if p.IsSetGcType() {
    if err := oprot.WriteFieldBegin("gcType", thrift.I32, 3); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:gcType: ", p), err) }
    if err := oprot.WriteI32(int32(p.GcType)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.gcType (3) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 3:gcType: ", p), err) }
  }
  return err
}

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

// Attributes:
//  - Hostname
//  - IP
//  - Ports
//  - AgentId
//  - ApplicationName
//  - ServiceType
//  - Pid
//  - AgentVersion
//  - VmVersion
//  - StartTimestamp
//  - EndTimestamp
//  - EndStatus
//  - ServerMetaData
//  - JvmInfo
type TFAgentInfo struct {
  Hostname string `thrift:"hostname,1" db:"hostname" json:"hostname"`
  IP string `thrift:"ip,2" db:"ip" json:"ip"`
  Ports string `thrift:"ports,3" db:"ports" json:"ports"`
  AgentId string `thrift:"agentId,4" db:"agentId" json:"agentId"`
  ApplicationName string `thrift:"applicationName,5" db:"applicationName" json:"applicationName"`
  ServiceType int16 `thrift:"serviceType,6" db:"serviceType" json:"serviceType"`
  Pid int32 `thrift:"pid,7" db:"pid" json:"pid"`
  AgentVersion string `thrift:"agentVersion,8" db:"agentVersion" json:"agentVersion"`
  VmVersion string `thrift:"vmVersion,9" db:"vmVersion" json:"vmVersion"`
  StartTimestamp int64 `thrift:"startTimestamp,10" db:"startTimestamp" json:"startTimestamp"`
  EndTimestamp *int64 `thrift:"endTimestamp,11" db:"endTimestamp" json:"endTimestamp,omitempty"`
  EndStatus *int32 `thrift:"endStatus,12" db:"endStatus" json:"endStatus,omitempty"`
  // unused fields # 13 to 19
  ServerMetaData *TFServerMetaData `thrift:"serverMetaData,20" db:"serverMetaData" json:"serverMetaData,omitempty"`
  // unused fields # 21 to 29
  JvmInfo *TFJvmInfo `thrift:"jvmInfo,30" db:"jvmInfo" json:"jvmInfo,omitempty"`
}

func NewTFAgentInfo() *TFAgentInfo {
  return &TFAgentInfo{}
}


func (p *TFAgentInfo) GetHostname() string {
  return p.Hostname
}

func (p *TFAgentInfo) GetIP() string {
  return p.IP
}

func (p *TFAgentInfo) GetPorts() string {
  return p.Ports
}

func (p *TFAgentInfo) GetAgentId() string {
  return p.AgentId
}

func (p *TFAgentInfo) GetApplicationName() string {
  return p.ApplicationName
}

func (p *TFAgentInfo) GetServiceType() int16 {
  return p.ServiceType
}

func (p *TFAgentInfo) GetPid() int32 {
  return p.Pid
}

func (p *TFAgentInfo) GetAgentVersion() string {
  return p.AgentVersion
}

func (p *TFAgentInfo) GetVmVersion() string {
  return p.VmVersion
}

func (p *TFAgentInfo) GetStartTimestamp() int64 {
  return p.StartTimestamp
}
var TFAgentInfo_EndTimestamp_DEFAULT int64
func (p *TFAgentInfo) GetEndTimestamp() int64 {
  if !p.IsSetEndTimestamp() {
    return TFAgentInfo_EndTimestamp_DEFAULT
  }
return *p.EndTimestamp
}
var TFAgentInfo_EndStatus_DEFAULT int32
func (p *TFAgentInfo) GetEndStatus() int32 {
  if !p.IsSetEndStatus() {
    return TFAgentInfo_EndStatus_DEFAULT
  }
return *p.EndStatus
}
var TFAgentInfo_ServerMetaData_DEFAULT *TFServerMetaData
func (p *TFAgentInfo) GetServerMetaData() *TFServerMetaData {
  if !p.IsSetServerMetaData() {
    return TFAgentInfo_ServerMetaData_DEFAULT
  }
return p.ServerMetaData
}
var TFAgentInfo_JvmInfo_DEFAULT *TFJvmInfo
func (p *TFAgentInfo) GetJvmInfo() *TFJvmInfo {
  if !p.IsSetJvmInfo() {
    return TFAgentInfo_JvmInfo_DEFAULT
  }
return p.JvmInfo
}
func (p *TFAgentInfo) IsSetEndTimestamp() bool {
  return p.EndTimestamp != nil
}

func (p *TFAgentInfo) IsSetEndStatus() bool {
  return p.EndStatus != nil
}

func (p *TFAgentInfo) IsSetServerMetaData() bool {
  return p.ServerMetaData != nil
}

func (p *TFAgentInfo) IsSetJvmInfo() bool {
  return p.JvmInfo != nil
}

func (p *TFAgentInfo) Read(iprot thrift.TProtocol) 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
      }
    case 8:
      if err := p.ReadField8(iprot); err != nil {
        return err
      }
    case 9:
      if err := p.ReadField9(iprot); err != nil {
        return err
      }
    case 10:
      if err := p.ReadField10(iprot); err != nil {
        return err
      }
    case 11:
      if err := p.ReadField11(iprot); err != nil {
        return err
      }
    case 12:
      if err := p.ReadField12(iprot); err != nil {
        return err
      }
    case 20:
      if err := p.ReadField20(iprot); err != nil {
        return err
      }
    case 30:
      if err := p.ReadField30(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 *TFAgentInfo)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.Hostname = v
}
  return nil
}

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

func (p *TFAgentInfo)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.Ports = v
}
  return nil
}

func (p *TFAgentInfo)  ReadField4(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 4: ", err)
} else {
  p.AgentId = v
}
  return nil
}

func (p *TFAgentInfo)  ReadField5(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 5: ", err)
} else {
  p.ApplicationName = v
}
  return nil
}

func (p *TFAgentInfo)  ReadField6(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI16(); err != nil {
  return thrift.PrependError("error reading field 6: ", err)
} else {
  p.ServiceType = v
}
  return nil
}

func (p *TFAgentInfo)  ReadField7(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 7: ", err)
} else {
  p.Pid = v
}
  return nil
}

func (p *TFAgentInfo)  ReadField8(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 8: ", err)
} else {
  p.AgentVersion = v
}
  return nil
}

func (p *TFAgentInfo)  ReadField9(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 9: ", err)
} else {
  p.VmVersion = v
}
  return nil
}

func (p *TFAgentInfo)  ReadField10(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 10: ", err)
} else {
  p.StartTimestamp = v
}
  return nil
}

func (p *TFAgentInfo)  ReadField11(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 11: ", err)
} else {
  p.EndTimestamp = &v
}
  return nil
}

func (p *TFAgentInfo)  ReadField12(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 12: ", err)
} else {
  p.EndStatus = &v
}
  return nil
}

func (p *TFAgentInfo)  ReadField20(iprot thrift.TProtocol) error {
  p.ServerMetaData = &TFServerMetaData{}
  if err := p.ServerMetaData.Read(iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.ServerMetaData), err)
  }
  return nil
}

func (p *TFAgentInfo)  ReadField30(iprot thrift.TProtocol) error {
  p.JvmInfo = &TFJvmInfo{
  GcType:   0,
}
  if err := p.JvmInfo.Read(iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.JvmInfo), err)
  }
  return nil
}

func (p *TFAgentInfo) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("TFAgentInfo"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    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 := p.writeField8(oprot); err != nil { return err }
    if err := p.writeField9(oprot); err != nil { return err }
    if err := p.writeField10(oprot); err != nil { return err }
    if err := p.writeField11(oprot); err != nil { return err }
    if err := p.writeField12(oprot); err != nil { return err }
    if err := p.writeField20(oprot); err != nil { return err }
    if err := p.writeField30(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 *TFAgentInfo) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("hostname", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:hostname: ", p), err) }
  if err := oprot.WriteString(string(p.Hostname)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.hostname (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:hostname: ", p), err) }
  return err
}

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

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

func (p *TFAgentInfo) writeField4(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("agentId", thrift.STRING, 4); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:agentId: ", p), err) }
  if err := oprot.WriteString(string(p.AgentId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.agentId (4) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 4:agentId: ", p), err) }
  return err
}

func (p *TFAgentInfo) writeField5(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("applicationName", thrift.STRING, 5); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:applicationName: ", p), err) }
  if err := oprot.WriteString(string(p.ApplicationName)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.applicationName (5) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 5:applicationName: ", p), err) }
  return err
}

func (p *TFAgentInfo) writeField6(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("serviceType", thrift.I16, 6); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 6:serviceType: ", p), err) }
  if err := oprot.WriteI16(int16(p.ServiceType)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.serviceType (6) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 6:serviceType: ", p), err) }
  return err
}

func (p *TFAgentInfo) writeField7(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("pid", thrift.I32, 7); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 7:pid: ", p), err) }
  if err := oprot.WriteI32(int32(p.Pid)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.pid (7) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 7:pid: ", p), err) }
  return err
}

func (p *TFAgentInfo) writeField8(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("agentVersion", thrift.STRING, 8); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 8:agentVersion: ", p), err) }
  if err := oprot.WriteString(string(p.AgentVersion)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.agentVersion (8) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 8:agentVersion: ", p), err) }
  return err
}

func (p *TFAgentInfo) writeField9(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("vmVersion", thrift.STRING, 9); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 9:vmVersion: ", p), err) }
  if err := oprot.WriteString(string(p.VmVersion)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.vmVersion (9) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 9:vmVersion: ", p), err) }
  return err
}

func (p *TFAgentInfo) writeField10(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("startTimestamp", thrift.I64, 10); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 10:startTimestamp: ", p), err) }
  if err := oprot.WriteI64(int64(p.StartTimestamp)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.startTimestamp (10) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 10:startTimestamp: ", p), err) }
  return err
}

func (p *TFAgentInfo) writeField11(oprot thrift.TProtocol) (err error) {
  if p.IsSetEndTimestamp() {
    if err := oprot.WriteFieldBegin("endTimestamp", thrift.I64, 11); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 11:endTimestamp: ", p), err) }
    if err := oprot.WriteI64(int64(*p.EndTimestamp)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.endTimestamp (11) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 11:endTimestamp: ", p), err) }
  }
  return err
}

func (p *TFAgentInfo) writeField12(oprot thrift.TProtocol) (err error) {
  if p.IsSetEndStatus() {
    if err := oprot.WriteFieldBegin("endStatus", thrift.I32, 12); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 12:endStatus: ", p), err) }
    if err := oprot.WriteI32(int32(*p.EndStatus)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.endStatus (12) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 12:endStatus: ", p), err) }
  }
  return err
}

func (p *TFAgentInfo) writeField20(oprot thrift.TProtocol) (err error) {
  if p.IsSetServerMetaData() {
    if err := oprot.WriteFieldBegin("serverMetaData", thrift.STRUCT, 20); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 20:serverMetaData: ", p), err) }
    if err := p.ServerMetaData.Write(oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.ServerMetaData), err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 20:serverMetaData: ", p), err) }
  }
  return err
}

func (p *TFAgentInfo) writeField30(oprot thrift.TProtocol) (err error) {
  if p.IsSetJvmInfo() {
    if err := oprot.WriteFieldBegin("jvmInfo", thrift.STRUCT, 30); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 30:jvmInfo: ", p), err) }
    if err := p.JvmInfo.Write(oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.JvmInfo), err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 30:jvmInfo: ", p), err) }
  }
  return err
}

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

// Attributes:
//  - Type
//  - JvmMemoryHeapUsed
//  - JvmMemoryHeapMax
//  - JvmMemoryNonHeapUsed
//  - JvmMemoryNonHeapMax
//  - JvmGcOldCount
//  - JvmGcOldTime
//  - JvmGcDetailed
type TFJvmGc struct {
  Type TFJvmGcType `thrift:"type,1" db:"type" json:"type"`
  JvmMemoryHeapUsed int64 `thrift:"jvmMemoryHeapUsed,2" db:"jvmMemoryHeapUsed" json:"jvmMemoryHeapUsed"`
  JvmMemoryHeapMax int64 `thrift:"jvmMemoryHeapMax,3" db:"jvmMemoryHeapMax" json:"jvmMemoryHeapMax"`
  JvmMemoryNonHeapUsed int64 `thrift:"jvmMemoryNonHeapUsed,4" db:"jvmMemoryNonHeapUsed" json:"jvmMemoryNonHeapUsed"`
  JvmMemoryNonHeapMax int64 `thrift:"jvmMemoryNonHeapMax,5" db:"jvmMemoryNonHeapMax" json:"jvmMemoryNonHeapMax"`
  JvmGcOldCount int64 `thrift:"jvmGcOldCount,6" db:"jvmGcOldCount" json:"jvmGcOldCount"`
  JvmGcOldTime int64 `thrift:"jvmGcOldTime,7" db:"jvmGcOldTime" json:"jvmGcOldTime"`
  JvmGcDetailed *TFJvmGcDetailed `thrift:"jvmGcDetailed,8" db:"jvmGcDetailed" json:"jvmGcDetailed,omitempty"`
}

func NewTFJvmGc() *TFJvmGc {
  return &TFJvmGc{
Type: 0,
}
}


func (p *TFJvmGc) GetType() TFJvmGcType {
  return p.Type
}

func (p *TFJvmGc) GetJvmMemoryHeapUsed() int64 {
  return p.JvmMemoryHeapUsed
}

func (p *TFJvmGc) GetJvmMemoryHeapMax() int64 {
  return p.JvmMemoryHeapMax
}

func (p *TFJvmGc) GetJvmMemoryNonHeapUsed() int64 {
  return p.JvmMemoryNonHeapUsed
}

func (p *TFJvmGc) GetJvmMemoryNonHeapMax() int64 {
  return p.JvmMemoryNonHeapMax
}

func (p *TFJvmGc) GetJvmGcOldCount() int64 {
  return p.JvmGcOldCount
}

func (p *TFJvmGc) GetJvmGcOldTime() int64 {
  return p.JvmGcOldTime
}
var TFJvmGc_JvmGcDetailed_DEFAULT *TFJvmGcDetailed
func (p *TFJvmGc) GetJvmGcDetailed() *TFJvmGcDetailed {
  if !p.IsSetJvmGcDetailed() {
    return TFJvmGc_JvmGcDetailed_DEFAULT
  }
return p.JvmGcDetailed
}
func (p *TFJvmGc) IsSetJvmGcDetailed() bool {
  return p.JvmGcDetailed != nil
}

func (p *TFJvmGc) Read(iprot thrift.TProtocol) 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
      }
    case 8:
      if err := p.ReadField8(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 *TFJvmGc)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  temp := TFJvmGcType(v)
  p.Type = temp
}
  return nil
}

func (p *TFJvmGc)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.JvmMemoryHeapUsed = v
}
  return nil
}

func (p *TFJvmGc)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.JvmMemoryHeapMax = v
}
  return nil
}

func (p *TFJvmGc)  ReadField4(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 4: ", err)
} else {
  p.JvmMemoryNonHeapUsed = v
}
  return nil
}

func (p *TFJvmGc)  ReadField5(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 5: ", err)
} else {
  p.JvmMemoryNonHeapMax = v
}
  return nil
}

func (p *TFJvmGc)  ReadField6(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 6: ", err)
} else {
  p.JvmGcOldCount = v
}
  return nil
}

func (p *TFJvmGc)  ReadField7(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 7: ", err)
} else {
  p.JvmGcOldTime = v
}
  return nil
}

func (p *TFJvmGc)  ReadField8(iprot thrift.TProtocol) error {
  p.JvmGcDetailed = &TFJvmGcDetailed{}
  if err := p.JvmGcDetailed.Read(iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.JvmGcDetailed), err)
  }
  return nil
}

func (p *TFJvmGc) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("TFJvmGc"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    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 := p.writeField8(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 *TFJvmGc) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("type", thrift.I32, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:type: ", p), err) }
  if err := oprot.WriteI32(int32(p.Type)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.type (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:type: ", p), err) }
  return err
}

func (p *TFJvmGc) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("jvmMemoryHeapUsed", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:jvmMemoryHeapUsed: ", p), err) }
  if err := oprot.WriteI64(int64(p.JvmMemoryHeapUsed)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.jvmMemoryHeapUsed (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:jvmMemoryHeapUsed: ", p), err) }
  return err
}

func (p *TFJvmGc) writeField3(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("jvmMemoryHeapMax", thrift.I64, 3); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:jvmMemoryHeapMax: ", p), err) }
  if err := oprot.WriteI64(int64(p.JvmMemoryHeapMax)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.jvmMemoryHeapMax (3) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 3:jvmMemoryHeapMax: ", p), err) }
  return err
}

func (p *TFJvmGc) writeField4(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("jvmMemoryNonHeapUsed", thrift.I64, 4); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:jvmMemoryNonHeapUsed: ", p), err) }
  if err := oprot.WriteI64(int64(p.JvmMemoryNonHeapUsed)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.jvmMemoryNonHeapUsed (4) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 4:jvmMemoryNonHeapUsed: ", p), err) }
  return err
}

func (p *TFJvmGc) writeField5(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("jvmMemoryNonHeapMax", thrift.I64, 5); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:jvmMemoryNonHeapMax: ", p), err) }
  if err := oprot.WriteI64(int64(p.JvmMemoryNonHeapMax)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.jvmMemoryNonHeapMax (5) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 5:jvmMemoryNonHeapMax: ", p), err) }
  return err
}

func (p *TFJvmGc) writeField6(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("jvmGcOldCount", thrift.I64, 6); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 6:jvmGcOldCount: ", p), err) }
  if err := oprot.WriteI64(int64(p.JvmGcOldCount)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.jvmGcOldCount (6) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 6:jvmGcOldCount: ", p), err) }
  return err
}

func (p *TFJvmGc) writeField7(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("jvmGcOldTime", thrift.I64, 7); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 7:jvmGcOldTime: ", p), err) }
  if err := oprot.WriteI64(int64(p.JvmGcOldTime)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.jvmGcOldTime (7) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 7:jvmGcOldTime: ", p), err) }
  return err
}

func (p *TFJvmGc) writeField8(oprot thrift.TProtocol) (err error) {
  if p.IsSetJvmGcDetailed() {
    if err := oprot.WriteFieldBegin("jvmGcDetailed", thrift.STRUCT, 8); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 8:jvmGcDetailed: ", p), err) }
    if err := p.JvmGcDetailed.Write(oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.JvmGcDetailed), err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 8:jvmGcDetailed: ", p), err) }
  }
  return err
}

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

// Attributes:
//  - JvmGcNewCount
//  - JvmGcNewTime
//  - JvmPoolCodeCacheUsed
//  - JvmPoolNewGenUsed
//  - JvmPoolOldGenUsed
//  - JvmPoolSurvivorSpaceUsed
//  - JvmPoolPermGenUsed
//  - JvmPoolMetaspaceUsed
type TFJvmGcDetailed struct {
  JvmGcNewCount *int64 `thrift:"jvmGcNewCount,1" db:"jvmGcNewCount" json:"jvmGcNewCount,omitempty"`
  JvmGcNewTime *int64 `thrift:"jvmGcNewTime,2" db:"jvmGcNewTime" json:"jvmGcNewTime,omitempty"`
  JvmPoolCodeCacheUsed *float64 `thrift:"jvmPoolCodeCacheUsed,3" db:"jvmPoolCodeCacheUsed" json:"jvmPoolCodeCacheUsed,omitempty"`
  JvmPoolNewGenUsed *float64 `thrift:"jvmPoolNewGenUsed,4" db:"jvmPoolNewGenUsed" json:"jvmPoolNewGenUsed,omitempty"`
  JvmPoolOldGenUsed *float64 `thrift:"jvmPoolOldGenUsed,5" db:"jvmPoolOldGenUsed" json:"jvmPoolOldGenUsed,omitempty"`
  JvmPoolSurvivorSpaceUsed *float64 `thrift:"jvmPoolSurvivorSpaceUsed,6" db:"jvmPoolSurvivorSpaceUsed" json:"jvmPoolSurvivorSpaceUsed,omitempty"`
  JvmPoolPermGenUsed *float64 `thrift:"jvmPoolPermGenUsed,7" db:"jvmPoolPermGenUsed" json:"jvmPoolPermGenUsed,omitempty"`
  JvmPoolMetaspaceUsed *float64 `thrift:"jvmPoolMetaspaceUsed,8" db:"jvmPoolMetaspaceUsed" json:"jvmPoolMetaspaceUsed,omitempty"`
}

func NewTFJvmGcDetailed() *TFJvmGcDetailed {
  return &TFJvmGcDetailed{}
}

var TFJvmGcDetailed_JvmGcNewCount_DEFAULT int64
func (p *TFJvmGcDetailed) GetJvmGcNewCount() int64 {
  if !p.IsSetJvmGcNewCount() {
    return TFJvmGcDetailed_JvmGcNewCount_DEFAULT
  }
return *p.JvmGcNewCount
}
var TFJvmGcDetailed_JvmGcNewTime_DEFAULT int64
func (p *TFJvmGcDetailed) GetJvmGcNewTime() int64 {
  if !p.IsSetJvmGcNewTime() {
    return TFJvmGcDetailed_JvmGcNewTime_DEFAULT
  }
return *p.JvmGcNewTime
}
var TFJvmGcDetailed_JvmPoolCodeCacheUsed_DEFAULT float64
func (p *TFJvmGcDetailed) GetJvmPoolCodeCacheUsed() float64 {
  if !p.IsSetJvmPoolCodeCacheUsed() {
    return TFJvmGcDetailed_JvmPoolCodeCacheUsed_DEFAULT
  }
return *p.JvmPoolCodeCacheUsed
}
var TFJvmGcDetailed_JvmPoolNewGenUsed_DEFAULT float64
func (p *TFJvmGcDetailed) GetJvmPoolNewGenUsed() float64 {
  if !p.IsSetJvmPoolNewGenUsed() {
    return TFJvmGcDetailed_JvmPoolNewGenUsed_DEFAULT
  }
return *p.JvmPoolNewGenUsed
}
var TFJvmGcDetailed_JvmPoolOldGenUsed_DEFAULT float64
func (p *TFJvmGcDetailed) GetJvmPoolOldGenUsed() float64 {
  if !p.IsSetJvmPoolOldGenUsed() {
    return TFJvmGcDetailed_JvmPoolOldGenUsed_DEFAULT
  }
return *p.JvmPoolOldGenUsed
}
var TFJvmGcDetailed_JvmPoolSurvivorSpaceUsed_DEFAULT float64
func (p *TFJvmGcDetailed) GetJvmPoolSurvivorSpaceUsed() float64 {
  if !p.IsSetJvmPoolSurvivorSpaceUsed() {
    return TFJvmGcDetailed_JvmPoolSurvivorSpaceUsed_DEFAULT
  }
return *p.JvmPoolSurvivorSpaceUsed
}
var TFJvmGcDetailed_JvmPoolPermGenUsed_DEFAULT float64
func (p *TFJvmGcDetailed) GetJvmPoolPermGenUsed() float64 {
  if !p.IsSetJvmPoolPermGenUsed() {
    return TFJvmGcDetailed_JvmPoolPermGenUsed_DEFAULT
  }
return *p.JvmPoolPermGenUsed
}
var TFJvmGcDetailed_JvmPoolMetaspaceUsed_DEFAULT float64
func (p *TFJvmGcDetailed) GetJvmPoolMetaspaceUsed() float64 {
  if !p.IsSetJvmPoolMetaspaceUsed() {
    return TFJvmGcDetailed_JvmPoolMetaspaceUsed_DEFAULT
  }
return *p.JvmPoolMetaspaceUsed
}
func (p *TFJvmGcDetailed) IsSetJvmGcNewCount() bool {
  return p.JvmGcNewCount != nil
}

func (p *TFJvmGcDetailed) IsSetJvmGcNewTime() bool {
  return p.JvmGcNewTime != nil
}

func (p *TFJvmGcDetailed) IsSetJvmPoolCodeCacheUsed() bool {
  return p.JvmPoolCodeCacheUsed != nil
}

func (p *TFJvmGcDetailed) IsSetJvmPoolNewGenUsed() bool {
  return p.JvmPoolNewGenUsed != nil
}

func (p *TFJvmGcDetailed) IsSetJvmPoolOldGenUsed() bool {
  return p.JvmPoolOldGenUsed != nil
}

func (p *TFJvmGcDetailed) IsSetJvmPoolSurvivorSpaceUsed() bool {
  return p.JvmPoolSurvivorSpaceUsed != nil
}

func (p *TFJvmGcDetailed) IsSetJvmPoolPermGenUsed() bool {
  return p.JvmPoolPermGenUsed != nil
}

func (p *TFJvmGcDetailed) IsSetJvmPoolMetaspaceUsed() bool {
  return p.JvmPoolMetaspaceUsed != nil
}

func (p *TFJvmGcDetailed) Read(iprot thrift.TProtocol) 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
      }
    case 8:
      if err := p.ReadField8(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 *TFJvmGcDetailed)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.JvmGcNewCount = &v
}
  return nil
}

func (p *TFJvmGcDetailed)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.JvmGcNewTime = &v
}
  return nil
}

func (p *TFJvmGcDetailed)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadDouble(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.JvmPoolCodeCacheUsed = &v
}
  return nil
}

func (p *TFJvmGcDetailed)  ReadField4(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadDouble(); err != nil {
  return thrift.PrependError("error reading field 4: ", err)
} else {
  p.JvmPoolNewGenUsed = &v
}
  return nil
}

func (p *TFJvmGcDetailed)  ReadField5(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadDouble(); err != nil {
  return thrift.PrependError("error reading field 5: ", err)
} else {
  p.JvmPoolOldGenUsed = &v
}
  return nil
}

func (p *TFJvmGcDetailed)  ReadField6(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadDouble(); err != nil {
  return thrift.PrependError("error reading field 6: ", err)
} else {
  p.JvmPoolSurvivorSpaceUsed = &v
}
  return nil
}

func (p *TFJvmGcDetailed)  ReadField7(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadDouble(); err != nil {
  return thrift.PrependError("error reading field 7: ", err)
} else {
  p.JvmPoolPermGenUsed = &v
}
  return nil
}

func (p *TFJvmGcDetailed)  ReadField8(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadDouble(); err != nil {
  return thrift.PrependError("error reading field 8: ", err)
} else {
  p.JvmPoolMetaspaceUsed = &v
}
  return nil
}

func (p *TFJvmGcDetailed) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("TFJvmGcDetailed"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    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 := p.writeField8(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 *TFJvmGcDetailed) writeField1(oprot thrift.TProtocol) (err error) {
  if p.IsSetJvmGcNewCount() {
    if err := oprot.WriteFieldBegin("jvmGcNewCount", thrift.I64, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:jvmGcNewCount: ", p), err) }
    if err := oprot.WriteI64(int64(*p.JvmGcNewCount)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.jvmGcNewCount (1) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:jvmGcNewCount: ", p), err) }
  }
  return err
}

func (p *TFJvmGcDetailed) writeField2(oprot thrift.TProtocol) (err error) {
  if p.IsSetJvmGcNewTime() {
    if err := oprot.WriteFieldBegin("jvmGcNewTime", thrift.I64, 2); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:jvmGcNewTime: ", p), err) }
    if err := oprot.WriteI64(int64(*p.JvmGcNewTime)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.jvmGcNewTime (2) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 2:jvmGcNewTime: ", p), err) }
  }
  return err
}

func (p *TFJvmGcDetailed) writeField3(oprot thrift.TProtocol) (err error) {
  if p.IsSetJvmPoolCodeCacheUsed() {
    if err := oprot.WriteFieldBegin("jvmPoolCodeCacheUsed", thrift.DOUBLE, 3); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:jvmPoolCodeCacheUsed: ", p), err) }
    if err := oprot.WriteDouble(float64(*p.JvmPoolCodeCacheUsed)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.jvmPoolCodeCacheUsed (3) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 3:jvmPoolCodeCacheUsed: ", p), err) }
  }
  return err
}

func (p *TFJvmGcDetailed) writeField4(oprot thrift.TProtocol) (err error) {
  if p.IsSetJvmPoolNewGenUsed() {
    if err := oprot.WriteFieldBegin("jvmPoolNewGenUsed", thrift.DOUBLE, 4); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:jvmPoolNewGenUsed: ", p), err) }
    if err := oprot.WriteDouble(float64(*p.JvmPoolNewGenUsed)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.jvmPoolNewGenUsed (4) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 4:jvmPoolNewGenUsed: ", p), err) }
  }
  return err
}

func (p *TFJvmGcDetailed) writeField5(oprot thrift.TProtocol) (err error) {
  if p.IsSetJvmPoolOldGenUsed() {
    if err := oprot.WriteFieldBegin("jvmPoolOldGenUsed", thrift.DOUBLE, 5); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:jvmPoolOldGenUsed: ", p), err) }
    if err := oprot.WriteDouble(float64(*p.JvmPoolOldGenUsed)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.jvmPoolOldGenUsed (5) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 5:jvmPoolOldGenUsed: ", p), err) }
  }
  return err
}

func (p *TFJvmGcDetailed) writeField6(oprot thrift.TProtocol) (err error) {
  if p.IsSetJvmPoolSurvivorSpaceUsed() {
    if err := oprot.WriteFieldBegin("jvmPoolSurvivorSpaceUsed", thrift.DOUBLE, 6); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 6:jvmPoolSurvivorSpaceUsed: ", p), err) }
    if err := oprot.WriteDouble(float64(*p.JvmPoolSurvivorSpaceUsed)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.jvmPoolSurvivorSpaceUsed (6) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 6:jvmPoolSurvivorSpaceUsed: ", p), err) }
  }
  return err
}

func (p *TFJvmGcDetailed) writeField7(oprot thrift.TProtocol) (err error) {
  if p.IsSetJvmPoolPermGenUsed() {
    if err := oprot.WriteFieldBegin("jvmPoolPermGenUsed", thrift.DOUBLE, 7); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 7:jvmPoolPermGenUsed: ", p), err) }
    if err := oprot.WriteDouble(float64(*p.JvmPoolPermGenUsed)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.jvmPoolPermGenUsed (7) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 7:jvmPoolPermGenUsed: ", p), err) }
  }
  return err
}

func (p *TFJvmGcDetailed) writeField8(oprot thrift.TProtocol) (err error) {
  if p.IsSetJvmPoolMetaspaceUsed() {
    if err := oprot.WriteFieldBegin("jvmPoolMetaspaceUsed", thrift.DOUBLE, 8); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 8:jvmPoolMetaspaceUsed: ", p), err) }
    if err := oprot.WriteDouble(float64(*p.JvmPoolMetaspaceUsed)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.jvmPoolMetaspaceUsed (8) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 8:jvmPoolMetaspaceUsed: ", p), err) }
  }
  return err
}

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

// Attributes:
//  - JvmCpuLoad
//  - SystemCpuLoad
type TFCpuLoad struct {
  JvmCpuLoad *float64 `thrift:"jvmCpuLoad,1" db:"jvmCpuLoad" json:"jvmCpuLoad,omitempty"`
  SystemCpuLoad *float64 `thrift:"systemCpuLoad,2" db:"systemCpuLoad" json:"systemCpuLoad,omitempty"`
}

func NewTFCpuLoad() *TFCpuLoad {
  return &TFCpuLoad{}
}

var TFCpuLoad_JvmCpuLoad_DEFAULT float64
func (p *TFCpuLoad) GetJvmCpuLoad() float64 {
  if !p.IsSetJvmCpuLoad() {
    return TFCpuLoad_JvmCpuLoad_DEFAULT
  }
return *p.JvmCpuLoad
}
var TFCpuLoad_SystemCpuLoad_DEFAULT float64
func (p *TFCpuLoad) GetSystemCpuLoad() float64 {
  if !p.IsSetSystemCpuLoad() {
    return TFCpuLoad_SystemCpuLoad_DEFAULT
  }
return *p.SystemCpuLoad
}
func (p *TFCpuLoad) IsSetJvmCpuLoad() bool {
  return p.JvmCpuLoad != nil
}

func (p *TFCpuLoad) IsSetSystemCpuLoad() bool {
  return p.SystemCpuLoad != nil
}

func (p *TFCpuLoad) Read(iprot thrift.TProtocol) 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 *TFCpuLoad)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadDouble(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.JvmCpuLoad = &v
}
  return nil
}

func (p *TFCpuLoad)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadDouble(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.SystemCpuLoad = &v
}
  return nil
}

func (p *TFCpuLoad) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("TFCpuLoad"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    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 *TFCpuLoad) writeField1(oprot thrift.TProtocol) (err error) {
  if p.IsSetJvmCpuLoad() {
    if err := oprot.WriteFieldBegin("jvmCpuLoad", thrift.DOUBLE, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:jvmCpuLoad: ", p), err) }
    if err := oprot.WriteDouble(float64(*p.JvmCpuLoad)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.jvmCpuLoad (1) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:jvmCpuLoad: ", p), err) }
  }
  return err
}

func (p *TFCpuLoad) writeField2(oprot thrift.TProtocol) (err error) {
  if p.IsSetSystemCpuLoad() {
    if err := oprot.WriteFieldBegin("systemCpuLoad", thrift.DOUBLE, 2); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:systemCpuLoad: ", p), err) }
    if err := oprot.WriteDouble(float64(*p.SystemCpuLoad)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.systemCpuLoad (2) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 2:systemCpuLoad: ", p), err) }
  }
  return err
}

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

// Attributes:
//  - SampledNewCount
//  - SampledContinuationCount
//  - UnsampledNewCount
//  - UnsampledContinuationCount
type TFTransaction struct {
  // unused field # 1
  SampledNewCount *int64 `thrift:"sampledNewCount,2" db:"sampledNewCount" json:"sampledNewCount,omitempty"`
  SampledContinuationCount *int64 `thrift:"sampledContinuationCount,3" db:"sampledContinuationCount" json:"sampledContinuationCount,omitempty"`
  UnsampledNewCount *int64 `thrift:"unsampledNewCount,4" db:"unsampledNewCount" json:"unsampledNewCount,omitempty"`
  UnsampledContinuationCount *int64 `thrift:"unsampledContinuationCount,5" db:"unsampledContinuationCount" json:"unsampledContinuationCount,omitempty"`
}

func NewTFTransaction() *TFTransaction {
  return &TFTransaction{}
}

var TFTransaction_SampledNewCount_DEFAULT int64
func (p *TFTransaction) GetSampledNewCount() int64 {
  if !p.IsSetSampledNewCount() {
    return TFTransaction_SampledNewCount_DEFAULT
  }
return *p.SampledNewCount
}
var TFTransaction_SampledContinuationCount_DEFAULT int64
func (p *TFTransaction) GetSampledContinuationCount() int64 {
  if !p.IsSetSampledContinuationCount() {
    return TFTransaction_SampledContinuationCount_DEFAULT
  }
return *p.SampledContinuationCount
}
var TFTransaction_UnsampledNewCount_DEFAULT int64
func (p *TFTransaction) GetUnsampledNewCount() int64 {
  if !p.IsSetUnsampledNewCount() {
    return TFTransaction_UnsampledNewCount_DEFAULT
  }
return *p.UnsampledNewCount
}
var TFTransaction_UnsampledContinuationCount_DEFAULT int64
func (p *TFTransaction) GetUnsampledContinuationCount() int64 {
  if !p.IsSetUnsampledContinuationCount() {
    return TFTransaction_UnsampledContinuationCount_DEFAULT
  }
return *p.UnsampledContinuationCount
}
func (p *TFTransaction) IsSetSampledNewCount() bool {
  return p.SampledNewCount != nil
}

func (p *TFTransaction) IsSetSampledContinuationCount() bool {
  return p.SampledContinuationCount != nil
}

func (p *TFTransaction) IsSetUnsampledNewCount() bool {
  return p.UnsampledNewCount != nil
}

func (p *TFTransaction) IsSetUnsampledContinuationCount() bool {
  return p.UnsampledContinuationCount != nil
}

func (p *TFTransaction) Read(iprot thrift.TProtocol) 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 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
      }
    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 *TFTransaction)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.SampledNewCount = &v
}
  return nil
}

func (p *TFTransaction)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.SampledContinuationCount = &v
}
  return nil
}

func (p *TFTransaction)  ReadField4(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 4: ", err)
} else {
  p.UnsampledNewCount = &v
}
  return nil
}

func (p *TFTransaction)  ReadField5(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 5: ", err)
} else {
  p.UnsampledContinuationCount = &v
}
  return nil
}

func (p *TFTransaction) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("TFTransaction"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    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 := 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 *TFTransaction) writeField2(oprot thrift.TProtocol) (err error) {
  if p.IsSetSampledNewCount() {
    if err := oprot.WriteFieldBegin("sampledNewCount", thrift.I64, 2); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:sampledNewCount: ", p), err) }
    if err := oprot.WriteI64(int64(*p.SampledNewCount)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.sampledNewCount (2) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 2:sampledNewCount: ", p), err) }
  }
  return err
}

func (p *TFTransaction) writeField3(oprot thrift.TProtocol) (err error) {
  if p.IsSetSampledContinuationCount() {
    if err := oprot.WriteFieldBegin("sampledContinuationCount", thrift.I64, 3); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:sampledContinuationCount: ", p), err) }
    if err := oprot.WriteI64(int64(*p.SampledContinuationCount)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.sampledContinuationCount (3) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 3:sampledContinuationCount: ", p), err) }
  }
  return err
}

func (p *TFTransaction) writeField4(oprot thrift.TProtocol) (err error) {
  if p.IsSetUnsampledNewCount() {
    if err := oprot.WriteFieldBegin("unsampledNewCount", thrift.I64, 4); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:unsampledNewCount: ", p), err) }
    if err := oprot.WriteI64(int64(*p.UnsampledNewCount)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.unsampledNewCount (4) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 4:unsampledNewCount: ", p), err) }
  }
  return err
}

func (p *TFTransaction) writeField5(oprot thrift.TProtocol) (err error) {
  if p.IsSetUnsampledContinuationCount() {
    if err := oprot.WriteFieldBegin("unsampledContinuationCount", thrift.I64, 5); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:unsampledContinuationCount: ", p), err) }
    if err := oprot.WriteI64(int64(*p.UnsampledContinuationCount)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.unsampledContinuationCount (5) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 5:unsampledContinuationCount: ", p), err) }
  }
  return err
}

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

// Attributes:
//  - Version
//  - HistogramSchemaType
//  - ActiveTraceCount
type TFActiveTraceHistogram struct {
  Version int16 `thrift:"version,1" db:"version" json:"version"`
  HistogramSchemaType *int32 `thrift:"histogramSchemaType,2" db:"histogramSchemaType" json:"histogramSchemaType,omitempty"`
  ActiveTraceCount []int32 `thrift:"activeTraceCount,3" db:"activeTraceCount" json:"activeTraceCount,omitempty"`
}

func NewTFActiveTraceHistogram() *TFActiveTraceHistogram {
  return &TFActiveTraceHistogram{}
}


func (p *TFActiveTraceHistogram) GetVersion() int16 {
  return p.Version
}
var TFActiveTraceHistogram_HistogramSchemaType_DEFAULT int32
func (p *TFActiveTraceHistogram) GetHistogramSchemaType() int32 {
  if !p.IsSetHistogramSchemaType() {
    return TFActiveTraceHistogram_HistogramSchemaType_DEFAULT
  }
return *p.HistogramSchemaType
}
var TFActiveTraceHistogram_ActiveTraceCount_DEFAULT []int32

func (p *TFActiveTraceHistogram) GetActiveTraceCount() []int32 {
  return p.ActiveTraceCount
}
func (p *TFActiveTraceHistogram) IsSetHistogramSchemaType() bool {
  return p.HistogramSchemaType != nil
}

func (p *TFActiveTraceHistogram) IsSetActiveTraceCount() bool {
  return p.ActiveTraceCount != nil
}

func (p *TFActiveTraceHistogram) Read(iprot thrift.TProtocol) 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
      }
    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 *TFActiveTraceHistogram)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI16(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.Version = v
}
  return nil
}

func (p *TFActiveTraceHistogram)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.HistogramSchemaType = &v
}
  return nil
}

func (p *TFActiveTraceHistogram)  ReadField3(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make([]int32, 0, size)
  p.ActiveTraceCount =  tSlice
  for i := 0; i < size; i ++ {
var _elem3 int32
    if v, err := iprot.ReadI32(); err != nil {
    return thrift.PrependError("error reading field 0: ", err)
} else {
    _elem3 = v
}
    p.ActiveTraceCount = append(p.ActiveTraceCount, _elem3)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *TFActiveTraceHistogram) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("TFActiveTraceHistogram"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    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 := 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 *TFActiveTraceHistogram) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("version", thrift.I16, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:version: ", p), err) }
  if err := oprot.WriteI16(int16(p.Version)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.version (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:version: ", p), err) }
  return err
}

func (p *TFActiveTraceHistogram) writeField2(oprot thrift.TProtocol) (err error) {
  if p.IsSetHistogramSchemaType() {
    if err := oprot.WriteFieldBegin("histogramSchemaType", thrift.I32, 2); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:histogramSchemaType: ", p), err) }
    if err := oprot.WriteI32(int32(*p.HistogramSchemaType)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.histogramSchemaType (2) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 2:histogramSchemaType: ", p), err) }
  }
  return err
}

func (p *TFActiveTraceHistogram) writeField3(oprot thrift.TProtocol) (err error) {
  if p.IsSetActiveTraceCount() {
    if err := oprot.WriteFieldBegin("activeTraceCount", thrift.LIST, 3); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:activeTraceCount: ", p), err) }
    if err := oprot.WriteListBegin(thrift.I32, len(p.ActiveTraceCount)); err != nil {
      return thrift.PrependError("error writing list begin: ", err)
    }
    for _, v := range p.ActiveTraceCount {
      if err := oprot.WriteI32(int32(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 3:activeTraceCount: ", p), err) }
  }
  return err
}

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

// Attributes:
//  - Histogram
type TFActiveTrace struct {
  Histogram *TFActiveTraceHistogram `thrift:"histogram,1" db:"histogram" json:"histogram,omitempty"`
}

func NewTFActiveTrace() *TFActiveTrace {
  return &TFActiveTrace{}
}

var TFActiveTrace_Histogram_DEFAULT *TFActiveTraceHistogram
func (p *TFActiveTrace) GetHistogram() *TFActiveTraceHistogram {
  if !p.IsSetHistogram() {
    return TFActiveTrace_Histogram_DEFAULT
  }
return p.Histogram
}
func (p *TFActiveTrace) IsSetHistogram() bool {
  return p.Histogram != nil
}

func (p *TFActiveTrace) Read(iprot thrift.TProtocol) 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 *TFActiveTrace)  ReadField1(iprot thrift.TProtocol) error {
  p.Histogram = &TFActiveTraceHistogram{}
  if err := p.Histogram.Read(iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Histogram), err)
  }
  return nil
}

func (p *TFActiveTrace) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("TFActiveTrace"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    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 *TFActiveTrace) writeField1(oprot thrift.TProtocol) (err error) {
  if p.IsSetHistogram() {
    if err := oprot.WriteFieldBegin("histogram", thrift.STRUCT, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:histogram: ", p), err) }
    if err := p.Histogram.Write(oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Histogram), err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:histogram: ", p), err) }
  }
  return err
}

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

// Attributes:
//  - Avg
type TFResponseTime struct {
  Avg int64 `thrift:"avg,1" db:"avg" json:"avg,omitempty"`
}

func NewTFResponseTime() *TFResponseTime {
  return &TFResponseTime{}
}

var TFResponseTime_Avg_DEFAULT int64 = 0

func (p *TFResponseTime) GetAvg() int64 {
  return p.Avg
}
func (p *TFResponseTime) IsSetAvg() bool {
  return p.Avg != TFResponseTime_Avg_DEFAULT
}

func (p *TFResponseTime) Read(iprot thrift.TProtocol) 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 *TFResponseTime)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.Avg = v
}
  return nil
}

func (p *TFResponseTime) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("TFResponseTime"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    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 *TFResponseTime) writeField1(oprot thrift.TProtocol) (err error) {
  if p.IsSetAvg() {
    if err := oprot.WriteFieldBegin("avg", thrift.I64, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:avg: ", p), err) }
    if err := oprot.WriteI64(int64(p.Avg)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.avg (1) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:avg: ", p), err) }
  }
  return err
}

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

// Attributes:
//  - AgentId
//  - StartTimestamp
//  - Timestamp
//  - CollectInterval
//  - Gc
//  - CpuLoad
//  - Transaction
//  - ActiveTrace
//  - DataSourceList
//  - ResponseTime
//  - Metadata
type TFAgentStat struct {
  AgentId *string `thrift:"agentId,1" db:"agentId" json:"agentId,omitempty"`
  StartTimestamp *int64 `thrift:"startTimestamp,2" db:"startTimestamp" json:"startTimestamp,omitempty"`
  Timestamp *int64 `thrift:"timestamp,3" db:"timestamp" json:"timestamp,omitempty"`
  CollectInterval *int64 `thrift:"collectInterval,4" db:"collectInterval" json:"collectInterval,omitempty"`
  // unused fields # 5 to 9
  Gc *TFJvmGc `thrift:"gc,10" db:"gc" json:"gc,omitempty"`
  // unused fields # 11 to 19
  CpuLoad *TFCpuLoad `thrift:"cpuLoad,20" db:"cpuLoad" json:"cpuLoad,omitempty"`
  // unused fields # 21 to 29
  Transaction *TFTransaction `thrift:"transaction,30" db:"transaction" json:"transaction,omitempty"`
  // unused fields # 31 to 39
  ActiveTrace *TFActiveTrace `thrift:"activeTrace,40" db:"activeTrace" json:"activeTrace,omitempty"`
  // unused fields # 41 to 49
  DataSourceList *TFDataSourceList `thrift:"dataSourceList,50" db:"dataSourceList" json:"dataSourceList,omitempty"`
  // unused fields # 51 to 59
  ResponseTime *TFResponseTime `thrift:"responseTime,60" db:"responseTime" json:"responseTime,omitempty"`
  // unused fields # 61 to 199
  Metadata *string `thrift:"metadata,200" db:"metadata" json:"metadata,omitempty"`
}

func NewTFAgentStat() *TFAgentStat {
  return &TFAgentStat{}
}

var TFAgentStat_AgentId_DEFAULT string
func (p *TFAgentStat) GetAgentId() string {
  if !p.IsSetAgentId() {
    return TFAgentStat_AgentId_DEFAULT
  }
return *p.AgentId
}
var TFAgentStat_StartTimestamp_DEFAULT int64
func (p *TFAgentStat) GetStartTimestamp() int64 {
  if !p.IsSetStartTimestamp() {
    return TFAgentStat_StartTimestamp_DEFAULT
  }
return *p.StartTimestamp
}
var TFAgentStat_Timestamp_DEFAULT int64
func (p *TFAgentStat) GetTimestamp() int64 {
  if !p.IsSetTimestamp() {
    return TFAgentStat_Timestamp_DEFAULT
  }
return *p.Timestamp
}
var TFAgentStat_CollectInterval_DEFAULT int64
func (p *TFAgentStat) GetCollectInterval() int64 {
  if !p.IsSetCollectInterval() {
    return TFAgentStat_CollectInterval_DEFAULT
  }
return *p.CollectInterval
}
var TFAgentStat_Gc_DEFAULT *TFJvmGc
func (p *TFAgentStat) GetGc() *TFJvmGc {
  if !p.IsSetGc() {
    return TFAgentStat_Gc_DEFAULT
  }
return p.Gc
}
var TFAgentStat_CpuLoad_DEFAULT *TFCpuLoad
func (p *TFAgentStat) GetCpuLoad() *TFCpuLoad {
  if !p.IsSetCpuLoad() {
    return TFAgentStat_CpuLoad_DEFAULT
  }
return p.CpuLoad
}
var TFAgentStat_Transaction_DEFAULT *TFTransaction
func (p *TFAgentStat) GetTransaction() *TFTransaction {
  if !p.IsSetTransaction() {
    return TFAgentStat_Transaction_DEFAULT
  }
return p.Transaction
}
var TFAgentStat_ActiveTrace_DEFAULT *TFActiveTrace
func (p *TFAgentStat) GetActiveTrace() *TFActiveTrace {
  if !p.IsSetActiveTrace() {
    return TFAgentStat_ActiveTrace_DEFAULT
  }
return p.ActiveTrace
}
var TFAgentStat_DataSourceList_DEFAULT *TFDataSourceList
func (p *TFAgentStat) GetDataSourceList() *TFDataSourceList {
  if !p.IsSetDataSourceList() {
    return TFAgentStat_DataSourceList_DEFAULT
  }
return p.DataSourceList
}
var TFAgentStat_ResponseTime_DEFAULT *TFResponseTime
func (p *TFAgentStat) GetResponseTime() *TFResponseTime {
  if !p.IsSetResponseTime() {
    return TFAgentStat_ResponseTime_DEFAULT
  }
return p.ResponseTime
}
var TFAgentStat_Metadata_DEFAULT string
func (p *TFAgentStat) GetMetadata() string {
  if !p.IsSetMetadata() {
    return TFAgentStat_Metadata_DEFAULT
  }
return *p.Metadata
}
func (p *TFAgentStat) IsSetAgentId() bool {
  return p.AgentId != nil
}

func (p *TFAgentStat) IsSetStartTimestamp() bool {
  return p.StartTimestamp != nil
}

func (p *TFAgentStat) IsSetTimestamp() bool {
  return p.Timestamp != nil
}

func (p *TFAgentStat) IsSetCollectInterval() bool {
  return p.CollectInterval != nil
}

func (p *TFAgentStat) IsSetGc() bool {
  return p.Gc != nil
}

func (p *TFAgentStat) IsSetCpuLoad() bool {
  return p.CpuLoad != nil
}

func (p *TFAgentStat) IsSetTransaction() bool {
  return p.Transaction != nil
}

func (p *TFAgentStat) IsSetActiveTrace() bool {
  return p.ActiveTrace != nil
}

func (p *TFAgentStat) IsSetDataSourceList() bool {
  return p.DataSourceList != nil
}

func (p *TFAgentStat) IsSetResponseTime() bool {
  return p.ResponseTime != nil
}

func (p *TFAgentStat) IsSetMetadata() bool {
  return p.Metadata != nil
}

func (p *TFAgentStat) Read(iprot thrift.TProtocol) 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 10:
      if err := p.ReadField10(iprot); err != nil {
        return err
      }
    case 20:
      if err := p.ReadField20(iprot); err != nil {
        return err
      }
    case 30:
      if err := p.ReadField30(iprot); err != nil {
        return err
      }
    case 40:
      if err := p.ReadField40(iprot); err != nil {
        return err
      }
    case 50:
      if err := p.ReadField50(iprot); err != nil {
        return err
      }
    case 60:
      if err := p.ReadField60(iprot); err != nil {
        return err
      }
    case 200:
      if err := p.ReadField200(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 *TFAgentStat)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.AgentId = &v
}
  return nil
}

func (p *TFAgentStat)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.StartTimestamp = &v
}
  return nil
}

func (p *TFAgentStat)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.Timestamp = &v
}
  return nil
}

func (p *TFAgentStat)  ReadField4(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 4: ", err)
} else {
  p.CollectInterval = &v
}
  return nil
}

func (p *TFAgentStat)  ReadField10(iprot thrift.TProtocol) error {
  p.Gc = &TFJvmGc{
  Type:   0,
}
  if err := p.Gc.Read(iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Gc), err)
  }
  return nil
}

func (p *TFAgentStat)  ReadField20(iprot thrift.TProtocol) error {
  p.CpuLoad = &TFCpuLoad{}
  if err := p.CpuLoad.Read(iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.CpuLoad), err)
  }
  return nil
}

func (p *TFAgentStat)  ReadField30(iprot thrift.TProtocol) error {
  p.Transaction = &TFTransaction{}
  if err := p.Transaction.Read(iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Transaction), err)
  }
  return nil
}

func (p *TFAgentStat)  ReadField40(iprot thrift.TProtocol) error {
  p.ActiveTrace = &TFActiveTrace{}
  if err := p.ActiveTrace.Read(iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.ActiveTrace), err)
  }
  return nil
}

func (p *TFAgentStat)  ReadField50(iprot thrift.TProtocol) error {
  p.DataSourceList = &TFDataSourceList{}
  if err := p.DataSourceList.Read(iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.DataSourceList), err)
  }
  return nil
}

func (p *TFAgentStat)  ReadField60(iprot thrift.TProtocol) error {
  p.ResponseTime = &TFResponseTime{}
  if err := p.ResponseTime.Read(iprot); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.ResponseTime), err)
  }
  return nil
}

func (p *TFAgentStat)  ReadField200(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 200: ", err)
} else {
  p.Metadata = &v
}
  return nil
}

func (p *TFAgentStat) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("TFAgentStat"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    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.writeField10(oprot); err != nil { return err }
    if err := p.writeField20(oprot); err != nil { return err }
    if err := p.writeField30(oprot); err != nil { return err }
    if err := p.writeField40(oprot); err != nil { return err }
    if err := p.writeField50(oprot); err != nil { return err }
    if err := p.writeField60(oprot); err != nil { return err }
    if err := p.writeField200(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 *TFAgentStat) writeField1(oprot thrift.TProtocol) (err error) {
  if p.IsSetAgentId() {
    if err := oprot.WriteFieldBegin("agentId", thrift.STRING, 1); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:agentId: ", p), err) }
    if err := oprot.WriteString(string(*p.AgentId)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.agentId (1) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 1:agentId: ", p), err) }
  }
  return err
}

func (p *TFAgentStat) writeField2(oprot thrift.TProtocol) (err error) {
  if p.IsSetStartTimestamp() {
    if err := oprot.WriteFieldBegin("startTimestamp", thrift.I64, 2); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:startTimestamp: ", p), err) }
    if err := oprot.WriteI64(int64(*p.StartTimestamp)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.startTimestamp (2) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 2:startTimestamp: ", p), err) }
  }
  return err
}

func (p *TFAgentStat) writeField3(oprot thrift.TProtocol) (err error) {
  if p.IsSetTimestamp() {
    if err := oprot.WriteFieldBegin("timestamp", thrift.I64, 3); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:timestamp: ", p), err) }
    if err := oprot.WriteI64(int64(*p.Timestamp)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.timestamp (3) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 3:timestamp: ", p), err) }
  }
  return err
}

func (p *TFAgentStat) writeField4(oprot thrift.TProtocol) (err error) {
  if p.IsSetCollectInterval() {
    if err := oprot.WriteFieldBegin("collectInterval", thrift.I64, 4); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:collectInterval: ", p), err) }
    if err := oprot.WriteI64(int64(*p.CollectInterval)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.collectInterval (4) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 4:collectInterval: ", p), err) }
  }
  return err
}

func (p *TFAgentStat) writeField10(oprot thrift.TProtocol) (err error) {
  if p.IsSetGc() {
    if err := oprot.WriteFieldBegin("gc", thrift.STRUCT, 10); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 10:gc: ", p), err) }
    if err := p.Gc.Write(oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Gc), err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 10:gc: ", p), err) }
  }
  return err
}

func (p *TFAgentStat) writeField20(oprot thrift.TProtocol) (err error) {
  if p.IsSetCpuLoad() {
    if err := oprot.WriteFieldBegin("cpuLoad", thrift.STRUCT, 20); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 20:cpuLoad: ", p), err) }
    if err := p.CpuLoad.Write(oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.CpuLoad), err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 20:cpuLoad: ", p), err) }
  }
  return err
}

func (p *TFAgentStat) writeField30(oprot thrift.TProtocol) (err error) {
  if p.IsSetTransaction() {
    if err := oprot.WriteFieldBegin("transaction", thrift.STRUCT, 30); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 30:transaction: ", p), err) }
    if err := p.Transaction.Write(oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Transaction), err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 30:transaction: ", p), err) }
  }
  return err
}

func (p *TFAgentStat) writeField40(oprot thrift.TProtocol) (err error) {
  if p.IsSetActiveTrace() {
    if err := oprot.WriteFieldBegin("activeTrace", thrift.STRUCT, 40); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 40:activeTrace: ", p), err) }
    if err := p.ActiveTrace.Write(oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.ActiveTrace), err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 40:activeTrace: ", p), err) }
  }
  return err
}

func (p *TFAgentStat) writeField50(oprot thrift.TProtocol) (err error) {
  if p.IsSetDataSourceList() {
    if err := oprot.WriteFieldBegin("dataSourceList", thrift.STRUCT, 50); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 50:dataSourceList: ", p), err) }
    if err := p.DataSourceList.Write(oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.DataSourceList), err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 50:dataSourceList: ", p), err) }
  }
  return err
}

func (p *TFAgentStat) writeField60(oprot thrift.TProtocol) (err error) {
  if p.IsSetResponseTime() {
    if err := oprot.WriteFieldBegin("responseTime", thrift.STRUCT, 60); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 60:responseTime: ", p), err) }
    if err := p.ResponseTime.Write(oprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.ResponseTime), err)
    }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 60:responseTime: ", p), err) }
  }
  return err
}

func (p *TFAgentStat) writeField200(oprot thrift.TProtocol) (err error) {
  if p.IsSetMetadata() {
    if err := oprot.WriteFieldBegin("metadata", thrift.STRING, 200); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 200:metadata: ", p), err) }
    if err := oprot.WriteString(string(*p.Metadata)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.metadata (200) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 200:metadata: ", p), err) }
  }
  return err
}

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

// Attributes:
//  - AgentId
//  - StartTimestamp
//  - AgentStats
type TFAgentStatBatch struct {
  AgentId string `thrift:"agentId,1" db:"agentId" json:"agentId"`
  StartTimestamp int64 `thrift:"startTimestamp,2" db:"startTimestamp" json:"startTimestamp"`
  // unused fields # 3 to 9
  AgentStats []*TFAgentStat `thrift:"agentStats,10" db:"agentStats" json:"agentStats"`
}

func NewTFAgentStatBatch() *TFAgentStatBatch {
  return &TFAgentStatBatch{}
}


func (p *TFAgentStatBatch) GetAgentId() string {
  return p.AgentId
}

func (p *TFAgentStatBatch) GetStartTimestamp() int64 {
  return p.StartTimestamp
}

func (p *TFAgentStatBatch) GetAgentStats() []*TFAgentStat {
  return p.AgentStats
}
func (p *TFAgentStatBatch) Read(iprot thrift.TProtocol) 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 10:
      if err := p.ReadField10(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 *TFAgentStatBatch)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.AgentId = v
}
  return nil
}

func (p *TFAgentStatBatch)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI64(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.StartTimestamp = v
}
  return nil
}

func (p *TFAgentStatBatch)  ReadField10(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make([]*TFAgentStat, 0, size)
  p.AgentStats =  tSlice
  for i := 0; i < size; i ++ {
    _elem4 := &TFAgentStat{}
    if err := _elem4.Read(iprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem4), err)
    }
    p.AgentStats = append(p.AgentStats, _elem4)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *TFAgentStatBatch) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("TFAgentStatBatch"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    if err := p.writeField1(oprot); err != nil { return err }
    if err := p.writeField2(oprot); err != nil { return err }
    if err := p.writeField10(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 *TFAgentStatBatch) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("agentId", thrift.STRING, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:agentId: ", p), err) }
  if err := oprot.WriteString(string(p.AgentId)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.agentId (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:agentId: ", p), err) }
  return err
}

func (p *TFAgentStatBatch) writeField2(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("startTimestamp", thrift.I64, 2); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:startTimestamp: ", p), err) }
  if err := oprot.WriteI64(int64(p.StartTimestamp)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.startTimestamp (2) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 2:startTimestamp: ", p), err) }
  return err
}

func (p *TFAgentStatBatch) writeField10(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("agentStats", thrift.LIST, 10); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 10:agentStats: ", p), err) }
  if err := oprot.WriteListBegin(thrift.STRUCT, len(p.AgentStats)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.AgentStats {
    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 10:agentStats: ", p), err) }
  return err
}

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

// Attributes:
//  - ID
//  - ServiceTypeCode
//  - DatabaseName
//  - URL
//  - ActiveConnectionSize
//  - MaxConnectionSize
type TFDataSource struct {
  ID int32 `thrift:"id,1" db:"id" json:"id"`
  ServiceTypeCode *int16 `thrift:"serviceTypeCode,2" db:"serviceTypeCode" json:"serviceTypeCode,omitempty"`
  DatabaseName *string `thrift:"databaseName,3" db:"databaseName" json:"databaseName,omitempty"`
  URL *string `thrift:"url,4" db:"url" json:"url,omitempty"`
  ActiveConnectionSize int32 `thrift:"activeConnectionSize,5" db:"activeConnectionSize" json:"activeConnectionSize,omitempty"`
  MaxConnectionSize *int32 `thrift:"maxConnectionSize,6" db:"maxConnectionSize" json:"maxConnectionSize,omitempty"`
}

func NewTFDataSource() *TFDataSource {
  return &TFDataSource{}
}


func (p *TFDataSource) GetID() int32 {
  return p.ID
}
var TFDataSource_ServiceTypeCode_DEFAULT int16
func (p *TFDataSource) GetServiceTypeCode() int16 {
  if !p.IsSetServiceTypeCode() {
    return TFDataSource_ServiceTypeCode_DEFAULT
  }
return *p.ServiceTypeCode
}
var TFDataSource_DatabaseName_DEFAULT string
func (p *TFDataSource) GetDatabaseName() string {
  if !p.IsSetDatabaseName() {
    return TFDataSource_DatabaseName_DEFAULT
  }
return *p.DatabaseName
}
var TFDataSource_URL_DEFAULT string
func (p *TFDataSource) GetURL() string {
  if !p.IsSetURL() {
    return TFDataSource_URL_DEFAULT
  }
return *p.URL
}
var TFDataSource_ActiveConnectionSize_DEFAULT int32 = 0

func (p *TFDataSource) GetActiveConnectionSize() int32 {
  return p.ActiveConnectionSize
}
var TFDataSource_MaxConnectionSize_DEFAULT int32
func (p *TFDataSource) GetMaxConnectionSize() int32 {
  if !p.IsSetMaxConnectionSize() {
    return TFDataSource_MaxConnectionSize_DEFAULT
  }
return *p.MaxConnectionSize
}
func (p *TFDataSource) IsSetServiceTypeCode() bool {
  return p.ServiceTypeCode != nil
}

func (p *TFDataSource) IsSetDatabaseName() bool {
  return p.DatabaseName != nil
}

func (p *TFDataSource) IsSetURL() bool {
  return p.URL != nil
}

func (p *TFDataSource) IsSetActiveConnectionSize() bool {
  return p.ActiveConnectionSize != TFDataSource_ActiveConnectionSize_DEFAULT
}

func (p *TFDataSource) IsSetMaxConnectionSize() bool {
  return p.MaxConnectionSize != nil
}

func (p *TFDataSource) Read(iprot thrift.TProtocol) 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
      }
    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 *TFDataSource)  ReadField1(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 1: ", err)
} else {
  p.ID = v
}
  return nil
}

func (p *TFDataSource)  ReadField2(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI16(); err != nil {
  return thrift.PrependError("error reading field 2: ", err)
} else {
  p.ServiceTypeCode = &v
}
  return nil
}

func (p *TFDataSource)  ReadField3(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 3: ", err)
} else {
  p.DatabaseName = &v
}
  return nil
}

func (p *TFDataSource)  ReadField4(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadString(); err != nil {
  return thrift.PrependError("error reading field 4: ", err)
} else {
  p.URL = &v
}
  return nil
}

func (p *TFDataSource)  ReadField5(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 5: ", err)
} else {
  p.ActiveConnectionSize = v
}
  return nil
}

func (p *TFDataSource)  ReadField6(iprot thrift.TProtocol) error {
  if v, err := iprot.ReadI32(); err != nil {
  return thrift.PrependError("error reading field 6: ", err)
} else {
  p.MaxConnectionSize = &v
}
  return nil
}

func (p *TFDataSource) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("TFDataSource"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    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 := 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 *TFDataSource) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("id", thrift.I32, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:id: ", p), err) }
  if err := oprot.WriteI32(int32(p.ID)); err != nil {
  return thrift.PrependError(fmt.Sprintf("%T.id (1) field write error: ", p), err) }
  if err := oprot.WriteFieldEnd(); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field end error 1:id: ", p), err) }
  return err
}

func (p *TFDataSource) writeField2(oprot thrift.TProtocol) (err error) {
  if p.IsSetServiceTypeCode() {
    if err := oprot.WriteFieldBegin("serviceTypeCode", thrift.I16, 2); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:serviceTypeCode: ", p), err) }
    if err := oprot.WriteI16(int16(*p.ServiceTypeCode)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.serviceTypeCode (2) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 2:serviceTypeCode: ", p), err) }
  }
  return err
}

func (p *TFDataSource) writeField3(oprot thrift.TProtocol) (err error) {
  if p.IsSetDatabaseName() {
    if err := oprot.WriteFieldBegin("databaseName", thrift.STRING, 3); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:databaseName: ", p), err) }
    if err := oprot.WriteString(string(*p.DatabaseName)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.databaseName (3) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 3:databaseName: ", p), err) }
  }
  return err
}

func (p *TFDataSource) writeField4(oprot thrift.TProtocol) (err error) {
  if p.IsSetURL() {
    if err := oprot.WriteFieldBegin("url", thrift.STRING, 4); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:url: ", p), err) }
    if err := oprot.WriteString(string(*p.URL)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.url (4) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 4:url: ", p), err) }
  }
  return err
}

func (p *TFDataSource) writeField5(oprot thrift.TProtocol) (err error) {
  if p.IsSetActiveConnectionSize() {
    if err := oprot.WriteFieldBegin("activeConnectionSize", thrift.I32, 5); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:activeConnectionSize: ", p), err) }
    if err := oprot.WriteI32(int32(p.ActiveConnectionSize)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.activeConnectionSize (5) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 5:activeConnectionSize: ", p), err) }
  }
  return err
}

func (p *TFDataSource) writeField6(oprot thrift.TProtocol) (err error) {
  if p.IsSetMaxConnectionSize() {
    if err := oprot.WriteFieldBegin("maxConnectionSize", thrift.I32, 6); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field begin error 6:maxConnectionSize: ", p), err) }
    if err := oprot.WriteI32(int32(*p.MaxConnectionSize)); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T.maxConnectionSize (6) field write error: ", p), err) }
    if err := oprot.WriteFieldEnd(); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T write field end error 6:maxConnectionSize: ", p), err) }
  }
  return err
}

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

// Attributes:
//  - DataSourceList
type TFDataSourceList struct {
  DataSourceList []*TFDataSource `thrift:"dataSourceList,1" db:"dataSourceList" json:"dataSourceList"`
}

func NewTFDataSourceList() *TFDataSourceList {
  return &TFDataSourceList{}
}


func (p *TFDataSourceList) GetDataSourceList() []*TFDataSource {
  return p.DataSourceList
}
func (p *TFDataSourceList) Read(iprot thrift.TProtocol) 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 *TFDataSourceList)  ReadField1(iprot thrift.TProtocol) error {
  _, size, err := iprot.ReadListBegin()
  if err != nil {
    return thrift.PrependError("error reading list begin: ", err)
  }
  tSlice := make([]*TFDataSource, 0, size)
  p.DataSourceList =  tSlice
  for i := 0; i < size; i ++ {
    _elem5 := &TFDataSource{}
    if err := _elem5.Read(iprot); err != nil {
      return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem5), err)
    }
    p.DataSourceList = append(p.DataSourceList, _elem5)
  }
  if err := iprot.ReadListEnd(); err != nil {
    return thrift.PrependError("error reading list end: ", err)
  }
  return nil
}

func (p *TFDataSourceList) Write(oprot thrift.TProtocol) error {
  if err := oprot.WriteStructBegin("TFDataSourceList"); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) }
  if p != nil {
    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 *TFDataSourceList) writeField1(oprot thrift.TProtocol) (err error) {
  if err := oprot.WriteFieldBegin("dataSourceList", thrift.LIST, 1); err != nil {
    return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:dataSourceList: ", p), err) }
  if err := oprot.WriteListBegin(thrift.STRUCT, len(p.DataSourceList)); err != nil {
    return thrift.PrependError("error writing list begin: ", err)
  }
  for _, v := range p.DataSourceList {
    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:dataSourceList: ", p), err) }
  return err
}

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