| // Code generated by Thrift Compiler (0.14.1). DO NOT EDIT. |
| |
| package common |
| |
| import( |
| "bytes" |
| "context" |
| "database/sql/driver" |
| "errors" |
| "fmt" |
| "time" |
| "github.com/apache/thrift/lib/go/thrift" |
| ) |
| |
| // (needed to ensure safety because of naive import list construction.) |
| var _ = thrift.ZERO |
| var _ = fmt.Printf |
| var _ = context.Background |
| var _ = time.Now |
| var _ = bytes.Equal |
| |
| type TConsensusGroupType int64 |
| const ( |
| TConsensusGroupType_ConfigRegion TConsensusGroupType = 0 |
| TConsensusGroupType_DataRegion TConsensusGroupType = 1 |
| TConsensusGroupType_SchemaRegion TConsensusGroupType = 2 |
| ) |
| |
| func (p TConsensusGroupType) String() string { |
| switch p { |
| case TConsensusGroupType_ConfigRegion: return "ConfigRegion" |
| case TConsensusGroupType_DataRegion: return "DataRegion" |
| case TConsensusGroupType_SchemaRegion: return "SchemaRegion" |
| } |
| return "<UNSET>" |
| } |
| |
| func TConsensusGroupTypeFromString(s string) (TConsensusGroupType, error) { |
| switch s { |
| case "ConfigRegion": return TConsensusGroupType_ConfigRegion, nil |
| case "DataRegion": return TConsensusGroupType_DataRegion, nil |
| case "SchemaRegion": return TConsensusGroupType_SchemaRegion, nil |
| } |
| return TConsensusGroupType(0), fmt.Errorf("not a valid TConsensusGroupType string") |
| } |
| |
| |
| func TConsensusGroupTypePtr(v TConsensusGroupType) *TConsensusGroupType { return &v } |
| |
| func (p TConsensusGroupType) MarshalText() ([]byte, error) { |
| return []byte(p.String()), nil |
| } |
| |
| func (p *TConsensusGroupType) UnmarshalText(text []byte) error { |
| q, err := TConsensusGroupTypeFromString(string(text)) |
| if (err != nil) { |
| return err |
| } |
| *p = q |
| return nil |
| } |
| |
| func (p *TConsensusGroupType) Scan(value interface{}) error { |
| v, ok := value.(int64) |
| if !ok { |
| return errors.New("Scan value is not int64") |
| } |
| *p = TConsensusGroupType(v) |
| return nil |
| } |
| |
| func (p * TConsensusGroupType) Value() (driver.Value, error) { |
| if p == nil { |
| return nil, nil |
| } |
| return int64(*p), nil |
| } |
| type TRegionMigrateFailedType int64 |
| const ( |
| TRegionMigrateFailedType_AddPeerFailed TRegionMigrateFailedType = 0 |
| TRegionMigrateFailedType_RemovePeerFailed TRegionMigrateFailedType = 1 |
| TRegionMigrateFailedType_RemoveConsensusGroupFailed TRegionMigrateFailedType = 2 |
| TRegionMigrateFailedType_DeleteRegionFailed TRegionMigrateFailedType = 3 |
| TRegionMigrateFailedType_CreateRegionFailed TRegionMigrateFailedType = 4 |
| ) |
| |
| func (p TRegionMigrateFailedType) String() string { |
| switch p { |
| case TRegionMigrateFailedType_AddPeerFailed: return "AddPeerFailed" |
| case TRegionMigrateFailedType_RemovePeerFailed: return "RemovePeerFailed" |
| case TRegionMigrateFailedType_RemoveConsensusGroupFailed: return "RemoveConsensusGroupFailed" |
| case TRegionMigrateFailedType_DeleteRegionFailed: return "DeleteRegionFailed" |
| case TRegionMigrateFailedType_CreateRegionFailed: return "CreateRegionFailed" |
| } |
| return "<UNSET>" |
| } |
| |
| func TRegionMigrateFailedTypeFromString(s string) (TRegionMigrateFailedType, error) { |
| switch s { |
| case "AddPeerFailed": return TRegionMigrateFailedType_AddPeerFailed, nil |
| case "RemovePeerFailed": return TRegionMigrateFailedType_RemovePeerFailed, nil |
| case "RemoveConsensusGroupFailed": return TRegionMigrateFailedType_RemoveConsensusGroupFailed, nil |
| case "DeleteRegionFailed": return TRegionMigrateFailedType_DeleteRegionFailed, nil |
| case "CreateRegionFailed": return TRegionMigrateFailedType_CreateRegionFailed, nil |
| } |
| return TRegionMigrateFailedType(0), fmt.Errorf("not a valid TRegionMigrateFailedType string") |
| } |
| |
| |
| func TRegionMigrateFailedTypePtr(v TRegionMigrateFailedType) *TRegionMigrateFailedType { return &v } |
| |
| func (p TRegionMigrateFailedType) MarshalText() ([]byte, error) { |
| return []byte(p.String()), nil |
| } |
| |
| func (p *TRegionMigrateFailedType) UnmarshalText(text []byte) error { |
| q, err := TRegionMigrateFailedTypeFromString(string(text)) |
| if (err != nil) { |
| return err |
| } |
| *p = q |
| return nil |
| } |
| |
| func (p *TRegionMigrateFailedType) Scan(value interface{}) error { |
| v, ok := value.(int64) |
| if !ok { |
| return errors.New("Scan value is not int64") |
| } |
| *p = TRegionMigrateFailedType(v) |
| return nil |
| } |
| |
| func (p * TRegionMigrateFailedType) Value() (driver.Value, error) { |
| if p == nil { |
| return nil, nil |
| } |
| return int64(*p), nil |
| } |
| type ThrottleType int64 |
| const ( |
| ThrottleType_REQUEST_NUMBER ThrottleType = 0 |
| ThrottleType_REQUEST_SIZE ThrottleType = 1 |
| ThrottleType_WRITE_NUMBER ThrottleType = 2 |
| ThrottleType_WRITE_SIZE ThrottleType = 3 |
| ThrottleType_READ_NUMBER ThrottleType = 4 |
| ThrottleType_READ_SIZE ThrottleType = 5 |
| ) |
| |
| func (p ThrottleType) String() string { |
| switch p { |
| case ThrottleType_REQUEST_NUMBER: return "REQUEST_NUMBER" |
| case ThrottleType_REQUEST_SIZE: return "REQUEST_SIZE" |
| case ThrottleType_WRITE_NUMBER: return "WRITE_NUMBER" |
| case ThrottleType_WRITE_SIZE: return "WRITE_SIZE" |
| case ThrottleType_READ_NUMBER: return "READ_NUMBER" |
| case ThrottleType_READ_SIZE: return "READ_SIZE" |
| } |
| return "<UNSET>" |
| } |
| |
| func ThrottleTypeFromString(s string) (ThrottleType, error) { |
| switch s { |
| case "REQUEST_NUMBER": return ThrottleType_REQUEST_NUMBER, nil |
| case "REQUEST_SIZE": return ThrottleType_REQUEST_SIZE, nil |
| case "WRITE_NUMBER": return ThrottleType_WRITE_NUMBER, nil |
| case "WRITE_SIZE": return ThrottleType_WRITE_SIZE, nil |
| case "READ_NUMBER": return ThrottleType_READ_NUMBER, nil |
| case "READ_SIZE": return ThrottleType_READ_SIZE, nil |
| } |
| return ThrottleType(0), fmt.Errorf("not a valid ThrottleType string") |
| } |
| |
| |
| func ThrottleTypePtr(v ThrottleType) *ThrottleType { return &v } |
| |
| func (p ThrottleType) MarshalText() ([]byte, error) { |
| return []byte(p.String()), nil |
| } |
| |
| func (p *ThrottleType) UnmarshalText(text []byte) error { |
| q, err := ThrottleTypeFromString(string(text)) |
| if (err != nil) { |
| return err |
| } |
| *p = q |
| return nil |
| } |
| |
| func (p *ThrottleType) Scan(value interface{}) error { |
| v, ok := value.(int64) |
| if !ok { |
| return errors.New("Scan value is not int64") |
| } |
| *p = ThrottleType(v) |
| return nil |
| } |
| |
| func (p * ThrottleType) Value() (driver.Value, error) { |
| if p == nil { |
| return nil, nil |
| } |
| return int64(*p), nil |
| } |
| type TAggregationType int64 |
| const ( |
| TAggregationType_COUNT TAggregationType = 0 |
| TAggregationType_AVG TAggregationType = 1 |
| TAggregationType_SUM TAggregationType = 2 |
| TAggregationType_FIRST_VALUE TAggregationType = 3 |
| TAggregationType_LAST_VALUE TAggregationType = 4 |
| TAggregationType_MAX_TIME TAggregationType = 5 |
| TAggregationType_MIN_TIME TAggregationType = 6 |
| TAggregationType_MAX_VALUE TAggregationType = 7 |
| TAggregationType_MIN_VALUE TAggregationType = 8 |
| TAggregationType_EXTREME TAggregationType = 9 |
| TAggregationType_COUNT_IF TAggregationType = 10 |
| TAggregationType_TIME_DURATION TAggregationType = 11 |
| TAggregationType_MODE TAggregationType = 12 |
| ) |
| |
| func (p TAggregationType) String() string { |
| switch p { |
| case TAggregationType_COUNT: return "COUNT" |
| case TAggregationType_AVG: return "AVG" |
| case TAggregationType_SUM: return "SUM" |
| case TAggregationType_FIRST_VALUE: return "FIRST_VALUE" |
| case TAggregationType_LAST_VALUE: return "LAST_VALUE" |
| case TAggregationType_MAX_TIME: return "MAX_TIME" |
| case TAggregationType_MIN_TIME: return "MIN_TIME" |
| case TAggregationType_MAX_VALUE: return "MAX_VALUE" |
| case TAggregationType_MIN_VALUE: return "MIN_VALUE" |
| case TAggregationType_EXTREME: return "EXTREME" |
| case TAggregationType_COUNT_IF: return "COUNT_IF" |
| case TAggregationType_TIME_DURATION: return "TIME_DURATION" |
| case TAggregationType_MODE: return "MODE" |
| } |
| return "<UNSET>" |
| } |
| |
| func TAggregationTypeFromString(s string) (TAggregationType, error) { |
| switch s { |
| case "COUNT": return TAggregationType_COUNT, nil |
| case "AVG": return TAggregationType_AVG, nil |
| case "SUM": return TAggregationType_SUM, nil |
| case "FIRST_VALUE": return TAggregationType_FIRST_VALUE, nil |
| case "LAST_VALUE": return TAggregationType_LAST_VALUE, nil |
| case "MAX_TIME": return TAggregationType_MAX_TIME, nil |
| case "MIN_TIME": return TAggregationType_MIN_TIME, nil |
| case "MAX_VALUE": return TAggregationType_MAX_VALUE, nil |
| case "MIN_VALUE": return TAggregationType_MIN_VALUE, nil |
| case "EXTREME": return TAggregationType_EXTREME, nil |
| case "COUNT_IF": return TAggregationType_COUNT_IF, nil |
| case "TIME_DURATION": return TAggregationType_TIME_DURATION, nil |
| case "MODE": return TAggregationType_MODE, nil |
| } |
| return TAggregationType(0), fmt.Errorf("not a valid TAggregationType string") |
| } |
| |
| |
| func TAggregationTypePtr(v TAggregationType) *TAggregationType { return &v } |
| |
| func (p TAggregationType) MarshalText() ([]byte, error) { |
| return []byte(p.String()), nil |
| } |
| |
| func (p *TAggregationType) UnmarshalText(text []byte) error { |
| q, err := TAggregationTypeFromString(string(text)) |
| if (err != nil) { |
| return err |
| } |
| *p = q |
| return nil |
| } |
| |
| func (p *TAggregationType) Scan(value interface{}) error { |
| v, ok := value.(int64) |
| if !ok { |
| return errors.New("Scan value is not int64") |
| } |
| *p = TAggregationType(v) |
| return nil |
| } |
| |
| func (p * TAggregationType) Value() (driver.Value, error) { |
| if p == nil { |
| return nil, nil |
| } |
| return int64(*p), nil |
| } |
| type TrainingState int64 |
| const ( |
| TrainingState_PENDING TrainingState = 0 |
| TrainingState_RUNNING TrainingState = 1 |
| TrainingState_FINISHED TrainingState = 2 |
| TrainingState_FAILED TrainingState = 3 |
| TrainingState_DROPPING TrainingState = 4 |
| ) |
| |
| func (p TrainingState) String() string { |
| switch p { |
| case TrainingState_PENDING: return "PENDING" |
| case TrainingState_RUNNING: return "RUNNING" |
| case TrainingState_FINISHED: return "FINISHED" |
| case TrainingState_FAILED: return "FAILED" |
| case TrainingState_DROPPING: return "DROPPING" |
| } |
| return "<UNSET>" |
| } |
| |
| func TrainingStateFromString(s string) (TrainingState, error) { |
| switch s { |
| case "PENDING": return TrainingState_PENDING, nil |
| case "RUNNING": return TrainingState_RUNNING, nil |
| case "FINISHED": return TrainingState_FINISHED, nil |
| case "FAILED": return TrainingState_FAILED, nil |
| case "DROPPING": return TrainingState_DROPPING, nil |
| } |
| return TrainingState(0), fmt.Errorf("not a valid TrainingState string") |
| } |
| |
| |
| func TrainingStatePtr(v TrainingState) *TrainingState { return &v } |
| |
| func (p TrainingState) MarshalText() ([]byte, error) { |
| return []byte(p.String()), nil |
| } |
| |
| func (p *TrainingState) UnmarshalText(text []byte) error { |
| q, err := TrainingStateFromString(string(text)) |
| if (err != nil) { |
| return err |
| } |
| *p = q |
| return nil |
| } |
| |
| func (p *TrainingState) Scan(value interface{}) error { |
| v, ok := value.(int64) |
| if !ok { |
| return errors.New("Scan value is not int64") |
| } |
| *p = TrainingState(v) |
| return nil |
| } |
| |
| func (p * TrainingState) Value() (driver.Value, error) { |
| if p == nil { |
| return nil, nil |
| } |
| return int64(*p), nil |
| } |
| type ModelTask int64 |
| const ( |
| ModelTask_FORECAST ModelTask = 0 |
| ) |
| |
| func (p ModelTask) String() string { |
| switch p { |
| case ModelTask_FORECAST: return "FORECAST" |
| } |
| return "<UNSET>" |
| } |
| |
| func ModelTaskFromString(s string) (ModelTask, error) { |
| switch s { |
| case "FORECAST": return ModelTask_FORECAST, nil |
| } |
| return ModelTask(0), fmt.Errorf("not a valid ModelTask string") |
| } |
| |
| |
| func ModelTaskPtr(v ModelTask) *ModelTask { return &v } |
| |
| func (p ModelTask) MarshalText() ([]byte, error) { |
| return []byte(p.String()), nil |
| } |
| |
| func (p *ModelTask) UnmarshalText(text []byte) error { |
| q, err := ModelTaskFromString(string(text)) |
| if (err != nil) { |
| return err |
| } |
| *p = q |
| return nil |
| } |
| |
| func (p *ModelTask) Scan(value interface{}) error { |
| v, ok := value.(int64) |
| if !ok { |
| return errors.New("Scan value is not int64") |
| } |
| *p = ModelTask(v) |
| return nil |
| } |
| |
| func (p * ModelTask) Value() (driver.Value, error) { |
| if p == nil { |
| return nil, nil |
| } |
| return int64(*p), nil |
| } |
| // Attributes: |
| // - IP |
| // - Port |
| type TEndPoint struct { |
| IP string `thrift:"ip,1,required" db:"ip" json:"ip"` |
| Port int32 `thrift:"port,2,required" db:"port" json:"port"` |
| } |
| |
| func NewTEndPoint() *TEndPoint { |
| return &TEndPoint{} |
| } |
| |
| |
| func (p *TEndPoint) GetIP() string { |
| return p.IP |
| } |
| |
| func (p *TEndPoint) GetPort() int32 { |
| return p.Port |
| } |
| func (p *TEndPoint) Read(ctx context.Context, iprot thrift.TProtocol) error { |
| if _, err := iprot.ReadStructBegin(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) |
| } |
| |
| var issetIP bool = false; |
| var issetPort bool = false; |
| |
| for { |
| _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx) |
| 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 fieldTypeId == thrift.STRING { |
| if err := p.ReadField1(ctx, iprot); err != nil { |
| return err |
| } |
| issetIP = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 2: |
| if fieldTypeId == thrift.I32 { |
| if err := p.ReadField2(ctx, iprot); err != nil { |
| return err |
| } |
| issetPort = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| default: |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadFieldEnd(ctx); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadStructEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) |
| } |
| if !issetIP{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field IP is not set")); |
| } |
| if !issetPort{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field Port is not set")); |
| } |
| return nil |
| } |
| |
| func (p *TEndPoint) ReadField1(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadString(ctx); err != nil { |
| return thrift.PrependError("error reading field 1: ", err) |
| } else { |
| p.IP = v |
| } |
| return nil |
| } |
| |
| func (p *TEndPoint) ReadField2(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadI32(ctx); err != nil { |
| return thrift.PrependError("error reading field 2: ", err) |
| } else { |
| p.Port = v |
| } |
| return nil |
| } |
| |
| func (p *TEndPoint) Write(ctx context.Context, oprot thrift.TProtocol) error { |
| if err := oprot.WriteStructBegin(ctx, "TEndPoint"); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } |
| if p != nil { |
| if err := p.writeField1(ctx, oprot); err != nil { return err } |
| if err := p.writeField2(ctx, oprot); err != nil { return err } |
| } |
| if err := oprot.WriteFieldStop(ctx); err != nil { |
| return thrift.PrependError("write field stop error: ", err) } |
| if err := oprot.WriteStructEnd(ctx); err != nil { |
| return thrift.PrependError("write struct stop error: ", err) } |
| return nil |
| } |
| |
| func (p *TEndPoint) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "ip", thrift.STRING, 1); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:ip: ", p), err) } |
| if err := oprot.WriteString(ctx, string(p.IP)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.ip (1) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 1:ip: ", p), err) } |
| return err |
| } |
| |
| func (p *TEndPoint) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "port", thrift.I32, 2); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:port: ", p), err) } |
| if err := oprot.WriteI32(ctx, int32(p.Port)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.port (2) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 2:port: ", p), err) } |
| return err |
| } |
| |
| func (p *TEndPoint) Equals(other *TEndPoint) bool { |
| if p == other { |
| return true |
| } else if p == nil || other == nil { |
| return false |
| } |
| if p.IP != other.IP { return false } |
| if p.Port != other.Port { return false } |
| return true |
| } |
| |
| func (p *TEndPoint) String() string { |
| if p == nil { |
| return "<nil>" |
| } |
| return fmt.Sprintf("TEndPoint(%+v)", *p) |
| } |
| |
| // Attributes: |
| // - Code |
| // - Message |
| // - SubStatus |
| // - RedirectNode |
| type TSStatus struct { |
| Code int32 `thrift:"code,1,required" db:"code" json:"code"` |
| Message *string `thrift:"message,2" db:"message" json:"message,omitempty"` |
| SubStatus []*TSStatus `thrift:"subStatus,3" db:"subStatus" json:"subStatus,omitempty"` |
| RedirectNode *TEndPoint `thrift:"redirectNode,4" db:"redirectNode" json:"redirectNode,omitempty"` |
| } |
| |
| func NewTSStatus() *TSStatus { |
| return &TSStatus{} |
| } |
| |
| |
| func (p *TSStatus) GetCode() int32 { |
| return p.Code |
| } |
| var TSStatus_Message_DEFAULT string |
| func (p *TSStatus) GetMessage() string { |
| if !p.IsSetMessage() { |
| return TSStatus_Message_DEFAULT |
| } |
| return *p.Message |
| } |
| var TSStatus_SubStatus_DEFAULT []*TSStatus |
| |
| func (p *TSStatus) GetSubStatus() []*TSStatus { |
| return p.SubStatus |
| } |
| var TSStatus_RedirectNode_DEFAULT *TEndPoint |
| func (p *TSStatus) GetRedirectNode() *TEndPoint { |
| if !p.IsSetRedirectNode() { |
| return TSStatus_RedirectNode_DEFAULT |
| } |
| return p.RedirectNode |
| } |
| func (p *TSStatus) IsSetMessage() bool { |
| return p.Message != nil |
| } |
| |
| func (p *TSStatus) IsSetSubStatus() bool { |
| return p.SubStatus != nil |
| } |
| |
| func (p *TSStatus) IsSetRedirectNode() bool { |
| return p.RedirectNode != nil |
| } |
| |
| func (p *TSStatus) Read(ctx context.Context, iprot thrift.TProtocol) error { |
| if _, err := iprot.ReadStructBegin(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) |
| } |
| |
| var issetCode bool = false; |
| |
| for { |
| _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx) |
| 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 fieldTypeId == thrift.I32 { |
| if err := p.ReadField1(ctx, iprot); err != nil { |
| return err |
| } |
| issetCode = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 2: |
| if fieldTypeId == thrift.STRING { |
| if err := p.ReadField2(ctx, iprot); err != nil { |
| return err |
| } |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 3: |
| if fieldTypeId == thrift.LIST { |
| if err := p.ReadField3(ctx, iprot); err != nil { |
| return err |
| } |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 4: |
| if fieldTypeId == thrift.STRUCT { |
| if err := p.ReadField4(ctx, iprot); err != nil { |
| return err |
| } |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| default: |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadFieldEnd(ctx); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadStructEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) |
| } |
| if !issetCode{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field Code is not set")); |
| } |
| return nil |
| } |
| |
| func (p *TSStatus) ReadField1(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadI32(ctx); err != nil { |
| return thrift.PrependError("error reading field 1: ", err) |
| } else { |
| p.Code = v |
| } |
| return nil |
| } |
| |
| func (p *TSStatus) ReadField2(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadString(ctx); err != nil { |
| return thrift.PrependError("error reading field 2: ", err) |
| } else { |
| p.Message = &v |
| } |
| return nil |
| } |
| |
| func (p *TSStatus) ReadField3(ctx context.Context, iprot thrift.TProtocol) error { |
| _, size, err := iprot.ReadListBegin(ctx) |
| if err != nil { |
| return thrift.PrependError("error reading list begin: ", err) |
| } |
| tSlice := make([]*TSStatus, 0, size) |
| p.SubStatus = tSlice |
| for i := 0; i < size; i ++ { |
| _elem0 := &TSStatus{} |
| if err := _elem0.Read(ctx, iprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem0), err) |
| } |
| p.SubStatus = append(p.SubStatus, _elem0) |
| } |
| if err := iprot.ReadListEnd(ctx); err != nil { |
| return thrift.PrependError("error reading list end: ", err) |
| } |
| return nil |
| } |
| |
| func (p *TSStatus) ReadField4(ctx context.Context, iprot thrift.TProtocol) error { |
| p.RedirectNode = &TEndPoint{} |
| if err := p.RedirectNode.Read(ctx, iprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.RedirectNode), err) |
| } |
| return nil |
| } |
| |
| func (p *TSStatus) Write(ctx context.Context, oprot thrift.TProtocol) error { |
| if err := oprot.WriteStructBegin(ctx, "TSStatus"); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } |
| if p != nil { |
| if err := p.writeField1(ctx, oprot); err != nil { return err } |
| if err := p.writeField2(ctx, oprot); err != nil { return err } |
| if err := p.writeField3(ctx, oprot); err != nil { return err } |
| if err := p.writeField4(ctx, oprot); err != nil { return err } |
| } |
| if err := oprot.WriteFieldStop(ctx); err != nil { |
| return thrift.PrependError("write field stop error: ", err) } |
| if err := oprot.WriteStructEnd(ctx); err != nil { |
| return thrift.PrependError("write struct stop error: ", err) } |
| return nil |
| } |
| |
| func (p *TSStatus) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "code", thrift.I32, 1); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:code: ", p), err) } |
| if err := oprot.WriteI32(ctx, int32(p.Code)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.code (1) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 1:code: ", p), err) } |
| return err |
| } |
| |
| func (p *TSStatus) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if p.IsSetMessage() { |
| if err := oprot.WriteFieldBegin(ctx, "message", thrift.STRING, 2); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:message: ", p), err) } |
| if err := oprot.WriteString(ctx, string(*p.Message)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.message (2) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 2:message: ", p), err) } |
| } |
| return err |
| } |
| |
| func (p *TSStatus) writeField3(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if p.IsSetSubStatus() { |
| if err := oprot.WriteFieldBegin(ctx, "subStatus", thrift.LIST, 3); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:subStatus: ", p), err) } |
| if err := oprot.WriteListBegin(ctx, thrift.STRUCT, len(p.SubStatus)); err != nil { |
| return thrift.PrependError("error writing list begin: ", err) |
| } |
| for _, v := range p.SubStatus { |
| if err := v.Write(ctx, oprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err) |
| } |
| } |
| if err := oprot.WriteListEnd(ctx); err != nil { |
| return thrift.PrependError("error writing list end: ", err) |
| } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 3:subStatus: ", p), err) } |
| } |
| return err |
| } |
| |
| func (p *TSStatus) writeField4(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if p.IsSetRedirectNode() { |
| if err := oprot.WriteFieldBegin(ctx, "redirectNode", thrift.STRUCT, 4); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:redirectNode: ", p), err) } |
| if err := p.RedirectNode.Write(ctx, oprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.RedirectNode), err) |
| } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 4:redirectNode: ", p), err) } |
| } |
| return err |
| } |
| |
| func (p *TSStatus) Equals(other *TSStatus) bool { |
| if p == other { |
| return true |
| } else if p == nil || other == nil { |
| return false |
| } |
| if p.Code != other.Code { return false } |
| if p.Message != other.Message { |
| if p.Message == nil || other.Message == nil { |
| return false |
| } |
| if (*p.Message) != (*other.Message) { return false } |
| } |
| if len(p.SubStatus) != len(other.SubStatus) { return false } |
| for i, _tgt := range p.SubStatus { |
| _src1 := other.SubStatus[i] |
| if !_tgt.Equals(_src1) { return false } |
| } |
| if !p.RedirectNode.Equals(other.RedirectNode) { return false } |
| return true |
| } |
| |
| func (p *TSStatus) String() string { |
| if p == nil { |
| return "<nil>" |
| } |
| return fmt.Sprintf("TSStatus(%+v)", *p) |
| } |
| |
| // Attributes: |
| // - Type |
| // - ID |
| type TConsensusGroupId struct { |
| Type TConsensusGroupType `thrift:"type,1,required" db:"type" json:"type"` |
| ID int32 `thrift:"id,2,required" db:"id" json:"id"` |
| } |
| |
| func NewTConsensusGroupId() *TConsensusGroupId { |
| return &TConsensusGroupId{} |
| } |
| |
| |
| func (p *TConsensusGroupId) GetType() TConsensusGroupType { |
| return p.Type |
| } |
| |
| func (p *TConsensusGroupId) GetID() int32 { |
| return p.ID |
| } |
| func (p *TConsensusGroupId) Read(ctx context.Context, iprot thrift.TProtocol) error { |
| if _, err := iprot.ReadStructBegin(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) |
| } |
| |
| var issetType bool = false; |
| var issetID bool = false; |
| |
| for { |
| _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx) |
| 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 fieldTypeId == thrift.I32 { |
| if err := p.ReadField1(ctx, iprot); err != nil { |
| return err |
| } |
| issetType = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 2: |
| if fieldTypeId == thrift.I32 { |
| if err := p.ReadField2(ctx, iprot); err != nil { |
| return err |
| } |
| issetID = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| default: |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadFieldEnd(ctx); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadStructEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) |
| } |
| if !issetType{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field Type is not set")); |
| } |
| if !issetID{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field ID is not set")); |
| } |
| return nil |
| } |
| |
| func (p *TConsensusGroupId) ReadField1(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadI32(ctx); err != nil { |
| return thrift.PrependError("error reading field 1: ", err) |
| } else { |
| temp := TConsensusGroupType(v) |
| p.Type = temp |
| } |
| return nil |
| } |
| |
| func (p *TConsensusGroupId) ReadField2(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadI32(ctx); err != nil { |
| return thrift.PrependError("error reading field 2: ", err) |
| } else { |
| p.ID = v |
| } |
| return nil |
| } |
| |
| func (p *TConsensusGroupId) Write(ctx context.Context, oprot thrift.TProtocol) error { |
| if err := oprot.WriteStructBegin(ctx, "TConsensusGroupId"); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } |
| if p != nil { |
| if err := p.writeField1(ctx, oprot); err != nil { return err } |
| if err := p.writeField2(ctx, oprot); err != nil { return err } |
| } |
| if err := oprot.WriteFieldStop(ctx); err != nil { |
| return thrift.PrependError("write field stop error: ", err) } |
| if err := oprot.WriteStructEnd(ctx); err != nil { |
| return thrift.PrependError("write struct stop error: ", err) } |
| return nil |
| } |
| |
| func (p *TConsensusGroupId) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "type", thrift.I32, 1); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:type: ", p), err) } |
| if err := oprot.WriteI32(ctx, int32(p.Type)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.type (1) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 1:type: ", p), err) } |
| return err |
| } |
| |
| func (p *TConsensusGroupId) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "id", thrift.I32, 2); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:id: ", p), err) } |
| if err := oprot.WriteI32(ctx, int32(p.ID)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.id (2) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 2:id: ", p), err) } |
| return err |
| } |
| |
| func (p *TConsensusGroupId) Equals(other *TConsensusGroupId) bool { |
| if p == other { |
| return true |
| } else if p == nil || other == nil { |
| return false |
| } |
| if p.Type != other.Type { return false } |
| if p.ID != other.ID { return false } |
| return true |
| } |
| |
| func (p *TConsensusGroupId) String() string { |
| if p == nil { |
| return "<nil>" |
| } |
| return fmt.Sprintf("TConsensusGroupId(%+v)", *p) |
| } |
| |
| // Attributes: |
| // - SlotId |
| type TSeriesPartitionSlot struct { |
| SlotId int32 `thrift:"slotId,1,required" db:"slotId" json:"slotId"` |
| } |
| |
| func NewTSeriesPartitionSlot() *TSeriesPartitionSlot { |
| return &TSeriesPartitionSlot{} |
| } |
| |
| |
| func (p *TSeriesPartitionSlot) GetSlotId() int32 { |
| return p.SlotId |
| } |
| func (p *TSeriesPartitionSlot) Read(ctx context.Context, iprot thrift.TProtocol) error { |
| if _, err := iprot.ReadStructBegin(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) |
| } |
| |
| var issetSlotId bool = false; |
| |
| for { |
| _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx) |
| 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 fieldTypeId == thrift.I32 { |
| if err := p.ReadField1(ctx, iprot); err != nil { |
| return err |
| } |
| issetSlotId = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| default: |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadFieldEnd(ctx); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadStructEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) |
| } |
| if !issetSlotId{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field SlotId is not set")); |
| } |
| return nil |
| } |
| |
| func (p *TSeriesPartitionSlot) ReadField1(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadI32(ctx); err != nil { |
| return thrift.PrependError("error reading field 1: ", err) |
| } else { |
| p.SlotId = v |
| } |
| return nil |
| } |
| |
| func (p *TSeriesPartitionSlot) Write(ctx context.Context, oprot thrift.TProtocol) error { |
| if err := oprot.WriteStructBegin(ctx, "TSeriesPartitionSlot"); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } |
| if p != nil { |
| if err := p.writeField1(ctx, oprot); err != nil { return err } |
| } |
| if err := oprot.WriteFieldStop(ctx); err != nil { |
| return thrift.PrependError("write field stop error: ", err) } |
| if err := oprot.WriteStructEnd(ctx); err != nil { |
| return thrift.PrependError("write struct stop error: ", err) } |
| return nil |
| } |
| |
| func (p *TSeriesPartitionSlot) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "slotId", thrift.I32, 1); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:slotId: ", p), err) } |
| if err := oprot.WriteI32(ctx, int32(p.SlotId)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.slotId (1) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 1:slotId: ", p), err) } |
| return err |
| } |
| |
| func (p *TSeriesPartitionSlot) Equals(other *TSeriesPartitionSlot) bool { |
| if p == other { |
| return true |
| } else if p == nil || other == nil { |
| return false |
| } |
| if p.SlotId != other.SlotId { return false } |
| return true |
| } |
| |
| func (p *TSeriesPartitionSlot) String() string { |
| if p == nil { |
| return "<nil>" |
| } |
| return fmt.Sprintf("TSeriesPartitionSlot(%+v)", *p) |
| } |
| |
| // Attributes: |
| // - StartTime |
| type TTimePartitionSlot struct { |
| StartTime int64 `thrift:"startTime,1,required" db:"startTime" json:"startTime"` |
| } |
| |
| func NewTTimePartitionSlot() *TTimePartitionSlot { |
| return &TTimePartitionSlot{} |
| } |
| |
| |
| func (p *TTimePartitionSlot) GetStartTime() int64 { |
| return p.StartTime |
| } |
| func (p *TTimePartitionSlot) Read(ctx context.Context, iprot thrift.TProtocol) error { |
| if _, err := iprot.ReadStructBegin(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) |
| } |
| |
| var issetStartTime bool = false; |
| |
| for { |
| _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx) |
| 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 fieldTypeId == thrift.I64 { |
| if err := p.ReadField1(ctx, iprot); err != nil { |
| return err |
| } |
| issetStartTime = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| default: |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadFieldEnd(ctx); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadStructEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) |
| } |
| if !issetStartTime{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field StartTime is not set")); |
| } |
| return nil |
| } |
| |
| func (p *TTimePartitionSlot) ReadField1(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadI64(ctx); err != nil { |
| return thrift.PrependError("error reading field 1: ", err) |
| } else { |
| p.StartTime = v |
| } |
| return nil |
| } |
| |
| func (p *TTimePartitionSlot) Write(ctx context.Context, oprot thrift.TProtocol) error { |
| if err := oprot.WriteStructBegin(ctx, "TTimePartitionSlot"); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } |
| if p != nil { |
| if err := p.writeField1(ctx, oprot); err != nil { return err } |
| } |
| if err := oprot.WriteFieldStop(ctx); err != nil { |
| return thrift.PrependError("write field stop error: ", err) } |
| if err := oprot.WriteStructEnd(ctx); err != nil { |
| return thrift.PrependError("write struct stop error: ", err) } |
| return nil |
| } |
| |
| func (p *TTimePartitionSlot) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "startTime", thrift.I64, 1); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:startTime: ", p), err) } |
| if err := oprot.WriteI64(ctx, int64(p.StartTime)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.startTime (1) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 1:startTime: ", p), err) } |
| return err |
| } |
| |
| func (p *TTimePartitionSlot) Equals(other *TTimePartitionSlot) bool { |
| if p == other { |
| return true |
| } else if p == nil || other == nil { |
| return false |
| } |
| if p.StartTime != other.StartTime { return false } |
| return true |
| } |
| |
| func (p *TTimePartitionSlot) String() string { |
| if p == nil { |
| return "<nil>" |
| } |
| return fmt.Sprintf("TTimePartitionSlot(%+v)", *p) |
| } |
| |
| // Attributes: |
| // - RegionId |
| // - DataNodeLocations |
| type TRegionReplicaSet struct { |
| RegionId *TConsensusGroupId `thrift:"regionId,1,required" db:"regionId" json:"regionId"` |
| DataNodeLocations []*TDataNodeLocation `thrift:"dataNodeLocations,2,required" db:"dataNodeLocations" json:"dataNodeLocations"` |
| } |
| |
| func NewTRegionReplicaSet() *TRegionReplicaSet { |
| return &TRegionReplicaSet{} |
| } |
| |
| var TRegionReplicaSet_RegionId_DEFAULT *TConsensusGroupId |
| func (p *TRegionReplicaSet) GetRegionId() *TConsensusGroupId { |
| if !p.IsSetRegionId() { |
| return TRegionReplicaSet_RegionId_DEFAULT |
| } |
| return p.RegionId |
| } |
| |
| func (p *TRegionReplicaSet) GetDataNodeLocations() []*TDataNodeLocation { |
| return p.DataNodeLocations |
| } |
| func (p *TRegionReplicaSet) IsSetRegionId() bool { |
| return p.RegionId != nil |
| } |
| |
| func (p *TRegionReplicaSet) Read(ctx context.Context, iprot thrift.TProtocol) error { |
| if _, err := iprot.ReadStructBegin(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) |
| } |
| |
| var issetRegionId bool = false; |
| var issetDataNodeLocations bool = false; |
| |
| for { |
| _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx) |
| 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 fieldTypeId == thrift.STRUCT { |
| if err := p.ReadField1(ctx, iprot); err != nil { |
| return err |
| } |
| issetRegionId = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 2: |
| if fieldTypeId == thrift.LIST { |
| if err := p.ReadField2(ctx, iprot); err != nil { |
| return err |
| } |
| issetDataNodeLocations = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| default: |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadFieldEnd(ctx); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadStructEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) |
| } |
| if !issetRegionId{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field RegionId is not set")); |
| } |
| if !issetDataNodeLocations{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field DataNodeLocations is not set")); |
| } |
| return nil |
| } |
| |
| func (p *TRegionReplicaSet) ReadField1(ctx context.Context, iprot thrift.TProtocol) error { |
| p.RegionId = &TConsensusGroupId{} |
| if err := p.RegionId.Read(ctx, iprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.RegionId), err) |
| } |
| return nil |
| } |
| |
| func (p *TRegionReplicaSet) ReadField2(ctx context.Context, iprot thrift.TProtocol) error { |
| _, size, err := iprot.ReadListBegin(ctx) |
| if err != nil { |
| return thrift.PrependError("error reading list begin: ", err) |
| } |
| tSlice := make([]*TDataNodeLocation, 0, size) |
| p.DataNodeLocations = tSlice |
| for i := 0; i < size; i ++ { |
| _elem2 := &TDataNodeLocation{} |
| if err := _elem2.Read(ctx, iprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem2), err) |
| } |
| p.DataNodeLocations = append(p.DataNodeLocations, _elem2) |
| } |
| if err := iprot.ReadListEnd(ctx); err != nil { |
| return thrift.PrependError("error reading list end: ", err) |
| } |
| return nil |
| } |
| |
| func (p *TRegionReplicaSet) Write(ctx context.Context, oprot thrift.TProtocol) error { |
| if err := oprot.WriteStructBegin(ctx, "TRegionReplicaSet"); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } |
| if p != nil { |
| if err := p.writeField1(ctx, oprot); err != nil { return err } |
| if err := p.writeField2(ctx, oprot); err != nil { return err } |
| } |
| if err := oprot.WriteFieldStop(ctx); err != nil { |
| return thrift.PrependError("write field stop error: ", err) } |
| if err := oprot.WriteStructEnd(ctx); err != nil { |
| return thrift.PrependError("write struct stop error: ", err) } |
| return nil |
| } |
| |
| func (p *TRegionReplicaSet) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "regionId", thrift.STRUCT, 1); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:regionId: ", p), err) } |
| if err := p.RegionId.Write(ctx, oprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.RegionId), err) |
| } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 1:regionId: ", p), err) } |
| return err |
| } |
| |
| func (p *TRegionReplicaSet) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "dataNodeLocations", thrift.LIST, 2); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:dataNodeLocations: ", p), err) } |
| if err := oprot.WriteListBegin(ctx, thrift.STRUCT, len(p.DataNodeLocations)); err != nil { |
| return thrift.PrependError("error writing list begin: ", err) |
| } |
| for _, v := range p.DataNodeLocations { |
| if err := v.Write(ctx, oprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err) |
| } |
| } |
| if err := oprot.WriteListEnd(ctx); err != nil { |
| return thrift.PrependError("error writing list end: ", err) |
| } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 2:dataNodeLocations: ", p), err) } |
| return err |
| } |
| |
| func (p *TRegionReplicaSet) Equals(other *TRegionReplicaSet) bool { |
| if p == other { |
| return true |
| } else if p == nil || other == nil { |
| return false |
| } |
| if !p.RegionId.Equals(other.RegionId) { return false } |
| if len(p.DataNodeLocations) != len(other.DataNodeLocations) { return false } |
| for i, _tgt := range p.DataNodeLocations { |
| _src3 := other.DataNodeLocations[i] |
| if !_tgt.Equals(_src3) { return false } |
| } |
| return true |
| } |
| |
| func (p *TRegionReplicaSet) String() string { |
| if p == nil { |
| return "<nil>" |
| } |
| return fmt.Sprintf("TRegionReplicaSet(%+v)", *p) |
| } |
| |
| // Attributes: |
| // - CpuCoreNum |
| // - MaxMemory |
| type TNodeResource struct { |
| CpuCoreNum int32 `thrift:"cpuCoreNum,1,required" db:"cpuCoreNum" json:"cpuCoreNum"` |
| MaxMemory int64 `thrift:"maxMemory,2,required" db:"maxMemory" json:"maxMemory"` |
| } |
| |
| func NewTNodeResource() *TNodeResource { |
| return &TNodeResource{} |
| } |
| |
| |
| func (p *TNodeResource) GetCpuCoreNum() int32 { |
| return p.CpuCoreNum |
| } |
| |
| func (p *TNodeResource) GetMaxMemory() int64 { |
| return p.MaxMemory |
| } |
| func (p *TNodeResource) Read(ctx context.Context, iprot thrift.TProtocol) error { |
| if _, err := iprot.ReadStructBegin(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) |
| } |
| |
| var issetCpuCoreNum bool = false; |
| var issetMaxMemory bool = false; |
| |
| for { |
| _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx) |
| 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 fieldTypeId == thrift.I32 { |
| if err := p.ReadField1(ctx, iprot); err != nil { |
| return err |
| } |
| issetCpuCoreNum = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 2: |
| if fieldTypeId == thrift.I64 { |
| if err := p.ReadField2(ctx, iprot); err != nil { |
| return err |
| } |
| issetMaxMemory = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| default: |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadFieldEnd(ctx); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadStructEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) |
| } |
| if !issetCpuCoreNum{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field CpuCoreNum is not set")); |
| } |
| if !issetMaxMemory{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field MaxMemory is not set")); |
| } |
| return nil |
| } |
| |
| func (p *TNodeResource) ReadField1(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadI32(ctx); err != nil { |
| return thrift.PrependError("error reading field 1: ", err) |
| } else { |
| p.CpuCoreNum = v |
| } |
| return nil |
| } |
| |
| func (p *TNodeResource) ReadField2(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadI64(ctx); err != nil { |
| return thrift.PrependError("error reading field 2: ", err) |
| } else { |
| p.MaxMemory = v |
| } |
| return nil |
| } |
| |
| func (p *TNodeResource) Write(ctx context.Context, oprot thrift.TProtocol) error { |
| if err := oprot.WriteStructBegin(ctx, "TNodeResource"); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } |
| if p != nil { |
| if err := p.writeField1(ctx, oprot); err != nil { return err } |
| if err := p.writeField2(ctx, oprot); err != nil { return err } |
| } |
| if err := oprot.WriteFieldStop(ctx); err != nil { |
| return thrift.PrependError("write field stop error: ", err) } |
| if err := oprot.WriteStructEnd(ctx); err != nil { |
| return thrift.PrependError("write struct stop error: ", err) } |
| return nil |
| } |
| |
| func (p *TNodeResource) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "cpuCoreNum", thrift.I32, 1); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:cpuCoreNum: ", p), err) } |
| if err := oprot.WriteI32(ctx, int32(p.CpuCoreNum)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.cpuCoreNum (1) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 1:cpuCoreNum: ", p), err) } |
| return err |
| } |
| |
| func (p *TNodeResource) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "maxMemory", thrift.I64, 2); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:maxMemory: ", p), err) } |
| if err := oprot.WriteI64(ctx, int64(p.MaxMemory)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.maxMemory (2) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 2:maxMemory: ", p), err) } |
| return err |
| } |
| |
| func (p *TNodeResource) Equals(other *TNodeResource) bool { |
| if p == other { |
| return true |
| } else if p == nil || other == nil { |
| return false |
| } |
| if p.CpuCoreNum != other.CpuCoreNum { return false } |
| if p.MaxMemory != other.MaxMemory { return false } |
| return true |
| } |
| |
| func (p *TNodeResource) String() string { |
| if p == nil { |
| return "<nil>" |
| } |
| return fmt.Sprintf("TNodeResource(%+v)", *p) |
| } |
| |
| // Attributes: |
| // - ConfigNodeId |
| // - InternalEndPoint |
| // - ConsensusEndPoint |
| type TConfigNodeLocation struct { |
| ConfigNodeId int32 `thrift:"configNodeId,1,required" db:"configNodeId" json:"configNodeId"` |
| InternalEndPoint *TEndPoint `thrift:"internalEndPoint,2,required" db:"internalEndPoint" json:"internalEndPoint"` |
| ConsensusEndPoint *TEndPoint `thrift:"consensusEndPoint,3,required" db:"consensusEndPoint" json:"consensusEndPoint"` |
| } |
| |
| func NewTConfigNodeLocation() *TConfigNodeLocation { |
| return &TConfigNodeLocation{} |
| } |
| |
| |
| func (p *TConfigNodeLocation) GetConfigNodeId() int32 { |
| return p.ConfigNodeId |
| } |
| var TConfigNodeLocation_InternalEndPoint_DEFAULT *TEndPoint |
| func (p *TConfigNodeLocation) GetInternalEndPoint() *TEndPoint { |
| if !p.IsSetInternalEndPoint() { |
| return TConfigNodeLocation_InternalEndPoint_DEFAULT |
| } |
| return p.InternalEndPoint |
| } |
| var TConfigNodeLocation_ConsensusEndPoint_DEFAULT *TEndPoint |
| func (p *TConfigNodeLocation) GetConsensusEndPoint() *TEndPoint { |
| if !p.IsSetConsensusEndPoint() { |
| return TConfigNodeLocation_ConsensusEndPoint_DEFAULT |
| } |
| return p.ConsensusEndPoint |
| } |
| func (p *TConfigNodeLocation) IsSetInternalEndPoint() bool { |
| return p.InternalEndPoint != nil |
| } |
| |
| func (p *TConfigNodeLocation) IsSetConsensusEndPoint() bool { |
| return p.ConsensusEndPoint != nil |
| } |
| |
| func (p *TConfigNodeLocation) Read(ctx context.Context, iprot thrift.TProtocol) error { |
| if _, err := iprot.ReadStructBegin(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) |
| } |
| |
| var issetConfigNodeId bool = false; |
| var issetInternalEndPoint bool = false; |
| var issetConsensusEndPoint bool = false; |
| |
| for { |
| _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx) |
| 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 fieldTypeId == thrift.I32 { |
| if err := p.ReadField1(ctx, iprot); err != nil { |
| return err |
| } |
| issetConfigNodeId = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 2: |
| if fieldTypeId == thrift.STRUCT { |
| if err := p.ReadField2(ctx, iprot); err != nil { |
| return err |
| } |
| issetInternalEndPoint = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 3: |
| if fieldTypeId == thrift.STRUCT { |
| if err := p.ReadField3(ctx, iprot); err != nil { |
| return err |
| } |
| issetConsensusEndPoint = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| default: |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadFieldEnd(ctx); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadStructEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) |
| } |
| if !issetConfigNodeId{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field ConfigNodeId is not set")); |
| } |
| if !issetInternalEndPoint{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field InternalEndPoint is not set")); |
| } |
| if !issetConsensusEndPoint{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field ConsensusEndPoint is not set")); |
| } |
| return nil |
| } |
| |
| func (p *TConfigNodeLocation) ReadField1(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadI32(ctx); err != nil { |
| return thrift.PrependError("error reading field 1: ", err) |
| } else { |
| p.ConfigNodeId = v |
| } |
| return nil |
| } |
| |
| func (p *TConfigNodeLocation) ReadField2(ctx context.Context, iprot thrift.TProtocol) error { |
| p.InternalEndPoint = &TEndPoint{} |
| if err := p.InternalEndPoint.Read(ctx, iprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.InternalEndPoint), err) |
| } |
| return nil |
| } |
| |
| func (p *TConfigNodeLocation) ReadField3(ctx context.Context, iprot thrift.TProtocol) error { |
| p.ConsensusEndPoint = &TEndPoint{} |
| if err := p.ConsensusEndPoint.Read(ctx, iprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.ConsensusEndPoint), err) |
| } |
| return nil |
| } |
| |
| func (p *TConfigNodeLocation) Write(ctx context.Context, oprot thrift.TProtocol) error { |
| if err := oprot.WriteStructBegin(ctx, "TConfigNodeLocation"); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } |
| if p != nil { |
| if err := p.writeField1(ctx, oprot); err != nil { return err } |
| if err := p.writeField2(ctx, oprot); err != nil { return err } |
| if err := p.writeField3(ctx, oprot); err != nil { return err } |
| } |
| if err := oprot.WriteFieldStop(ctx); err != nil { |
| return thrift.PrependError("write field stop error: ", err) } |
| if err := oprot.WriteStructEnd(ctx); err != nil { |
| return thrift.PrependError("write struct stop error: ", err) } |
| return nil |
| } |
| |
| func (p *TConfigNodeLocation) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "configNodeId", thrift.I32, 1); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:configNodeId: ", p), err) } |
| if err := oprot.WriteI32(ctx, int32(p.ConfigNodeId)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.configNodeId (1) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 1:configNodeId: ", p), err) } |
| return err |
| } |
| |
| func (p *TConfigNodeLocation) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "internalEndPoint", thrift.STRUCT, 2); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:internalEndPoint: ", p), err) } |
| if err := p.InternalEndPoint.Write(ctx, oprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.InternalEndPoint), err) |
| } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 2:internalEndPoint: ", p), err) } |
| return err |
| } |
| |
| func (p *TConfigNodeLocation) writeField3(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "consensusEndPoint", thrift.STRUCT, 3); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:consensusEndPoint: ", p), err) } |
| if err := p.ConsensusEndPoint.Write(ctx, oprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.ConsensusEndPoint), err) |
| } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 3:consensusEndPoint: ", p), err) } |
| return err |
| } |
| |
| func (p *TConfigNodeLocation) Equals(other *TConfigNodeLocation) bool { |
| if p == other { |
| return true |
| } else if p == nil || other == nil { |
| return false |
| } |
| if p.ConfigNodeId != other.ConfigNodeId { return false } |
| if !p.InternalEndPoint.Equals(other.InternalEndPoint) { return false } |
| if !p.ConsensusEndPoint.Equals(other.ConsensusEndPoint) { return false } |
| return true |
| } |
| |
| func (p *TConfigNodeLocation) String() string { |
| if p == nil { |
| return "<nil>" |
| } |
| return fmt.Sprintf("TConfigNodeLocation(%+v)", *p) |
| } |
| |
| // Attributes: |
| // - DataNodeId |
| // - ClientRpcEndPoint |
| // - InternalEndPoint |
| // - MPPDataExchangeEndPoint |
| // - DataRegionConsensusEndPoint |
| // - SchemaRegionConsensusEndPoint |
| type TDataNodeLocation struct { |
| DataNodeId int32 `thrift:"dataNodeId,1,required" db:"dataNodeId" json:"dataNodeId"` |
| ClientRpcEndPoint *TEndPoint `thrift:"clientRpcEndPoint,2,required" db:"clientRpcEndPoint" json:"clientRpcEndPoint"` |
| InternalEndPoint *TEndPoint `thrift:"internalEndPoint,3,required" db:"internalEndPoint" json:"internalEndPoint"` |
| MPPDataExchangeEndPoint *TEndPoint `thrift:"mPPDataExchangeEndPoint,4,required" db:"mPPDataExchangeEndPoint" json:"mPPDataExchangeEndPoint"` |
| DataRegionConsensusEndPoint *TEndPoint `thrift:"dataRegionConsensusEndPoint,5,required" db:"dataRegionConsensusEndPoint" json:"dataRegionConsensusEndPoint"` |
| SchemaRegionConsensusEndPoint *TEndPoint `thrift:"schemaRegionConsensusEndPoint,6,required" db:"schemaRegionConsensusEndPoint" json:"schemaRegionConsensusEndPoint"` |
| } |
| |
| func NewTDataNodeLocation() *TDataNodeLocation { |
| return &TDataNodeLocation{} |
| } |
| |
| |
| func (p *TDataNodeLocation) GetDataNodeId() int32 { |
| return p.DataNodeId |
| } |
| var TDataNodeLocation_ClientRpcEndPoint_DEFAULT *TEndPoint |
| func (p *TDataNodeLocation) GetClientRpcEndPoint() *TEndPoint { |
| if !p.IsSetClientRpcEndPoint() { |
| return TDataNodeLocation_ClientRpcEndPoint_DEFAULT |
| } |
| return p.ClientRpcEndPoint |
| } |
| var TDataNodeLocation_InternalEndPoint_DEFAULT *TEndPoint |
| func (p *TDataNodeLocation) GetInternalEndPoint() *TEndPoint { |
| if !p.IsSetInternalEndPoint() { |
| return TDataNodeLocation_InternalEndPoint_DEFAULT |
| } |
| return p.InternalEndPoint |
| } |
| var TDataNodeLocation_MPPDataExchangeEndPoint_DEFAULT *TEndPoint |
| func (p *TDataNodeLocation) GetMPPDataExchangeEndPoint() *TEndPoint { |
| if !p.IsSetMPPDataExchangeEndPoint() { |
| return TDataNodeLocation_MPPDataExchangeEndPoint_DEFAULT |
| } |
| return p.MPPDataExchangeEndPoint |
| } |
| var TDataNodeLocation_DataRegionConsensusEndPoint_DEFAULT *TEndPoint |
| func (p *TDataNodeLocation) GetDataRegionConsensusEndPoint() *TEndPoint { |
| if !p.IsSetDataRegionConsensusEndPoint() { |
| return TDataNodeLocation_DataRegionConsensusEndPoint_DEFAULT |
| } |
| return p.DataRegionConsensusEndPoint |
| } |
| var TDataNodeLocation_SchemaRegionConsensusEndPoint_DEFAULT *TEndPoint |
| func (p *TDataNodeLocation) GetSchemaRegionConsensusEndPoint() *TEndPoint { |
| if !p.IsSetSchemaRegionConsensusEndPoint() { |
| return TDataNodeLocation_SchemaRegionConsensusEndPoint_DEFAULT |
| } |
| return p.SchemaRegionConsensusEndPoint |
| } |
| func (p *TDataNodeLocation) IsSetClientRpcEndPoint() bool { |
| return p.ClientRpcEndPoint != nil |
| } |
| |
| func (p *TDataNodeLocation) IsSetInternalEndPoint() bool { |
| return p.InternalEndPoint != nil |
| } |
| |
| func (p *TDataNodeLocation) IsSetMPPDataExchangeEndPoint() bool { |
| return p.MPPDataExchangeEndPoint != nil |
| } |
| |
| func (p *TDataNodeLocation) IsSetDataRegionConsensusEndPoint() bool { |
| return p.DataRegionConsensusEndPoint != nil |
| } |
| |
| func (p *TDataNodeLocation) IsSetSchemaRegionConsensusEndPoint() bool { |
| return p.SchemaRegionConsensusEndPoint != nil |
| } |
| |
| func (p *TDataNodeLocation) Read(ctx context.Context, iprot thrift.TProtocol) error { |
| if _, err := iprot.ReadStructBegin(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) |
| } |
| |
| var issetDataNodeId bool = false; |
| var issetClientRpcEndPoint bool = false; |
| var issetInternalEndPoint bool = false; |
| var issetMPPDataExchangeEndPoint bool = false; |
| var issetDataRegionConsensusEndPoint bool = false; |
| var issetSchemaRegionConsensusEndPoint bool = false; |
| |
| for { |
| _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx) |
| 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 fieldTypeId == thrift.I32 { |
| if err := p.ReadField1(ctx, iprot); err != nil { |
| return err |
| } |
| issetDataNodeId = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 2: |
| if fieldTypeId == thrift.STRUCT { |
| if err := p.ReadField2(ctx, iprot); err != nil { |
| return err |
| } |
| issetClientRpcEndPoint = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 3: |
| if fieldTypeId == thrift.STRUCT { |
| if err := p.ReadField3(ctx, iprot); err != nil { |
| return err |
| } |
| issetInternalEndPoint = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 4: |
| if fieldTypeId == thrift.STRUCT { |
| if err := p.ReadField4(ctx, iprot); err != nil { |
| return err |
| } |
| issetMPPDataExchangeEndPoint = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 5: |
| if fieldTypeId == thrift.STRUCT { |
| if err := p.ReadField5(ctx, iprot); err != nil { |
| return err |
| } |
| issetDataRegionConsensusEndPoint = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 6: |
| if fieldTypeId == thrift.STRUCT { |
| if err := p.ReadField6(ctx, iprot); err != nil { |
| return err |
| } |
| issetSchemaRegionConsensusEndPoint = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| default: |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadFieldEnd(ctx); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadStructEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) |
| } |
| if !issetDataNodeId{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field DataNodeId is not set")); |
| } |
| if !issetClientRpcEndPoint{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field ClientRpcEndPoint is not set")); |
| } |
| if !issetInternalEndPoint{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field InternalEndPoint is not set")); |
| } |
| if !issetMPPDataExchangeEndPoint{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field MPPDataExchangeEndPoint is not set")); |
| } |
| if !issetDataRegionConsensusEndPoint{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field DataRegionConsensusEndPoint is not set")); |
| } |
| if !issetSchemaRegionConsensusEndPoint{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field SchemaRegionConsensusEndPoint is not set")); |
| } |
| return nil |
| } |
| |
| func (p *TDataNodeLocation) ReadField1(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadI32(ctx); err != nil { |
| return thrift.PrependError("error reading field 1: ", err) |
| } else { |
| p.DataNodeId = v |
| } |
| return nil |
| } |
| |
| func (p *TDataNodeLocation) ReadField2(ctx context.Context, iprot thrift.TProtocol) error { |
| p.ClientRpcEndPoint = &TEndPoint{} |
| if err := p.ClientRpcEndPoint.Read(ctx, iprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.ClientRpcEndPoint), err) |
| } |
| return nil |
| } |
| |
| func (p *TDataNodeLocation) ReadField3(ctx context.Context, iprot thrift.TProtocol) error { |
| p.InternalEndPoint = &TEndPoint{} |
| if err := p.InternalEndPoint.Read(ctx, iprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.InternalEndPoint), err) |
| } |
| return nil |
| } |
| |
| func (p *TDataNodeLocation) ReadField4(ctx context.Context, iprot thrift.TProtocol) error { |
| p.MPPDataExchangeEndPoint = &TEndPoint{} |
| if err := p.MPPDataExchangeEndPoint.Read(ctx, iprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.MPPDataExchangeEndPoint), err) |
| } |
| return nil |
| } |
| |
| func (p *TDataNodeLocation) ReadField5(ctx context.Context, iprot thrift.TProtocol) error { |
| p.DataRegionConsensusEndPoint = &TEndPoint{} |
| if err := p.DataRegionConsensusEndPoint.Read(ctx, iprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.DataRegionConsensusEndPoint), err) |
| } |
| return nil |
| } |
| |
| func (p *TDataNodeLocation) ReadField6(ctx context.Context, iprot thrift.TProtocol) error { |
| p.SchemaRegionConsensusEndPoint = &TEndPoint{} |
| if err := p.SchemaRegionConsensusEndPoint.Read(ctx, iprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.SchemaRegionConsensusEndPoint), err) |
| } |
| return nil |
| } |
| |
| func (p *TDataNodeLocation) Write(ctx context.Context, oprot thrift.TProtocol) error { |
| if err := oprot.WriteStructBegin(ctx, "TDataNodeLocation"); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } |
| if p != nil { |
| if err := p.writeField1(ctx, oprot); err != nil { return err } |
| if err := p.writeField2(ctx, oprot); err != nil { return err } |
| if err := p.writeField3(ctx, oprot); err != nil { return err } |
| if err := p.writeField4(ctx, oprot); err != nil { return err } |
| if err := p.writeField5(ctx, oprot); err != nil { return err } |
| if err := p.writeField6(ctx, oprot); err != nil { return err } |
| } |
| if err := oprot.WriteFieldStop(ctx); err != nil { |
| return thrift.PrependError("write field stop error: ", err) } |
| if err := oprot.WriteStructEnd(ctx); err != nil { |
| return thrift.PrependError("write struct stop error: ", err) } |
| return nil |
| } |
| |
| func (p *TDataNodeLocation) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "dataNodeId", thrift.I32, 1); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:dataNodeId: ", p), err) } |
| if err := oprot.WriteI32(ctx, int32(p.DataNodeId)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.dataNodeId (1) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 1:dataNodeId: ", p), err) } |
| return err |
| } |
| |
| func (p *TDataNodeLocation) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "clientRpcEndPoint", thrift.STRUCT, 2); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:clientRpcEndPoint: ", p), err) } |
| if err := p.ClientRpcEndPoint.Write(ctx, oprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.ClientRpcEndPoint), err) |
| } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 2:clientRpcEndPoint: ", p), err) } |
| return err |
| } |
| |
| func (p *TDataNodeLocation) writeField3(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "internalEndPoint", thrift.STRUCT, 3); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:internalEndPoint: ", p), err) } |
| if err := p.InternalEndPoint.Write(ctx, oprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.InternalEndPoint), err) |
| } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 3:internalEndPoint: ", p), err) } |
| return err |
| } |
| |
| func (p *TDataNodeLocation) writeField4(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "mPPDataExchangeEndPoint", thrift.STRUCT, 4); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 4:mPPDataExchangeEndPoint: ", p), err) } |
| if err := p.MPPDataExchangeEndPoint.Write(ctx, oprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.MPPDataExchangeEndPoint), err) |
| } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 4:mPPDataExchangeEndPoint: ", p), err) } |
| return err |
| } |
| |
| func (p *TDataNodeLocation) writeField5(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "dataRegionConsensusEndPoint", thrift.STRUCT, 5); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:dataRegionConsensusEndPoint: ", p), err) } |
| if err := p.DataRegionConsensusEndPoint.Write(ctx, oprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.DataRegionConsensusEndPoint), err) |
| } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 5:dataRegionConsensusEndPoint: ", p), err) } |
| return err |
| } |
| |
| func (p *TDataNodeLocation) writeField6(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "schemaRegionConsensusEndPoint", thrift.STRUCT, 6); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 6:schemaRegionConsensusEndPoint: ", p), err) } |
| if err := p.SchemaRegionConsensusEndPoint.Write(ctx, oprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.SchemaRegionConsensusEndPoint), err) |
| } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 6:schemaRegionConsensusEndPoint: ", p), err) } |
| return err |
| } |
| |
| func (p *TDataNodeLocation) Equals(other *TDataNodeLocation) bool { |
| if p == other { |
| return true |
| } else if p == nil || other == nil { |
| return false |
| } |
| if p.DataNodeId != other.DataNodeId { return false } |
| if !p.ClientRpcEndPoint.Equals(other.ClientRpcEndPoint) { return false } |
| if !p.InternalEndPoint.Equals(other.InternalEndPoint) { return false } |
| if !p.MPPDataExchangeEndPoint.Equals(other.MPPDataExchangeEndPoint) { return false } |
| if !p.DataRegionConsensusEndPoint.Equals(other.DataRegionConsensusEndPoint) { return false } |
| if !p.SchemaRegionConsensusEndPoint.Equals(other.SchemaRegionConsensusEndPoint) { return false } |
| return true |
| } |
| |
| func (p *TDataNodeLocation) String() string { |
| if p == nil { |
| return "<nil>" |
| } |
| return fmt.Sprintf("TDataNodeLocation(%+v)", *p) |
| } |
| |
| // Attributes: |
| // - Location |
| // - Resource |
| type TDataNodeConfiguration struct { |
| Location *TDataNodeLocation `thrift:"location,1,required" db:"location" json:"location"` |
| Resource *TNodeResource `thrift:"resource,2,required" db:"resource" json:"resource"` |
| } |
| |
| func NewTDataNodeConfiguration() *TDataNodeConfiguration { |
| return &TDataNodeConfiguration{} |
| } |
| |
| var TDataNodeConfiguration_Location_DEFAULT *TDataNodeLocation |
| func (p *TDataNodeConfiguration) GetLocation() *TDataNodeLocation { |
| if !p.IsSetLocation() { |
| return TDataNodeConfiguration_Location_DEFAULT |
| } |
| return p.Location |
| } |
| var TDataNodeConfiguration_Resource_DEFAULT *TNodeResource |
| func (p *TDataNodeConfiguration) GetResource() *TNodeResource { |
| if !p.IsSetResource() { |
| return TDataNodeConfiguration_Resource_DEFAULT |
| } |
| return p.Resource |
| } |
| func (p *TDataNodeConfiguration) IsSetLocation() bool { |
| return p.Location != nil |
| } |
| |
| func (p *TDataNodeConfiguration) IsSetResource() bool { |
| return p.Resource != nil |
| } |
| |
| func (p *TDataNodeConfiguration) Read(ctx context.Context, iprot thrift.TProtocol) error { |
| if _, err := iprot.ReadStructBegin(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) |
| } |
| |
| var issetLocation bool = false; |
| var issetResource bool = false; |
| |
| for { |
| _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx) |
| 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 fieldTypeId == thrift.STRUCT { |
| if err := p.ReadField1(ctx, iprot); err != nil { |
| return err |
| } |
| issetLocation = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 2: |
| if fieldTypeId == thrift.STRUCT { |
| if err := p.ReadField2(ctx, iprot); err != nil { |
| return err |
| } |
| issetResource = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| default: |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadFieldEnd(ctx); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadStructEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) |
| } |
| if !issetLocation{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field Location is not set")); |
| } |
| if !issetResource{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field Resource is not set")); |
| } |
| return nil |
| } |
| |
| func (p *TDataNodeConfiguration) ReadField1(ctx context.Context, iprot thrift.TProtocol) error { |
| p.Location = &TDataNodeLocation{} |
| if err := p.Location.Read(ctx, iprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Location), err) |
| } |
| return nil |
| } |
| |
| func (p *TDataNodeConfiguration) ReadField2(ctx context.Context, iprot thrift.TProtocol) error { |
| p.Resource = &TNodeResource{} |
| if err := p.Resource.Read(ctx, iprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Resource), err) |
| } |
| return nil |
| } |
| |
| func (p *TDataNodeConfiguration) Write(ctx context.Context, oprot thrift.TProtocol) error { |
| if err := oprot.WriteStructBegin(ctx, "TDataNodeConfiguration"); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } |
| if p != nil { |
| if err := p.writeField1(ctx, oprot); err != nil { return err } |
| if err := p.writeField2(ctx, oprot); err != nil { return err } |
| } |
| if err := oprot.WriteFieldStop(ctx); err != nil { |
| return thrift.PrependError("write field stop error: ", err) } |
| if err := oprot.WriteStructEnd(ctx); err != nil { |
| return thrift.PrependError("write struct stop error: ", err) } |
| return nil |
| } |
| |
| func (p *TDataNodeConfiguration) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "location", thrift.STRUCT, 1); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:location: ", p), err) } |
| if err := p.Location.Write(ctx, oprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Location), err) |
| } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 1:location: ", p), err) } |
| return err |
| } |
| |
| func (p *TDataNodeConfiguration) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "resource", thrift.STRUCT, 2); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:resource: ", p), err) } |
| if err := p.Resource.Write(ctx, oprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Resource), err) |
| } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 2:resource: ", p), err) } |
| return err |
| } |
| |
| func (p *TDataNodeConfiguration) Equals(other *TDataNodeConfiguration) bool { |
| if p == other { |
| return true |
| } else if p == nil || other == nil { |
| return false |
| } |
| if !p.Location.Equals(other.Location) { return false } |
| if !p.Resource.Equals(other.Resource) { return false } |
| return true |
| } |
| |
| func (p *TDataNodeConfiguration) String() string { |
| if p == nil { |
| return "<nil>" |
| } |
| return fmt.Sprintf("TDataNodeConfiguration(%+v)", *p) |
| } |
| |
| // Attributes: |
| // - IsSeq |
| // - StorageGroups |
| type TFlushReq struct { |
| IsSeq *string `thrift:"isSeq,1" db:"isSeq" json:"isSeq,omitempty"` |
| StorageGroups []string `thrift:"storageGroups,2" db:"storageGroups" json:"storageGroups,omitempty"` |
| } |
| |
| func NewTFlushReq() *TFlushReq { |
| return &TFlushReq{} |
| } |
| |
| var TFlushReq_IsSeq_DEFAULT string |
| func (p *TFlushReq) GetIsSeq() string { |
| if !p.IsSetIsSeq() { |
| return TFlushReq_IsSeq_DEFAULT |
| } |
| return *p.IsSeq |
| } |
| var TFlushReq_StorageGroups_DEFAULT []string |
| |
| func (p *TFlushReq) GetStorageGroups() []string { |
| return p.StorageGroups |
| } |
| func (p *TFlushReq) IsSetIsSeq() bool { |
| return p.IsSeq != nil |
| } |
| |
| func (p *TFlushReq) IsSetStorageGroups() bool { |
| return p.StorageGroups != nil |
| } |
| |
| func (p *TFlushReq) Read(ctx context.Context, iprot thrift.TProtocol) error { |
| if _, err := iprot.ReadStructBegin(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) |
| } |
| |
| |
| for { |
| _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx) |
| 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 fieldTypeId == thrift.STRING { |
| if err := p.ReadField1(ctx, iprot); err != nil { |
| return err |
| } |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 2: |
| if fieldTypeId == thrift.LIST { |
| if err := p.ReadField2(ctx, iprot); err != nil { |
| return err |
| } |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| default: |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadFieldEnd(ctx); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadStructEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) |
| } |
| return nil |
| } |
| |
| func (p *TFlushReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadString(ctx); err != nil { |
| return thrift.PrependError("error reading field 1: ", err) |
| } else { |
| p.IsSeq = &v |
| } |
| return nil |
| } |
| |
| func (p *TFlushReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error { |
| _, size, err := iprot.ReadListBegin(ctx) |
| if err != nil { |
| return thrift.PrependError("error reading list begin: ", err) |
| } |
| tSlice := make([]string, 0, size) |
| p.StorageGroups = tSlice |
| for i := 0; i < size; i ++ { |
| var _elem4 string |
| if v, err := iprot.ReadString(ctx); err != nil { |
| return thrift.PrependError("error reading field 0: ", err) |
| } else { |
| _elem4 = v |
| } |
| p.StorageGroups = append(p.StorageGroups, _elem4) |
| } |
| if err := iprot.ReadListEnd(ctx); err != nil { |
| return thrift.PrependError("error reading list end: ", err) |
| } |
| return nil |
| } |
| |
| func (p *TFlushReq) Write(ctx context.Context, oprot thrift.TProtocol) error { |
| if err := oprot.WriteStructBegin(ctx, "TFlushReq"); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } |
| if p != nil { |
| if err := p.writeField1(ctx, oprot); err != nil { return err } |
| if err := p.writeField2(ctx, oprot); err != nil { return err } |
| } |
| if err := oprot.WriteFieldStop(ctx); err != nil { |
| return thrift.PrependError("write field stop error: ", err) } |
| if err := oprot.WriteStructEnd(ctx); err != nil { |
| return thrift.PrependError("write struct stop error: ", err) } |
| return nil |
| } |
| |
| func (p *TFlushReq) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if p.IsSetIsSeq() { |
| if err := oprot.WriteFieldBegin(ctx, "isSeq", thrift.STRING, 1); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:isSeq: ", p), err) } |
| if err := oprot.WriteString(ctx, string(*p.IsSeq)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.isSeq (1) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 1:isSeq: ", p), err) } |
| } |
| return err |
| } |
| |
| func (p *TFlushReq) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if p.IsSetStorageGroups() { |
| if err := oprot.WriteFieldBegin(ctx, "storageGroups", thrift.LIST, 2); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:storageGroups: ", p), err) } |
| if err := oprot.WriteListBegin(ctx, thrift.STRING, len(p.StorageGroups)); err != nil { |
| return thrift.PrependError("error writing list begin: ", err) |
| } |
| for _, v := range p.StorageGroups { |
| if err := oprot.WriteString(ctx, string(v)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) } |
| } |
| if err := oprot.WriteListEnd(ctx); err != nil { |
| return thrift.PrependError("error writing list end: ", err) |
| } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 2:storageGroups: ", p), err) } |
| } |
| return err |
| } |
| |
| func (p *TFlushReq) Equals(other *TFlushReq) bool { |
| if p == other { |
| return true |
| } else if p == nil || other == nil { |
| return false |
| } |
| if p.IsSeq != other.IsSeq { |
| if p.IsSeq == nil || other.IsSeq == nil { |
| return false |
| } |
| if (*p.IsSeq) != (*other.IsSeq) { return false } |
| } |
| if len(p.StorageGroups) != len(other.StorageGroups) { return false } |
| for i, _tgt := range p.StorageGroups { |
| _src5 := other.StorageGroups[i] |
| if _tgt != _src5 { return false } |
| } |
| return true |
| } |
| |
| func (p *TFlushReq) String() string { |
| if p == nil { |
| return "<nil>" |
| } |
| return fmt.Sprintf("TFlushReq(%+v)", *p) |
| } |
| |
| // Attributes: |
| // - Paths |
| type TSettleReq struct { |
| Paths []string `thrift:"paths,1,required" db:"paths" json:"paths"` |
| } |
| |
| func NewTSettleReq() *TSettleReq { |
| return &TSettleReq{} |
| } |
| |
| |
| func (p *TSettleReq) GetPaths() []string { |
| return p.Paths |
| } |
| func (p *TSettleReq) Read(ctx context.Context, iprot thrift.TProtocol) error { |
| if _, err := iprot.ReadStructBegin(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) |
| } |
| |
| var issetPaths bool = false; |
| |
| for { |
| _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx) |
| 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 fieldTypeId == thrift.LIST { |
| if err := p.ReadField1(ctx, iprot); err != nil { |
| return err |
| } |
| issetPaths = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| default: |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadFieldEnd(ctx); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadStructEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) |
| } |
| if !issetPaths{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field Paths is not set")); |
| } |
| return nil |
| } |
| |
| func (p *TSettleReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error { |
| _, size, err := iprot.ReadListBegin(ctx) |
| if err != nil { |
| return thrift.PrependError("error reading list begin: ", err) |
| } |
| tSlice := make([]string, 0, size) |
| p.Paths = tSlice |
| for i := 0; i < size; i ++ { |
| var _elem6 string |
| if v, err := iprot.ReadString(ctx); err != nil { |
| return thrift.PrependError("error reading field 0: ", err) |
| } else { |
| _elem6 = v |
| } |
| p.Paths = append(p.Paths, _elem6) |
| } |
| if err := iprot.ReadListEnd(ctx); err != nil { |
| return thrift.PrependError("error reading list end: ", err) |
| } |
| return nil |
| } |
| |
| func (p *TSettleReq) Write(ctx context.Context, oprot thrift.TProtocol) error { |
| if err := oprot.WriteStructBegin(ctx, "TSettleReq"); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } |
| if p != nil { |
| if err := p.writeField1(ctx, oprot); err != nil { return err } |
| } |
| if err := oprot.WriteFieldStop(ctx); err != nil { |
| return thrift.PrependError("write field stop error: ", err) } |
| if err := oprot.WriteStructEnd(ctx); err != nil { |
| return thrift.PrependError("write struct stop error: ", err) } |
| return nil |
| } |
| |
| func (p *TSettleReq) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "paths", thrift.LIST, 1); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:paths: ", p), err) } |
| if err := oprot.WriteListBegin(ctx, thrift.STRING, len(p.Paths)); err != nil { |
| return thrift.PrependError("error writing list begin: ", err) |
| } |
| for _, v := range p.Paths { |
| if err := oprot.WriteString(ctx, string(v)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) } |
| } |
| if err := oprot.WriteListEnd(ctx); err != nil { |
| return thrift.PrependError("error writing list end: ", err) |
| } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 1:paths: ", p), err) } |
| return err |
| } |
| |
| func (p *TSettleReq) Equals(other *TSettleReq) bool { |
| if p == other { |
| return true |
| } else if p == nil || other == nil { |
| return false |
| } |
| if len(p.Paths) != len(other.Paths) { return false } |
| for i, _tgt := range p.Paths { |
| _src7 := other.Paths[i] |
| if _tgt != _src7 { return false } |
| } |
| return true |
| } |
| |
| func (p *TSettleReq) String() string { |
| if p == nil { |
| return "<nil>" |
| } |
| return fmt.Sprintf("TSettleReq(%+v)", *p) |
| } |
| |
| // Attributes: |
| // - NodeName |
| // - NodeType |
| type TSchemaNode struct { |
| NodeName string `thrift:"nodeName,1,required" db:"nodeName" json:"nodeName"` |
| NodeType int8 `thrift:"nodeType,2,required" db:"nodeType" json:"nodeType"` |
| } |
| |
| func NewTSchemaNode() *TSchemaNode { |
| return &TSchemaNode{} |
| } |
| |
| |
| func (p *TSchemaNode) GetNodeName() string { |
| return p.NodeName |
| } |
| |
| func (p *TSchemaNode) GetNodeType() int8 { |
| return p.NodeType |
| } |
| func (p *TSchemaNode) Read(ctx context.Context, iprot thrift.TProtocol) error { |
| if _, err := iprot.ReadStructBegin(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) |
| } |
| |
| var issetNodeName bool = false; |
| var issetNodeType bool = false; |
| |
| for { |
| _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx) |
| 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 fieldTypeId == thrift.STRING { |
| if err := p.ReadField1(ctx, iprot); err != nil { |
| return err |
| } |
| issetNodeName = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 2: |
| if fieldTypeId == thrift.BYTE { |
| if err := p.ReadField2(ctx, iprot); err != nil { |
| return err |
| } |
| issetNodeType = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| default: |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadFieldEnd(ctx); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadStructEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) |
| } |
| if !issetNodeName{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field NodeName is not set")); |
| } |
| if !issetNodeType{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field NodeType is not set")); |
| } |
| return nil |
| } |
| |
| func (p *TSchemaNode) ReadField1(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadString(ctx); err != nil { |
| return thrift.PrependError("error reading field 1: ", err) |
| } else { |
| p.NodeName = v |
| } |
| return nil |
| } |
| |
| func (p *TSchemaNode) ReadField2(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadByte(ctx); err != nil { |
| return thrift.PrependError("error reading field 2: ", err) |
| } else { |
| temp := int8(v) |
| p.NodeType = temp |
| } |
| return nil |
| } |
| |
| func (p *TSchemaNode) Write(ctx context.Context, oprot thrift.TProtocol) error { |
| if err := oprot.WriteStructBegin(ctx, "TSchemaNode"); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } |
| if p != nil { |
| if err := p.writeField1(ctx, oprot); err != nil { return err } |
| if err := p.writeField2(ctx, oprot); err != nil { return err } |
| } |
| if err := oprot.WriteFieldStop(ctx); err != nil { |
| return thrift.PrependError("write field stop error: ", err) } |
| if err := oprot.WriteStructEnd(ctx); err != nil { |
| return thrift.PrependError("write struct stop error: ", err) } |
| return nil |
| } |
| |
| func (p *TSchemaNode) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "nodeName", thrift.STRING, 1); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:nodeName: ", p), err) } |
| if err := oprot.WriteString(ctx, string(p.NodeName)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.nodeName (1) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 1:nodeName: ", p), err) } |
| return err |
| } |
| |
| func (p *TSchemaNode) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "nodeType", thrift.BYTE, 2); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:nodeType: ", p), err) } |
| if err := oprot.WriteByte(ctx, int8(p.NodeType)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.nodeType (2) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 2:nodeType: ", p), err) } |
| return err |
| } |
| |
| func (p *TSchemaNode) Equals(other *TSchemaNode) bool { |
| if p == other { |
| return true |
| } else if p == nil || other == nil { |
| return false |
| } |
| if p.NodeName != other.NodeName { return false } |
| if p.NodeType != other.NodeType { return false } |
| return true |
| } |
| |
| func (p *TSchemaNode) String() string { |
| if p == nil { |
| return "<nil>" |
| } |
| return fmt.Sprintf("TSchemaNode(%+v)", *p) |
| } |
| |
| // Attributes: |
| // - StorageGroupPathPattern |
| // - TTL |
| type TSetTTLReq struct { |
| StorageGroupPathPattern []string `thrift:"storageGroupPathPattern,1,required" db:"storageGroupPathPattern" json:"storageGroupPathPattern"` |
| TTL int64 `thrift:"TTL,2,required" db:"TTL" json:"TTL"` |
| } |
| |
| func NewTSetTTLReq() *TSetTTLReq { |
| return &TSetTTLReq{} |
| } |
| |
| |
| func (p *TSetTTLReq) GetStorageGroupPathPattern() []string { |
| return p.StorageGroupPathPattern |
| } |
| |
| func (p *TSetTTLReq) GetTTL() int64 { |
| return p.TTL |
| } |
| func (p *TSetTTLReq) Read(ctx context.Context, iprot thrift.TProtocol) error { |
| if _, err := iprot.ReadStructBegin(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) |
| } |
| |
| var issetStorageGroupPathPattern bool = false; |
| var issetTTL bool = false; |
| |
| for { |
| _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx) |
| 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 fieldTypeId == thrift.LIST { |
| if err := p.ReadField1(ctx, iprot); err != nil { |
| return err |
| } |
| issetStorageGroupPathPattern = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 2: |
| if fieldTypeId == thrift.I64 { |
| if err := p.ReadField2(ctx, iprot); err != nil { |
| return err |
| } |
| issetTTL = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| default: |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadFieldEnd(ctx); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadStructEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) |
| } |
| if !issetStorageGroupPathPattern{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field StorageGroupPathPattern is not set")); |
| } |
| if !issetTTL{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field TTL is not set")); |
| } |
| return nil |
| } |
| |
| func (p *TSetTTLReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error { |
| _, size, err := iprot.ReadListBegin(ctx) |
| if err != nil { |
| return thrift.PrependError("error reading list begin: ", err) |
| } |
| tSlice := make([]string, 0, size) |
| p.StorageGroupPathPattern = tSlice |
| for i := 0; i < size; i ++ { |
| var _elem8 string |
| if v, err := iprot.ReadString(ctx); err != nil { |
| return thrift.PrependError("error reading field 0: ", err) |
| } else { |
| _elem8 = v |
| } |
| p.StorageGroupPathPattern = append(p.StorageGroupPathPattern, _elem8) |
| } |
| if err := iprot.ReadListEnd(ctx); err != nil { |
| return thrift.PrependError("error reading list end: ", err) |
| } |
| return nil |
| } |
| |
| func (p *TSetTTLReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadI64(ctx); err != nil { |
| return thrift.PrependError("error reading field 2: ", err) |
| } else { |
| p.TTL = v |
| } |
| return nil |
| } |
| |
| func (p *TSetTTLReq) Write(ctx context.Context, oprot thrift.TProtocol) error { |
| if err := oprot.WriteStructBegin(ctx, "TSetTTLReq"); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } |
| if p != nil { |
| if err := p.writeField1(ctx, oprot); err != nil { return err } |
| if err := p.writeField2(ctx, oprot); err != nil { return err } |
| } |
| if err := oprot.WriteFieldStop(ctx); err != nil { |
| return thrift.PrependError("write field stop error: ", err) } |
| if err := oprot.WriteStructEnd(ctx); err != nil { |
| return thrift.PrependError("write struct stop error: ", err) } |
| return nil |
| } |
| |
| func (p *TSetTTLReq) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "storageGroupPathPattern", thrift.LIST, 1); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:storageGroupPathPattern: ", p), err) } |
| if err := oprot.WriteListBegin(ctx, thrift.STRING, len(p.StorageGroupPathPattern)); err != nil { |
| return thrift.PrependError("error writing list begin: ", err) |
| } |
| for _, v := range p.StorageGroupPathPattern { |
| if err := oprot.WriteString(ctx, string(v)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) } |
| } |
| if err := oprot.WriteListEnd(ctx); err != nil { |
| return thrift.PrependError("error writing list end: ", err) |
| } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 1:storageGroupPathPattern: ", p), err) } |
| return err |
| } |
| |
| func (p *TSetTTLReq) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "TTL", thrift.I64, 2); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:TTL: ", p), err) } |
| if err := oprot.WriteI64(ctx, int64(p.TTL)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.TTL (2) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 2:TTL: ", p), err) } |
| return err |
| } |
| |
| func (p *TSetTTLReq) Equals(other *TSetTTLReq) bool { |
| if p == other { |
| return true |
| } else if p == nil || other == nil { |
| return false |
| } |
| if len(p.StorageGroupPathPattern) != len(other.StorageGroupPathPattern) { return false } |
| for i, _tgt := range p.StorageGroupPathPattern { |
| _src9 := other.StorageGroupPathPattern[i] |
| if _tgt != _src9 { return false } |
| } |
| if p.TTL != other.TTL { return false } |
| return true |
| } |
| |
| func (p *TSetTTLReq) String() string { |
| if p == nil { |
| return "<nil>" |
| } |
| return fmt.Sprintf("TSetTTLReq(%+v)", *p) |
| } |
| |
| // Attributes: |
| // - FileName |
| // - File |
| type TFile struct { |
| FileName string `thrift:"fileName,1,required" db:"fileName" json:"fileName"` |
| File []byte `thrift:"file,2,required" db:"file" json:"file"` |
| } |
| |
| func NewTFile() *TFile { |
| return &TFile{} |
| } |
| |
| |
| func (p *TFile) GetFileName() string { |
| return p.FileName |
| } |
| |
| func (p *TFile) GetFile() []byte { |
| return p.File |
| } |
| func (p *TFile) Read(ctx context.Context, iprot thrift.TProtocol) error { |
| if _, err := iprot.ReadStructBegin(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) |
| } |
| |
| var issetFileName bool = false; |
| var issetFile bool = false; |
| |
| for { |
| _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx) |
| 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 fieldTypeId == thrift.STRING { |
| if err := p.ReadField1(ctx, iprot); err != nil { |
| return err |
| } |
| issetFileName = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 2: |
| if fieldTypeId == thrift.STRING { |
| if err := p.ReadField2(ctx, iprot); err != nil { |
| return err |
| } |
| issetFile = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| default: |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadFieldEnd(ctx); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadStructEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) |
| } |
| if !issetFileName{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field FileName is not set")); |
| } |
| if !issetFile{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field File is not set")); |
| } |
| return nil |
| } |
| |
| func (p *TFile) ReadField1(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadString(ctx); err != nil { |
| return thrift.PrependError("error reading field 1: ", err) |
| } else { |
| p.FileName = v |
| } |
| return nil |
| } |
| |
| func (p *TFile) ReadField2(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadBinary(ctx); err != nil { |
| return thrift.PrependError("error reading field 2: ", err) |
| } else { |
| p.File = v |
| } |
| return nil |
| } |
| |
| func (p *TFile) Write(ctx context.Context, oprot thrift.TProtocol) error { |
| if err := oprot.WriteStructBegin(ctx, "TFile"); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } |
| if p != nil { |
| if err := p.writeField1(ctx, oprot); err != nil { return err } |
| if err := p.writeField2(ctx, oprot); err != nil { return err } |
| } |
| if err := oprot.WriteFieldStop(ctx); err != nil { |
| return thrift.PrependError("write field stop error: ", err) } |
| if err := oprot.WriteStructEnd(ctx); err != nil { |
| return thrift.PrependError("write struct stop error: ", err) } |
| return nil |
| } |
| |
| func (p *TFile) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "fileName", thrift.STRING, 1); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:fileName: ", p), err) } |
| if err := oprot.WriteString(ctx, string(p.FileName)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.fileName (1) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 1:fileName: ", p), err) } |
| return err |
| } |
| |
| func (p *TFile) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "file", thrift.STRING, 2); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:file: ", p), err) } |
| if err := oprot.WriteBinary(ctx, p.File); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.file (2) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 2:file: ", p), err) } |
| return err |
| } |
| |
| func (p *TFile) Equals(other *TFile) bool { |
| if p == other { |
| return true |
| } else if p == nil || other == nil { |
| return false |
| } |
| if p.FileName != other.FileName { return false } |
| if bytes.Compare(p.File, other.File) != 0 { return false } |
| return true |
| } |
| |
| func (p *TFile) String() string { |
| if p == nil { |
| return "<nil>" |
| } |
| return fmt.Sprintf("TFile(%+v)", *p) |
| } |
| |
| // Attributes: |
| // - Status |
| // - Files |
| type TFilesResp struct { |
| Status *TSStatus `thrift:"status,1,required" db:"status" json:"status"` |
| Files []*TFile `thrift:"files,2,required" db:"files" json:"files"` |
| } |
| |
| func NewTFilesResp() *TFilesResp { |
| return &TFilesResp{} |
| } |
| |
| var TFilesResp_Status_DEFAULT *TSStatus |
| func (p *TFilesResp) GetStatus() *TSStatus { |
| if !p.IsSetStatus() { |
| return TFilesResp_Status_DEFAULT |
| } |
| return p.Status |
| } |
| |
| func (p *TFilesResp) GetFiles() []*TFile { |
| return p.Files |
| } |
| func (p *TFilesResp) IsSetStatus() bool { |
| return p.Status != nil |
| } |
| |
| func (p *TFilesResp) Read(ctx context.Context, iprot thrift.TProtocol) error { |
| if _, err := iprot.ReadStructBegin(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) |
| } |
| |
| var issetStatus bool = false; |
| var issetFiles bool = false; |
| |
| for { |
| _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx) |
| 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 fieldTypeId == thrift.STRUCT { |
| if err := p.ReadField1(ctx, iprot); err != nil { |
| return err |
| } |
| issetStatus = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 2: |
| if fieldTypeId == thrift.LIST { |
| if err := p.ReadField2(ctx, iprot); err != nil { |
| return err |
| } |
| issetFiles = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| default: |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadFieldEnd(ctx); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadStructEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) |
| } |
| if !issetStatus{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field Status is not set")); |
| } |
| if !issetFiles{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field Files is not set")); |
| } |
| return nil |
| } |
| |
| func (p *TFilesResp) ReadField1(ctx context.Context, iprot thrift.TProtocol) error { |
| p.Status = &TSStatus{} |
| if err := p.Status.Read(ctx, iprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Status), err) |
| } |
| return nil |
| } |
| |
| func (p *TFilesResp) ReadField2(ctx context.Context, iprot thrift.TProtocol) error { |
| _, size, err := iprot.ReadListBegin(ctx) |
| if err != nil { |
| return thrift.PrependError("error reading list begin: ", err) |
| } |
| tSlice := make([]*TFile, 0, size) |
| p.Files = tSlice |
| for i := 0; i < size; i ++ { |
| _elem10 := &TFile{} |
| if err := _elem10.Read(ctx, iprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem10), err) |
| } |
| p.Files = append(p.Files, _elem10) |
| } |
| if err := iprot.ReadListEnd(ctx); err != nil { |
| return thrift.PrependError("error reading list end: ", err) |
| } |
| return nil |
| } |
| |
| func (p *TFilesResp) Write(ctx context.Context, oprot thrift.TProtocol) error { |
| if err := oprot.WriteStructBegin(ctx, "TFilesResp"); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } |
| if p != nil { |
| if err := p.writeField1(ctx, oprot); err != nil { return err } |
| if err := p.writeField2(ctx, oprot); err != nil { return err } |
| } |
| if err := oprot.WriteFieldStop(ctx); err != nil { |
| return thrift.PrependError("write field stop error: ", err) } |
| if err := oprot.WriteStructEnd(ctx); err != nil { |
| return thrift.PrependError("write struct stop error: ", err) } |
| return nil |
| } |
| |
| func (p *TFilesResp) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "status", thrift.STRUCT, 1); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:status: ", p), err) } |
| if err := p.Status.Write(ctx, oprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.Status), err) |
| } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 1:status: ", p), err) } |
| return err |
| } |
| |
| func (p *TFilesResp) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "files", thrift.LIST, 2); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:files: ", p), err) } |
| if err := oprot.WriteListBegin(ctx, thrift.STRUCT, len(p.Files)); err != nil { |
| return thrift.PrependError("error writing list begin: ", err) |
| } |
| for _, v := range p.Files { |
| if err := v.Write(ctx, oprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err) |
| } |
| } |
| if err := oprot.WriteListEnd(ctx); err != nil { |
| return thrift.PrependError("error writing list end: ", err) |
| } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 2:files: ", p), err) } |
| return err |
| } |
| |
| func (p *TFilesResp) Equals(other *TFilesResp) bool { |
| if p == other { |
| return true |
| } else if p == nil || other == nil { |
| return false |
| } |
| if !p.Status.Equals(other.Status) { return false } |
| if len(p.Files) != len(other.Files) { return false } |
| for i, _tgt := range p.Files { |
| _src11 := other.Files[i] |
| if !_tgt.Equals(_src11) { return false } |
| } |
| return true |
| } |
| |
| func (p *TFilesResp) String() string { |
| if p == nil { |
| return "<nil>" |
| } |
| return fmt.Sprintf("TFilesResp(%+v)", *p) |
| } |
| |
| // Attributes: |
| // - DiskSize |
| // - DeviceNum |
| // - TimeserieNum |
| type TSpaceQuota struct { |
| DiskSize *int64 `thrift:"diskSize,1" db:"diskSize" json:"diskSize,omitempty"` |
| DeviceNum *int64 `thrift:"deviceNum,2" db:"deviceNum" json:"deviceNum,omitempty"` |
| TimeserieNum *int64 `thrift:"timeserieNum,3" db:"timeserieNum" json:"timeserieNum,omitempty"` |
| } |
| |
| func NewTSpaceQuota() *TSpaceQuota { |
| return &TSpaceQuota{} |
| } |
| |
| var TSpaceQuota_DiskSize_DEFAULT int64 |
| func (p *TSpaceQuota) GetDiskSize() int64 { |
| if !p.IsSetDiskSize() { |
| return TSpaceQuota_DiskSize_DEFAULT |
| } |
| return *p.DiskSize |
| } |
| var TSpaceQuota_DeviceNum_DEFAULT int64 |
| func (p *TSpaceQuota) GetDeviceNum() int64 { |
| if !p.IsSetDeviceNum() { |
| return TSpaceQuota_DeviceNum_DEFAULT |
| } |
| return *p.DeviceNum |
| } |
| var TSpaceQuota_TimeserieNum_DEFAULT int64 |
| func (p *TSpaceQuota) GetTimeserieNum() int64 { |
| if !p.IsSetTimeserieNum() { |
| return TSpaceQuota_TimeserieNum_DEFAULT |
| } |
| return *p.TimeserieNum |
| } |
| func (p *TSpaceQuota) IsSetDiskSize() bool { |
| return p.DiskSize != nil |
| } |
| |
| func (p *TSpaceQuota) IsSetDeviceNum() bool { |
| return p.DeviceNum != nil |
| } |
| |
| func (p *TSpaceQuota) IsSetTimeserieNum() bool { |
| return p.TimeserieNum != nil |
| } |
| |
| func (p *TSpaceQuota) Read(ctx context.Context, iprot thrift.TProtocol) error { |
| if _, err := iprot.ReadStructBegin(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) |
| } |
| |
| |
| for { |
| _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx) |
| 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 fieldTypeId == thrift.I64 { |
| if err := p.ReadField1(ctx, iprot); err != nil { |
| return err |
| } |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 2: |
| if fieldTypeId == thrift.I64 { |
| if err := p.ReadField2(ctx, iprot); err != nil { |
| return err |
| } |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 3: |
| if fieldTypeId == thrift.I64 { |
| if err := p.ReadField3(ctx, iprot); err != nil { |
| return err |
| } |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| default: |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadFieldEnd(ctx); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadStructEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) |
| } |
| return nil |
| } |
| |
| func (p *TSpaceQuota) ReadField1(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadI64(ctx); err != nil { |
| return thrift.PrependError("error reading field 1: ", err) |
| } else { |
| p.DiskSize = &v |
| } |
| return nil |
| } |
| |
| func (p *TSpaceQuota) ReadField2(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadI64(ctx); err != nil { |
| return thrift.PrependError("error reading field 2: ", err) |
| } else { |
| p.DeviceNum = &v |
| } |
| return nil |
| } |
| |
| func (p *TSpaceQuota) ReadField3(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadI64(ctx); err != nil { |
| return thrift.PrependError("error reading field 3: ", err) |
| } else { |
| p.TimeserieNum = &v |
| } |
| return nil |
| } |
| |
| func (p *TSpaceQuota) Write(ctx context.Context, oprot thrift.TProtocol) error { |
| if err := oprot.WriteStructBegin(ctx, "TSpaceQuota"); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } |
| if p != nil { |
| if err := p.writeField1(ctx, oprot); err != nil { return err } |
| if err := p.writeField2(ctx, oprot); err != nil { return err } |
| if err := p.writeField3(ctx, oprot); err != nil { return err } |
| } |
| if err := oprot.WriteFieldStop(ctx); err != nil { |
| return thrift.PrependError("write field stop error: ", err) } |
| if err := oprot.WriteStructEnd(ctx); err != nil { |
| return thrift.PrependError("write struct stop error: ", err) } |
| return nil |
| } |
| |
| func (p *TSpaceQuota) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if p.IsSetDiskSize() { |
| if err := oprot.WriteFieldBegin(ctx, "diskSize", thrift.I64, 1); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:diskSize: ", p), err) } |
| if err := oprot.WriteI64(ctx, int64(*p.DiskSize)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.diskSize (1) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 1:diskSize: ", p), err) } |
| } |
| return err |
| } |
| |
| func (p *TSpaceQuota) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if p.IsSetDeviceNum() { |
| if err := oprot.WriteFieldBegin(ctx, "deviceNum", thrift.I64, 2); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:deviceNum: ", p), err) } |
| if err := oprot.WriteI64(ctx, int64(*p.DeviceNum)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.deviceNum (2) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 2:deviceNum: ", p), err) } |
| } |
| return err |
| } |
| |
| func (p *TSpaceQuota) writeField3(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if p.IsSetTimeserieNum() { |
| if err := oprot.WriteFieldBegin(ctx, "timeserieNum", thrift.I64, 3); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:timeserieNum: ", p), err) } |
| if err := oprot.WriteI64(ctx, int64(*p.TimeserieNum)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.timeserieNum (3) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 3:timeserieNum: ", p), err) } |
| } |
| return err |
| } |
| |
| func (p *TSpaceQuota) Equals(other *TSpaceQuota) bool { |
| if p == other { |
| return true |
| } else if p == nil || other == nil { |
| return false |
| } |
| if p.DiskSize != other.DiskSize { |
| if p.DiskSize == nil || other.DiskSize == nil { |
| return false |
| } |
| if (*p.DiskSize) != (*other.DiskSize) { return false } |
| } |
| if p.DeviceNum != other.DeviceNum { |
| if p.DeviceNum == nil || other.DeviceNum == nil { |
| return false |
| } |
| if (*p.DeviceNum) != (*other.DeviceNum) { return false } |
| } |
| if p.TimeserieNum != other.TimeserieNum { |
| if p.TimeserieNum == nil || other.TimeserieNum == nil { |
| return false |
| } |
| if (*p.TimeserieNum) != (*other.TimeserieNum) { return false } |
| } |
| return true |
| } |
| |
| func (p *TSpaceQuota) String() string { |
| if p == nil { |
| return "<nil>" |
| } |
| return fmt.Sprintf("TSpaceQuota(%+v)", *p) |
| } |
| |
| // Attributes: |
| // - TimeUnit |
| // - SoftLimit |
| type TTimedQuota struct { |
| TimeUnit int64 `thrift:"timeUnit,1,required" db:"timeUnit" json:"timeUnit"` |
| SoftLimit int64 `thrift:"softLimit,2,required" db:"softLimit" json:"softLimit"` |
| } |
| |
| func NewTTimedQuota() *TTimedQuota { |
| return &TTimedQuota{} |
| } |
| |
| |
| func (p *TTimedQuota) GetTimeUnit() int64 { |
| return p.TimeUnit |
| } |
| |
| func (p *TTimedQuota) GetSoftLimit() int64 { |
| return p.SoftLimit |
| } |
| func (p *TTimedQuota) Read(ctx context.Context, iprot thrift.TProtocol) error { |
| if _, err := iprot.ReadStructBegin(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) |
| } |
| |
| var issetTimeUnit bool = false; |
| var issetSoftLimit bool = false; |
| |
| for { |
| _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx) |
| 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 fieldTypeId == thrift.I64 { |
| if err := p.ReadField1(ctx, iprot); err != nil { |
| return err |
| } |
| issetTimeUnit = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 2: |
| if fieldTypeId == thrift.I64 { |
| if err := p.ReadField2(ctx, iprot); err != nil { |
| return err |
| } |
| issetSoftLimit = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| default: |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadFieldEnd(ctx); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadStructEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) |
| } |
| if !issetTimeUnit{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field TimeUnit is not set")); |
| } |
| if !issetSoftLimit{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field SoftLimit is not set")); |
| } |
| return nil |
| } |
| |
| func (p *TTimedQuota) ReadField1(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadI64(ctx); err != nil { |
| return thrift.PrependError("error reading field 1: ", err) |
| } else { |
| p.TimeUnit = v |
| } |
| return nil |
| } |
| |
| func (p *TTimedQuota) ReadField2(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadI64(ctx); err != nil { |
| return thrift.PrependError("error reading field 2: ", err) |
| } else { |
| p.SoftLimit = v |
| } |
| return nil |
| } |
| |
| func (p *TTimedQuota) Write(ctx context.Context, oprot thrift.TProtocol) error { |
| if err := oprot.WriteStructBegin(ctx, "TTimedQuota"); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } |
| if p != nil { |
| if err := p.writeField1(ctx, oprot); err != nil { return err } |
| if err := p.writeField2(ctx, oprot); err != nil { return err } |
| } |
| if err := oprot.WriteFieldStop(ctx); err != nil { |
| return thrift.PrependError("write field stop error: ", err) } |
| if err := oprot.WriteStructEnd(ctx); err != nil { |
| return thrift.PrependError("write struct stop error: ", err) } |
| return nil |
| } |
| |
| func (p *TTimedQuota) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "timeUnit", thrift.I64, 1); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:timeUnit: ", p), err) } |
| if err := oprot.WriteI64(ctx, int64(p.TimeUnit)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.timeUnit (1) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 1:timeUnit: ", p), err) } |
| return err |
| } |
| |
| func (p *TTimedQuota) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "softLimit", thrift.I64, 2); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:softLimit: ", p), err) } |
| if err := oprot.WriteI64(ctx, int64(p.SoftLimit)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.softLimit (2) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 2:softLimit: ", p), err) } |
| return err |
| } |
| |
| func (p *TTimedQuota) Equals(other *TTimedQuota) bool { |
| if p == other { |
| return true |
| } else if p == nil || other == nil { |
| return false |
| } |
| if p.TimeUnit != other.TimeUnit { return false } |
| if p.SoftLimit != other.SoftLimit { return false } |
| return true |
| } |
| |
| func (p *TTimedQuota) String() string { |
| if p == nil { |
| return "<nil>" |
| } |
| return fmt.Sprintf("TTimedQuota(%+v)", *p) |
| } |
| |
| // Attributes: |
| // - ThrottleLimit |
| // - MemLimit |
| // - CpuLimit |
| type TThrottleQuota struct { |
| ThrottleLimit map[ThrottleType]*TTimedQuota `thrift:"throttleLimit,1" db:"throttleLimit" json:"throttleLimit,omitempty"` |
| MemLimit *int64 `thrift:"memLimit,2" db:"memLimit" json:"memLimit,omitempty"` |
| CpuLimit *int32 `thrift:"cpuLimit,3" db:"cpuLimit" json:"cpuLimit,omitempty"` |
| } |
| |
| func NewTThrottleQuota() *TThrottleQuota { |
| return &TThrottleQuota{} |
| } |
| |
| var TThrottleQuota_ThrottleLimit_DEFAULT map[ThrottleType]*TTimedQuota |
| |
| func (p *TThrottleQuota) GetThrottleLimit() map[ThrottleType]*TTimedQuota { |
| return p.ThrottleLimit |
| } |
| var TThrottleQuota_MemLimit_DEFAULT int64 |
| func (p *TThrottleQuota) GetMemLimit() int64 { |
| if !p.IsSetMemLimit() { |
| return TThrottleQuota_MemLimit_DEFAULT |
| } |
| return *p.MemLimit |
| } |
| var TThrottleQuota_CpuLimit_DEFAULT int32 |
| func (p *TThrottleQuota) GetCpuLimit() int32 { |
| if !p.IsSetCpuLimit() { |
| return TThrottleQuota_CpuLimit_DEFAULT |
| } |
| return *p.CpuLimit |
| } |
| func (p *TThrottleQuota) IsSetThrottleLimit() bool { |
| return p.ThrottleLimit != nil |
| } |
| |
| func (p *TThrottleQuota) IsSetMemLimit() bool { |
| return p.MemLimit != nil |
| } |
| |
| func (p *TThrottleQuota) IsSetCpuLimit() bool { |
| return p.CpuLimit != nil |
| } |
| |
| func (p *TThrottleQuota) Read(ctx context.Context, iprot thrift.TProtocol) error { |
| if _, err := iprot.ReadStructBegin(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) |
| } |
| |
| |
| for { |
| _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx) |
| 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 fieldTypeId == thrift.MAP { |
| if err := p.ReadField1(ctx, iprot); err != nil { |
| return err |
| } |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 2: |
| if fieldTypeId == thrift.I64 { |
| if err := p.ReadField2(ctx, iprot); err != nil { |
| return err |
| } |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 3: |
| if fieldTypeId == thrift.I32 { |
| if err := p.ReadField3(ctx, iprot); err != nil { |
| return err |
| } |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| default: |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadFieldEnd(ctx); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadStructEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) |
| } |
| return nil |
| } |
| |
| func (p *TThrottleQuota) ReadField1(ctx context.Context, iprot thrift.TProtocol) error { |
| _, _, size, err := iprot.ReadMapBegin(ctx) |
| if err != nil { |
| return thrift.PrependError("error reading map begin: ", err) |
| } |
| tMap := make(map[ThrottleType]*TTimedQuota, size) |
| p.ThrottleLimit = tMap |
| for i := 0; i < size; i ++ { |
| var _key12 ThrottleType |
| if v, err := iprot.ReadI32(ctx); err != nil { |
| return thrift.PrependError("error reading field 0: ", err) |
| } else { |
| temp := ThrottleType(v) |
| _key12 = temp |
| } |
| _val13 := &TTimedQuota{} |
| if err := _val13.Read(ctx, iprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _val13), err) |
| } |
| p.ThrottleLimit[_key12] = _val13 |
| } |
| if err := iprot.ReadMapEnd(ctx); err != nil { |
| return thrift.PrependError("error reading map end: ", err) |
| } |
| return nil |
| } |
| |
| func (p *TThrottleQuota) ReadField2(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadI64(ctx); err != nil { |
| return thrift.PrependError("error reading field 2: ", err) |
| } else { |
| p.MemLimit = &v |
| } |
| return nil |
| } |
| |
| func (p *TThrottleQuota) ReadField3(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadI32(ctx); err != nil { |
| return thrift.PrependError("error reading field 3: ", err) |
| } else { |
| p.CpuLimit = &v |
| } |
| return nil |
| } |
| |
| func (p *TThrottleQuota) Write(ctx context.Context, oprot thrift.TProtocol) error { |
| if err := oprot.WriteStructBegin(ctx, "TThrottleQuota"); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } |
| if p != nil { |
| if err := p.writeField1(ctx, oprot); err != nil { return err } |
| if err := p.writeField2(ctx, oprot); err != nil { return err } |
| if err := p.writeField3(ctx, oprot); err != nil { return err } |
| } |
| if err := oprot.WriteFieldStop(ctx); err != nil { |
| return thrift.PrependError("write field stop error: ", err) } |
| if err := oprot.WriteStructEnd(ctx); err != nil { |
| return thrift.PrependError("write struct stop error: ", err) } |
| return nil |
| } |
| |
| func (p *TThrottleQuota) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if p.IsSetThrottleLimit() { |
| if err := oprot.WriteFieldBegin(ctx, "throttleLimit", thrift.MAP, 1); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:throttleLimit: ", p), err) } |
| if err := oprot.WriteMapBegin(ctx, thrift.I32, thrift.STRUCT, len(p.ThrottleLimit)); err != nil { |
| return thrift.PrependError("error writing map begin: ", err) |
| } |
| for k, v := range p.ThrottleLimit { |
| if err := oprot.WriteI32(ctx, int32(k)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) } |
| if err := v.Write(ctx, oprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err) |
| } |
| } |
| if err := oprot.WriteMapEnd(ctx); err != nil { |
| return thrift.PrependError("error writing map end: ", err) |
| } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 1:throttleLimit: ", p), err) } |
| } |
| return err |
| } |
| |
| func (p *TThrottleQuota) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if p.IsSetMemLimit() { |
| if err := oprot.WriteFieldBegin(ctx, "memLimit", thrift.I64, 2); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:memLimit: ", p), err) } |
| if err := oprot.WriteI64(ctx, int64(*p.MemLimit)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.memLimit (2) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 2:memLimit: ", p), err) } |
| } |
| return err |
| } |
| |
| func (p *TThrottleQuota) writeField3(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if p.IsSetCpuLimit() { |
| if err := oprot.WriteFieldBegin(ctx, "cpuLimit", thrift.I32, 3); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:cpuLimit: ", p), err) } |
| if err := oprot.WriteI32(ctx, int32(*p.CpuLimit)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.cpuLimit (3) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 3:cpuLimit: ", p), err) } |
| } |
| return err |
| } |
| |
| func (p *TThrottleQuota) Equals(other *TThrottleQuota) bool { |
| if p == other { |
| return true |
| } else if p == nil || other == nil { |
| return false |
| } |
| if len(p.ThrottleLimit) != len(other.ThrottleLimit) { return false } |
| for k, _tgt := range p.ThrottleLimit { |
| _src14 := other.ThrottleLimit[k] |
| if !_tgt.Equals(_src14) { return false } |
| } |
| if p.MemLimit != other.MemLimit { |
| if p.MemLimit == nil || other.MemLimit == nil { |
| return false |
| } |
| if (*p.MemLimit) != (*other.MemLimit) { return false } |
| } |
| if p.CpuLimit != other.CpuLimit { |
| if p.CpuLimit == nil || other.CpuLimit == nil { |
| return false |
| } |
| if (*p.CpuLimit) != (*other.CpuLimit) { return false } |
| } |
| return true |
| } |
| |
| func (p *TThrottleQuota) String() string { |
| if p == nil { |
| return "<nil>" |
| } |
| return fmt.Sprintf("TThrottleQuota(%+v)", *p) |
| } |
| |
| // Attributes: |
| // - Database |
| // - SpaceLimit |
| type TSetSpaceQuotaReq struct { |
| Database []string `thrift:"database,1,required" db:"database" json:"database"` |
| SpaceLimit *TSpaceQuota `thrift:"spaceLimit,2,required" db:"spaceLimit" json:"spaceLimit"` |
| } |
| |
| func NewTSetSpaceQuotaReq() *TSetSpaceQuotaReq { |
| return &TSetSpaceQuotaReq{} |
| } |
| |
| |
| func (p *TSetSpaceQuotaReq) GetDatabase() []string { |
| return p.Database |
| } |
| var TSetSpaceQuotaReq_SpaceLimit_DEFAULT *TSpaceQuota |
| func (p *TSetSpaceQuotaReq) GetSpaceLimit() *TSpaceQuota { |
| if !p.IsSetSpaceLimit() { |
| return TSetSpaceQuotaReq_SpaceLimit_DEFAULT |
| } |
| return p.SpaceLimit |
| } |
| func (p *TSetSpaceQuotaReq) IsSetSpaceLimit() bool { |
| return p.SpaceLimit != nil |
| } |
| |
| func (p *TSetSpaceQuotaReq) Read(ctx context.Context, iprot thrift.TProtocol) error { |
| if _, err := iprot.ReadStructBegin(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) |
| } |
| |
| var issetDatabase bool = false; |
| var issetSpaceLimit bool = false; |
| |
| for { |
| _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx) |
| 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 fieldTypeId == thrift.LIST { |
| if err := p.ReadField1(ctx, iprot); err != nil { |
| return err |
| } |
| issetDatabase = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 2: |
| if fieldTypeId == thrift.STRUCT { |
| if err := p.ReadField2(ctx, iprot); err != nil { |
| return err |
| } |
| issetSpaceLimit = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| default: |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadFieldEnd(ctx); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadStructEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) |
| } |
| if !issetDatabase{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field Database is not set")); |
| } |
| if !issetSpaceLimit{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field SpaceLimit is not set")); |
| } |
| return nil |
| } |
| |
| func (p *TSetSpaceQuotaReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error { |
| _, size, err := iprot.ReadListBegin(ctx) |
| if err != nil { |
| return thrift.PrependError("error reading list begin: ", err) |
| } |
| tSlice := make([]string, 0, size) |
| p.Database = tSlice |
| for i := 0; i < size; i ++ { |
| var _elem15 string |
| if v, err := iprot.ReadString(ctx); err != nil { |
| return thrift.PrependError("error reading field 0: ", err) |
| } else { |
| _elem15 = v |
| } |
| p.Database = append(p.Database, _elem15) |
| } |
| if err := iprot.ReadListEnd(ctx); err != nil { |
| return thrift.PrependError("error reading list end: ", err) |
| } |
| return nil |
| } |
| |
| func (p *TSetSpaceQuotaReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error { |
| p.SpaceLimit = &TSpaceQuota{} |
| if err := p.SpaceLimit.Read(ctx, iprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.SpaceLimit), err) |
| } |
| return nil |
| } |
| |
| func (p *TSetSpaceQuotaReq) Write(ctx context.Context, oprot thrift.TProtocol) error { |
| if err := oprot.WriteStructBegin(ctx, "TSetSpaceQuotaReq"); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } |
| if p != nil { |
| if err := p.writeField1(ctx, oprot); err != nil { return err } |
| if err := p.writeField2(ctx, oprot); err != nil { return err } |
| } |
| if err := oprot.WriteFieldStop(ctx); err != nil { |
| return thrift.PrependError("write field stop error: ", err) } |
| if err := oprot.WriteStructEnd(ctx); err != nil { |
| return thrift.PrependError("write struct stop error: ", err) } |
| return nil |
| } |
| |
| func (p *TSetSpaceQuotaReq) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "database", thrift.LIST, 1); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:database: ", p), err) } |
| if err := oprot.WriteListBegin(ctx, thrift.STRING, len(p.Database)); err != nil { |
| return thrift.PrependError("error writing list begin: ", err) |
| } |
| for _, v := range p.Database { |
| if err := oprot.WriteString(ctx, string(v)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err) } |
| } |
| if err := oprot.WriteListEnd(ctx); err != nil { |
| return thrift.PrependError("error writing list end: ", err) |
| } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 1:database: ", p), err) } |
| return err |
| } |
| |
| func (p *TSetSpaceQuotaReq) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "spaceLimit", thrift.STRUCT, 2); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:spaceLimit: ", p), err) } |
| if err := p.SpaceLimit.Write(ctx, oprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.SpaceLimit), err) |
| } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 2:spaceLimit: ", p), err) } |
| return err |
| } |
| |
| func (p *TSetSpaceQuotaReq) Equals(other *TSetSpaceQuotaReq) bool { |
| if p == other { |
| return true |
| } else if p == nil || other == nil { |
| return false |
| } |
| if len(p.Database) != len(other.Database) { return false } |
| for i, _tgt := range p.Database { |
| _src16 := other.Database[i] |
| if _tgt != _src16 { return false } |
| } |
| if !p.SpaceLimit.Equals(other.SpaceLimit) { return false } |
| return true |
| } |
| |
| func (p *TSetSpaceQuotaReq) String() string { |
| if p == nil { |
| return "<nil>" |
| } |
| return fmt.Sprintf("TSetSpaceQuotaReq(%+v)", *p) |
| } |
| |
| // Attributes: |
| // - UserName |
| // - ThrottleQuota |
| type TSetThrottleQuotaReq struct { |
| UserName string `thrift:"userName,1,required" db:"userName" json:"userName"` |
| ThrottleQuota *TThrottleQuota `thrift:"throttleQuota,2,required" db:"throttleQuota" json:"throttleQuota"` |
| } |
| |
| func NewTSetThrottleQuotaReq() *TSetThrottleQuotaReq { |
| return &TSetThrottleQuotaReq{} |
| } |
| |
| |
| func (p *TSetThrottleQuotaReq) GetUserName() string { |
| return p.UserName |
| } |
| var TSetThrottleQuotaReq_ThrottleQuota_DEFAULT *TThrottleQuota |
| func (p *TSetThrottleQuotaReq) GetThrottleQuota() *TThrottleQuota { |
| if !p.IsSetThrottleQuota() { |
| return TSetThrottleQuotaReq_ThrottleQuota_DEFAULT |
| } |
| return p.ThrottleQuota |
| } |
| func (p *TSetThrottleQuotaReq) IsSetThrottleQuota() bool { |
| return p.ThrottleQuota != nil |
| } |
| |
| func (p *TSetThrottleQuotaReq) Read(ctx context.Context, iprot thrift.TProtocol) error { |
| if _, err := iprot.ReadStructBegin(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err) |
| } |
| |
| var issetUserName bool = false; |
| var issetThrottleQuota bool = false; |
| |
| for { |
| _, fieldTypeId, fieldId, err := iprot.ReadFieldBegin(ctx) |
| 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 fieldTypeId == thrift.STRING { |
| if err := p.ReadField1(ctx, iprot); err != nil { |
| return err |
| } |
| issetUserName = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| case 2: |
| if fieldTypeId == thrift.STRUCT { |
| if err := p.ReadField2(ctx, iprot); err != nil { |
| return err |
| } |
| issetThrottleQuota = true |
| } else { |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| default: |
| if err := iprot.Skip(ctx, fieldTypeId); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadFieldEnd(ctx); err != nil { |
| return err |
| } |
| } |
| if err := iprot.ReadStructEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err) |
| } |
| if !issetUserName{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field UserName is not set")); |
| } |
| if !issetThrottleQuota{ |
| return thrift.NewTProtocolExceptionWithType(thrift.INVALID_DATA, fmt.Errorf("Required field ThrottleQuota is not set")); |
| } |
| return nil |
| } |
| |
| func (p *TSetThrottleQuotaReq) ReadField1(ctx context.Context, iprot thrift.TProtocol) error { |
| if v, err := iprot.ReadString(ctx); err != nil { |
| return thrift.PrependError("error reading field 1: ", err) |
| } else { |
| p.UserName = v |
| } |
| return nil |
| } |
| |
| func (p *TSetThrottleQuotaReq) ReadField2(ctx context.Context, iprot thrift.TProtocol) error { |
| p.ThrottleQuota = &TThrottleQuota{} |
| if err := p.ThrottleQuota.Read(ctx, iprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.ThrottleQuota), err) |
| } |
| return nil |
| } |
| |
| func (p *TSetThrottleQuotaReq) Write(ctx context.Context, oprot thrift.TProtocol) error { |
| if err := oprot.WriteStructBegin(ctx, "TSetThrottleQuotaReq"); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write struct begin error: ", p), err) } |
| if p != nil { |
| if err := p.writeField1(ctx, oprot); err != nil { return err } |
| if err := p.writeField2(ctx, oprot); err != nil { return err } |
| } |
| if err := oprot.WriteFieldStop(ctx); err != nil { |
| return thrift.PrependError("write field stop error: ", err) } |
| if err := oprot.WriteStructEnd(ctx); err != nil { |
| return thrift.PrependError("write struct stop error: ", err) } |
| return nil |
| } |
| |
| func (p *TSetThrottleQuotaReq) writeField1(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "userName", thrift.STRING, 1); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 1:userName: ", p), err) } |
| if err := oprot.WriteString(ctx, string(p.UserName)); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T.userName (1) field write error: ", p), err) } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 1:userName: ", p), err) } |
| return err |
| } |
| |
| func (p *TSetThrottleQuotaReq) writeField2(ctx context.Context, oprot thrift.TProtocol) (err error) { |
| if err := oprot.WriteFieldBegin(ctx, "throttleQuota", thrift.STRUCT, 2); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:throttleQuota: ", p), err) } |
| if err := p.ThrottleQuota.Write(ctx, oprot); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.ThrottleQuota), err) |
| } |
| if err := oprot.WriteFieldEnd(ctx); err != nil { |
| return thrift.PrependError(fmt.Sprintf("%T write field end error 2:throttleQuota: ", p), err) } |
| return err |
| } |
| |
| func (p *TSetThrottleQuotaReq) Equals(other *TSetThrottleQuotaReq) bool { |
| if p == other { |
| return true |
| } else if p == nil || other == nil { |
| return false |
| } |
| if p.UserName != other.UserName { return false } |
| if !p.ThrottleQuota.Equals(other.ThrottleQuota) { return false } |
| return true |
| } |
| |
| func (p *TSetThrottleQuotaReq) String() string { |
| if p == nil { |
| return "<nil>" |
| } |
| return fmt.Sprintf("TSetThrottleQuotaReq(%+v)", *p) |
| } |
| |
