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

package admin

import (
	"bytes"
	"context"
	"database/sql/driver"
	"errors"
	"fmt"
	"github.com/apache/incubator-pegasus/go-client/idl/base"
	"github.com/apache/incubator-pegasus/go-client/idl/replication"
	"github.com/apache/incubator-pegasus/go-client/idl/utils"
	"github.com/apache/thrift/lib/go/thrift"
	"reflect"
)

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

var _ = base.GoUnusedProtection__
var _ = replication.GoUnusedProtection__
var _ = utils.GoUnusedProtection__

type DuplicationMode int64

const (
	DuplicationMode_FULL        DuplicationMode = 0
	DuplicationMode_INCREMENTAL DuplicationMode = 1
)

func (p DuplicationMode) String() string {
	switch p {
	case DuplicationMode_FULL:
		return "FULL"
	case DuplicationMode_INCREMENTAL:
		return "INCREMENTAL"
	}
	return "<UNSET>"
}

func DuplicationModeFromString(s string) (DuplicationMode, error) {
	switch s {
	case "FULL":
		return DuplicationMode_FULL, nil
	case "INCREMENTAL":
		return DuplicationMode_INCREMENTAL, nil
	}
	return DuplicationMode(0), fmt.Errorf("not a valid DuplicationMode string")
}

func DuplicationModePtr(v DuplicationMode) *DuplicationMode { return &v }

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

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

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

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

type DuplicationStatus int64

const (
	DuplicationStatus_DS_INIT    DuplicationStatus = 0
	DuplicationStatus_DS_PREPARE DuplicationStatus = 1
	DuplicationStatus_DS_APP     DuplicationStatus = 2
	DuplicationStatus_DS_LOG     DuplicationStatus = 3
	DuplicationStatus_DS_PAUSE   DuplicationStatus = 4
	DuplicationStatus_DS_REMOVED DuplicationStatus = 5
)

func (p DuplicationStatus) String() string {
	switch p {
	case DuplicationStatus_DS_INIT:
		return "DS_INIT"
	case DuplicationStatus_DS_PREPARE:
		return "DS_PREPARE"
	case DuplicationStatus_DS_APP:
		return "DS_APP"
	case DuplicationStatus_DS_LOG:
		return "DS_LOG"
	case DuplicationStatus_DS_PAUSE:
		return "DS_PAUSE"
	case DuplicationStatus_DS_REMOVED:
		return "DS_REMOVED"
	}
	return "<UNSET>"
}

func DuplicationStatusFromString(s string) (DuplicationStatus, error) {
	switch s {
	case "DS_INIT":
		return DuplicationStatus_DS_INIT, nil
	case "DS_PREPARE":
		return DuplicationStatus_DS_PREPARE, nil
	case "DS_APP":
		return DuplicationStatus_DS_APP, nil
	case "DS_LOG":
		return DuplicationStatus_DS_LOG, nil
	case "DS_PAUSE":
		return DuplicationStatus_DS_PAUSE, nil
	case "DS_REMOVED":
		return DuplicationStatus_DS_REMOVED, nil
	}
	return DuplicationStatus(0), fmt.Errorf("not a valid DuplicationStatus string")
}

func DuplicationStatusPtr(v DuplicationStatus) *DuplicationStatus { return &v }

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

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

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

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

type DuplicationFailMode int64

const (
	DuplicationFailMode_FAIL_SLOW DuplicationFailMode = 0
	DuplicationFailMode_FAIL_SKIP DuplicationFailMode = 1
	DuplicationFailMode_FAIL_FAST DuplicationFailMode = 2
)

func (p DuplicationFailMode) String() string {
	switch p {
	case DuplicationFailMode_FAIL_SLOW:
		return "FAIL_SLOW"
	case DuplicationFailMode_FAIL_SKIP:
		return "FAIL_SKIP"
	case DuplicationFailMode_FAIL_FAST:
		return "FAIL_FAST"
	}
	return "<UNSET>"
}

func DuplicationFailModeFromString(s string) (DuplicationFailMode, error) {
	switch s {
	case "FAIL_SLOW":
		return DuplicationFailMode_FAIL_SLOW, nil
	case "FAIL_SKIP":
		return DuplicationFailMode_FAIL_SKIP, nil
	case "FAIL_FAST":
		return DuplicationFailMode_FAIL_FAST, nil
	}
	return DuplicationFailMode(0), fmt.Errorf("not a valid DuplicationFailMode string")
}

func DuplicationFailModePtr(v DuplicationFailMode) *DuplicationFailMode { return &v }

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

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

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

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

// Attributes:
//  - AppName
//  - RemoteClusterName
//  - IsDuplicatingCheckpoint
//  - RemoteAppName
//  - RemoteReplicaCount
type DuplicationAddRequest struct {
	AppName                 string  `thrift:"app_name,1" db:"app_name" json:"app_name"`
	RemoteClusterName       string  `thrift:"remote_cluster_name,2" db:"remote_cluster_name" json:"remote_cluster_name"`
	IsDuplicatingCheckpoint bool    `thrift:"is_duplicating_checkpoint,3" db:"is_duplicating_checkpoint" json:"is_duplicating_checkpoint"`
	RemoteAppName           *string `thrift:"remote_app_name,4" db:"remote_app_name" json:"remote_app_name,omitempty"`
	RemoteReplicaCount      *int32  `thrift:"remote_replica_count,5" db:"remote_replica_count" json:"remote_replica_count,omitempty"`
}

func NewDuplicationAddRequest() *DuplicationAddRequest {
	return &DuplicationAddRequest{
		IsDuplicatingCheckpoint: true,
	}
}

func (p *DuplicationAddRequest) GetAppName() string {
	return p.AppName
}

func (p *DuplicationAddRequest) GetRemoteClusterName() string {
	return p.RemoteClusterName
}

var DuplicationAddRequest_IsDuplicatingCheckpoint_DEFAULT bool = true

func (p *DuplicationAddRequest) GetIsDuplicatingCheckpoint() bool {
	return p.IsDuplicatingCheckpoint
}

var DuplicationAddRequest_RemoteAppName_DEFAULT string

func (p *DuplicationAddRequest) GetRemoteAppName() string {
	if !p.IsSetRemoteAppName() {
		return DuplicationAddRequest_RemoteAppName_DEFAULT
	}
	return *p.RemoteAppName
}

var DuplicationAddRequest_RemoteReplicaCount_DEFAULT int32

func (p *DuplicationAddRequest) GetRemoteReplicaCount() int32 {
	if !p.IsSetRemoteReplicaCount() {
		return DuplicationAddRequest_RemoteReplicaCount_DEFAULT
	}
	return *p.RemoteReplicaCount
}
func (p *DuplicationAddRequest) IsSetIsDuplicatingCheckpoint() bool {
	return p.IsDuplicatingCheckpoint != DuplicationAddRequest_IsDuplicatingCheckpoint_DEFAULT
}

func (p *DuplicationAddRequest) IsSetRemoteAppName() bool {
	return p.RemoteAppName != nil
}

func (p *DuplicationAddRequest) IsSetRemoteReplicaCount() bool {
	return p.RemoteReplicaCount != nil
}

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

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

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

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

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

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

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

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

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

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

func (p *DuplicationAddRequest) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetIsDuplicatingCheckpoint() {
		if err := oprot.WriteFieldBegin("is_duplicating_checkpoint", thrift.BOOL, 3); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:is_duplicating_checkpoint: ", p), err)
		}
		if err := oprot.WriteBool(bool(p.IsDuplicatingCheckpoint)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.is_duplicating_checkpoint (3) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 3:is_duplicating_checkpoint: ", p), err)
		}
	}
	return err
}

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

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

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

// Attributes:
//  - Err
//  - Appid
//  - Dupid
//  - Hint
//  - RemoteAppName
//  - RemoteReplicaCount
type DuplicationAddResponse struct {
	Err                *base.ErrorCode `thrift:"err,1" db:"err" json:"err"`
	Appid              int32           `thrift:"appid,2" db:"appid" json:"appid"`
	Dupid              int32           `thrift:"dupid,3" db:"dupid" json:"dupid"`
	Hint               *string         `thrift:"hint,4" db:"hint" json:"hint,omitempty"`
	RemoteAppName      *string         `thrift:"remote_app_name,5" db:"remote_app_name" json:"remote_app_name,omitempty"`
	RemoteReplicaCount *int32          `thrift:"remote_replica_count,6" db:"remote_replica_count" json:"remote_replica_count,omitempty"`
}

func NewDuplicationAddResponse() *DuplicationAddResponse {
	return &DuplicationAddResponse{}
}

var DuplicationAddResponse_Err_DEFAULT *base.ErrorCode

func (p *DuplicationAddResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return DuplicationAddResponse_Err_DEFAULT
	}
	return p.Err
}

func (p *DuplicationAddResponse) GetAppid() int32 {
	return p.Appid
}

func (p *DuplicationAddResponse) GetDupid() int32 {
	return p.Dupid
}

var DuplicationAddResponse_Hint_DEFAULT string

func (p *DuplicationAddResponse) GetHint() string {
	if !p.IsSetHint() {
		return DuplicationAddResponse_Hint_DEFAULT
	}
	return *p.Hint
}

var DuplicationAddResponse_RemoteAppName_DEFAULT string

func (p *DuplicationAddResponse) GetRemoteAppName() string {
	if !p.IsSetRemoteAppName() {
		return DuplicationAddResponse_RemoteAppName_DEFAULT
	}
	return *p.RemoteAppName
}

var DuplicationAddResponse_RemoteReplicaCount_DEFAULT int32

func (p *DuplicationAddResponse) GetRemoteReplicaCount() int32 {
	if !p.IsSetRemoteReplicaCount() {
		return DuplicationAddResponse_RemoteReplicaCount_DEFAULT
	}
	return *p.RemoteReplicaCount
}
func (p *DuplicationAddResponse) IsSetErr() bool {
	return p.Err != nil
}

func (p *DuplicationAddResponse) IsSetHint() bool {
	return p.Hint != nil
}

func (p *DuplicationAddResponse) IsSetRemoteAppName() bool {
	return p.RemoteAppName != nil
}

func (p *DuplicationAddResponse) IsSetRemoteReplicaCount() bool {
	return p.RemoteReplicaCount != nil
}

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

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

func (p *DuplicationAddResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// Attributes:
//  - AppName
//  - Dupid
//  - Status
//  - FailMode
type DuplicationModifyRequest struct {
	AppName  string               `thrift:"app_name,1" db:"app_name" json:"app_name"`
	Dupid    int32                `thrift:"dupid,2" db:"dupid" json:"dupid"`
	Status   *DuplicationStatus   `thrift:"status,3" db:"status" json:"status,omitempty"`
	FailMode *DuplicationFailMode `thrift:"fail_mode,4" db:"fail_mode" json:"fail_mode,omitempty"`
}

func NewDuplicationModifyRequest() *DuplicationModifyRequest {
	return &DuplicationModifyRequest{}
}

func (p *DuplicationModifyRequest) GetAppName() string {
	return p.AppName
}

func (p *DuplicationModifyRequest) GetDupid() int32 {
	return p.Dupid
}

var DuplicationModifyRequest_Status_DEFAULT DuplicationStatus

func (p *DuplicationModifyRequest) GetStatus() DuplicationStatus {
	if !p.IsSetStatus() {
		return DuplicationModifyRequest_Status_DEFAULT
	}
	return *p.Status
}

var DuplicationModifyRequest_FailMode_DEFAULT DuplicationFailMode

func (p *DuplicationModifyRequest) GetFailMode() DuplicationFailMode {
	if !p.IsSetFailMode() {
		return DuplicationModifyRequest_FailMode_DEFAULT
	}
	return *p.FailMode
}
func (p *DuplicationModifyRequest) IsSetStatus() bool {
	return p.Status != nil
}

func (p *DuplicationModifyRequest) IsSetFailMode() bool {
	return p.FailMode != nil
}

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

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

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

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

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

func (p *DuplicationModifyRequest) ReadField4(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 4: ", err)
	} else {
		temp := DuplicationFailMode(v)
		p.FailMode = &temp
	}
	return nil
}

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

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

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

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

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

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

// Attributes:
//  - Err
//  - Appid
type DuplicationModifyResponse struct {
	Err   *base.ErrorCode `thrift:"err,1" db:"err" json:"err"`
	Appid int32           `thrift:"appid,2" db:"appid" json:"appid"`
}

func NewDuplicationModifyResponse() *DuplicationModifyResponse {
	return &DuplicationModifyResponse{}
}

var DuplicationModifyResponse_Err_DEFAULT *base.ErrorCode

func (p *DuplicationModifyResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return DuplicationModifyResponse_Err_DEFAULT
	}
	return p.Err
}

func (p *DuplicationModifyResponse) GetAppid() int32 {
	return p.Appid
}
func (p *DuplicationModifyResponse) IsSetErr() bool {
	return p.Err != nil
}

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

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

func (p *DuplicationModifyResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

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

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

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

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

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

// Attributes:
//  - ConfirmedDecree
//  - LastCommittedDecree
type DuplicationPartitionState struct {
	ConfirmedDecree     int64 `thrift:"confirmed_decree,1" db:"confirmed_decree" json:"confirmed_decree"`
	LastCommittedDecree int64 `thrift:"last_committed_decree,2" db:"last_committed_decree" json:"last_committed_decree"`
}

func NewDuplicationPartitionState() *DuplicationPartitionState {
	return &DuplicationPartitionState{}
}

func (p *DuplicationPartitionState) GetConfirmedDecree() int64 {
	return p.ConfirmedDecree
}

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

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

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

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

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

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

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

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

// Attributes:
//  - Dupid
//  - Status
//  - Remote
//  - CreateTs
//  - Progress
//  - FailMode
//  - RemoteAppName
//  - RemoteReplicaCount
//  - Mode
//  - PartitionStates
type DuplicationEntry struct {
	Dupid    int32             `thrift:"dupid,1" db:"dupid" json:"dupid"`
	Status   DuplicationStatus `thrift:"status,2" db:"status" json:"status"`
	Remote   string            `thrift:"remote,3" db:"remote" json:"remote"`
	CreateTs int64             `thrift:"create_ts,4" db:"create_ts" json:"create_ts"`
	Progress map[int32]int64   `thrift:"progress,5" db:"progress" json:"progress,omitempty"`
	// unused field # 6
	FailMode           *DuplicationFailMode                 `thrift:"fail_mode,7" db:"fail_mode" json:"fail_mode,omitempty"`
	RemoteAppName      *string                              `thrift:"remote_app_name,8" db:"remote_app_name" json:"remote_app_name,omitempty"`
	RemoteReplicaCount *int32                               `thrift:"remote_replica_count,9" db:"remote_replica_count" json:"remote_replica_count,omitempty"`
	Mode               *DuplicationMode                     `thrift:"mode,10" db:"mode" json:"mode,omitempty"`
	PartitionStates    map[int32]*DuplicationPartitionState `thrift:"partition_states,11" db:"partition_states" json:"partition_states,omitempty"`
}

func NewDuplicationEntry() *DuplicationEntry {
	return &DuplicationEntry{}
}

func (p *DuplicationEntry) GetDupid() int32 {
	return p.Dupid
}

func (p *DuplicationEntry) GetStatus() DuplicationStatus {
	return p.Status
}

func (p *DuplicationEntry) GetRemote() string {
	return p.Remote
}

func (p *DuplicationEntry) GetCreateTs() int64 {
	return p.CreateTs
}

var DuplicationEntry_Progress_DEFAULT map[int32]int64

func (p *DuplicationEntry) GetProgress() map[int32]int64 {
	return p.Progress
}

var DuplicationEntry_FailMode_DEFAULT DuplicationFailMode

func (p *DuplicationEntry) GetFailMode() DuplicationFailMode {
	if !p.IsSetFailMode() {
		return DuplicationEntry_FailMode_DEFAULT
	}
	return *p.FailMode
}

var DuplicationEntry_RemoteAppName_DEFAULT string

func (p *DuplicationEntry) GetRemoteAppName() string {
	if !p.IsSetRemoteAppName() {
		return DuplicationEntry_RemoteAppName_DEFAULT
	}
	return *p.RemoteAppName
}

var DuplicationEntry_RemoteReplicaCount_DEFAULT int32

func (p *DuplicationEntry) GetRemoteReplicaCount() int32 {
	if !p.IsSetRemoteReplicaCount() {
		return DuplicationEntry_RemoteReplicaCount_DEFAULT
	}
	return *p.RemoteReplicaCount
}

var DuplicationEntry_Mode_DEFAULT DuplicationMode

func (p *DuplicationEntry) GetMode() DuplicationMode {
	if !p.IsSetMode() {
		return DuplicationEntry_Mode_DEFAULT
	}
	return *p.Mode
}

var DuplicationEntry_PartitionStates_DEFAULT map[int32]*DuplicationPartitionState

func (p *DuplicationEntry) GetPartitionStates() map[int32]*DuplicationPartitionState {
	return p.PartitionStates
}
func (p *DuplicationEntry) IsSetProgress() bool {
	return p.Progress != nil
}

func (p *DuplicationEntry) IsSetFailMode() bool {
	return p.FailMode != nil
}

func (p *DuplicationEntry) IsSetRemoteAppName() bool {
	return p.RemoteAppName != nil
}

func (p *DuplicationEntry) IsSetRemoteReplicaCount() bool {
	return p.RemoteReplicaCount != nil
}

func (p *DuplicationEntry) IsSetMode() bool {
	return p.Mode != nil
}

func (p *DuplicationEntry) IsSetPartitionStates() bool {
	return p.PartitionStates != nil
}

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

	for {
		_, fieldTypeId, fieldId, err := iprot.ReadFieldBegin()
		if err != nil {
			return thrift.PrependError(fmt.Sprintf("%T field %d read error: ", p, fieldId), err)
		}
		if fieldTypeId == thrift.STOP {
			break
		}
		switch fieldId {
		case 1:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField1(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 2:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField2(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 3:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField3(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 4:
			if fieldTypeId == thrift.I64 {
				if err := p.ReadField4(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 5:
			if fieldTypeId == thrift.MAP {
				if err := p.ReadField5(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 7:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField7(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 8:
			if fieldTypeId == thrift.STRING {
				if err := p.ReadField8(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 9:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField9(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 10:
			if fieldTypeId == thrift.I32 {
				if err := p.ReadField10(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		case 11:
			if fieldTypeId == thrift.MAP {
				if err := p.ReadField11(iprot); err != nil {
					return err
				}
			} else {
				if err := iprot.Skip(fieldTypeId); err != nil {
					return err
				}
			}
		default:
			if err := iprot.Skip(fieldTypeId); err != nil {
				return err
			}
		}
		if err := iprot.ReadFieldEnd(); err != nil {
			return err
		}
	}
	if err := iprot.ReadStructEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read struct end error: ", p), err)
	}
	return nil
}

func (p *DuplicationEntry) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.Dupid = v
	}
	return nil
}

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

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

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

func (p *DuplicationEntry) ReadField5(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return thrift.PrependError("error reading map begin: ", err)
	}
	tMap := make(map[int32]int64, size)
	p.Progress = tMap
	for i := 0; i < size; i++ {
		var _key0 int32
		if v, err := iprot.ReadI32(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_key0 = v
		}
		var _val1 int64
		if v, err := iprot.ReadI64(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_val1 = v
		}
		p.Progress[_key0] = _val1
	}
	if err := iprot.ReadMapEnd(); err != nil {
		return thrift.PrependError("error reading map end: ", err)
	}
	return nil
}

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

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

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

func (p *DuplicationEntry) ReadField10(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 10: ", err)
	} else {
		temp := DuplicationMode(v)
		p.Mode = &temp
	}
	return nil
}

func (p *DuplicationEntry) ReadField11(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return thrift.PrependError("error reading map begin: ", err)
	}
	tMap := make(map[int32]*DuplicationPartitionState, size)
	p.PartitionStates = tMap
	for i := 0; i < size; i++ {
		var _key2 int32
		if v, err := iprot.ReadI32(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_key2 = v
		}
		_val3 := &DuplicationPartitionState{}
		if err := _val3.Read(iprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _val3), err)
		}
		p.PartitionStates[_key2] = _val3
	}
	if err := iprot.ReadMapEnd(); err != nil {
		return thrift.PrependError("error reading map end: ", err)
	}
	return nil
}

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

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

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

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

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

func (p *DuplicationEntry) writeField5(oprot thrift.TProtocol) (err error) {
	if p.IsSetProgress() {
		if err := oprot.WriteFieldBegin("progress", thrift.MAP, 5); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 5:progress: ", p), err)
		}
		if err := oprot.WriteMapBegin(thrift.I32, thrift.I64, len(p.Progress)); err != nil {
			return thrift.PrependError("error writing map begin: ", err)
		}
		for k, v := range p.Progress {
			if err := oprot.WriteI32(int32(k)); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
			}
			if err := oprot.WriteI64(int64(v)); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T. (0) field write error: ", p), err)
			}
		}
		if err := oprot.WriteMapEnd(); err != nil {
			return thrift.PrependError("error writing map end: ", err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 5:progress: ", p), err)
		}
	}
	return err
}

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

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

func (p *DuplicationEntry) writeField9(oprot thrift.TProtocol) (err error) {
	if p.IsSetRemoteReplicaCount() {
		if err := oprot.WriteFieldBegin("remote_replica_count", thrift.I32, 9); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 9:remote_replica_count: ", p), err)
		}
		if err := oprot.WriteI32(int32(*p.RemoteReplicaCount)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.remote_replica_count (9) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 9:remote_replica_count: ", p), err)
		}
	}
	return err
}

func (p *DuplicationEntry) writeField10(oprot thrift.TProtocol) (err error) {
	if p.IsSetMode() {
		if err := oprot.WriteFieldBegin("mode", thrift.I32, 10); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 10:mode: ", p), err)
		}
		if err := oprot.WriteI32(int32(*p.Mode)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.mode (10) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 10:mode: ", p), err)
		}
	}
	return err
}

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

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

// Attributes:
//  - Appid
//  - Duplications
//  - AppName
//  - PartitionCount
type DuplicationAppState struct {
	Appid          int32                       `thrift:"appid,1" db:"appid" json:"appid"`
	Duplications   map[int32]*DuplicationEntry `thrift:"duplications,2" db:"duplications" json:"duplications"`
	AppName        string                      `thrift:"app_name,3" db:"app_name" json:"app_name"`
	PartitionCount int32                       `thrift:"partition_count,4" db:"partition_count" json:"partition_count"`
}

func NewDuplicationAppState() *DuplicationAppState {
	return &DuplicationAppState{}
}

func (p *DuplicationAppState) GetAppid() int32 {
	return p.Appid
}

func (p *DuplicationAppState) GetDuplications() map[int32]*DuplicationEntry {
	return p.Duplications
}

func (p *DuplicationAppState) GetAppName() string {
	return p.AppName
}

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

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

func (p *DuplicationAppState) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.Appid = v
	}
	return nil
}

func (p *DuplicationAppState) ReadField2(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return thrift.PrependError("error reading map begin: ", err)
	}
	tMap := make(map[int32]*DuplicationEntry, size)
	p.Duplications = tMap
	for i := 0; i < size; i++ {
		var _key4 int32
		if v, err := iprot.ReadI32(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_key4 = v
		}
		_val5 := &DuplicationEntry{}
		if err := _val5.Read(iprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _val5), err)
		}
		p.Duplications[_key4] = _val5
	}
	if err := iprot.ReadMapEnd(); err != nil {
		return thrift.PrependError("error reading map end: ", err)
	}
	return nil
}

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

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

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

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

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

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

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

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

// Attributes:
//  - AppName
type DuplicationQueryRequest struct {
	AppName string `thrift:"app_name,1" db:"app_name" json:"app_name"`
}

func NewDuplicationQueryRequest() *DuplicationQueryRequest {
	return &DuplicationQueryRequest{}
}

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

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

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

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

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

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

// Attributes:
//  - Err
//  - Appid
//  - EntryList
type DuplicationQueryResponse struct {
	Err *base.ErrorCode `thrift:"err,1" db:"err" json:"err"`
	// unused field # 2
	Appid     int32               `thrift:"appid,3" db:"appid" json:"appid"`
	EntryList []*DuplicationEntry `thrift:"entry_list,4" db:"entry_list" json:"entry_list"`
}

func NewDuplicationQueryResponse() *DuplicationQueryResponse {
	return &DuplicationQueryResponse{}
}

var DuplicationQueryResponse_Err_DEFAULT *base.ErrorCode

func (p *DuplicationQueryResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return DuplicationQueryResponse_Err_DEFAULT
	}
	return p.Err
}

func (p *DuplicationQueryResponse) GetAppid() int32 {
	return p.Appid
}

func (p *DuplicationQueryResponse) GetEntryList() []*DuplicationEntry {
	return p.EntryList
}
func (p *DuplicationQueryResponse) IsSetErr() bool {
	return p.Err != nil
}

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

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

func (p *DuplicationQueryResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

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

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

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

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

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

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

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

// Attributes:
//  - Dupid
//  - ConfirmedDecree
//  - CheckpointPrepared
//  - LastCommittedDecree
type DuplicationConfirmEntry struct {
	Dupid               int32  `thrift:"dupid,1" db:"dupid" json:"dupid"`
	ConfirmedDecree     int64  `thrift:"confirmed_decree,2" db:"confirmed_decree" json:"confirmed_decree"`
	CheckpointPrepared  bool   `thrift:"checkpoint_prepared,3" db:"checkpoint_prepared" json:"checkpoint_prepared"`
	LastCommittedDecree *int64 `thrift:"last_committed_decree,4" db:"last_committed_decree" json:"last_committed_decree,omitempty"`
}

func NewDuplicationConfirmEntry() *DuplicationConfirmEntry {
	return &DuplicationConfirmEntry{}
}

func (p *DuplicationConfirmEntry) GetDupid() int32 {
	return p.Dupid
}

func (p *DuplicationConfirmEntry) GetConfirmedDecree() int64 {
	return p.ConfirmedDecree
}

var DuplicationConfirmEntry_CheckpointPrepared_DEFAULT bool = false

func (p *DuplicationConfirmEntry) GetCheckpointPrepared() bool {
	return p.CheckpointPrepared
}

var DuplicationConfirmEntry_LastCommittedDecree_DEFAULT int64

func (p *DuplicationConfirmEntry) GetLastCommittedDecree() int64 {
	if !p.IsSetLastCommittedDecree() {
		return DuplicationConfirmEntry_LastCommittedDecree_DEFAULT
	}
	return *p.LastCommittedDecree
}
func (p *DuplicationConfirmEntry) IsSetCheckpointPrepared() bool {
	return p.CheckpointPrepared != DuplicationConfirmEntry_CheckpointPrepared_DEFAULT
}

func (p *DuplicationConfirmEntry) IsSetLastCommittedDecree() bool {
	return p.LastCommittedDecree != nil
}

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

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

func (p *DuplicationConfirmEntry) ReadField1(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 1: ", err)
	} else {
		p.Dupid = v
	}
	return nil
}

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

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

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

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

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

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

func (p *DuplicationConfirmEntry) writeField3(oprot thrift.TProtocol) (err error) {
	if p.IsSetCheckpointPrepared() {
		if err := oprot.WriteFieldBegin("checkpoint_prepared", thrift.BOOL, 3); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:checkpoint_prepared: ", p), err)
		}
		if err := oprot.WriteBool(bool(p.CheckpointPrepared)); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T.checkpoint_prepared (3) field write error: ", p), err)
		}
		if err := oprot.WriteFieldEnd(); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T write field end error 3:checkpoint_prepared: ", p), err)
		}
	}
	return err
}

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

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

// Attributes:
//  - Node
//  - ConfirmList
//  - HpNode
type DuplicationSyncRequest struct {
	Node        *base.RPCAddress                          `thrift:"node,1" db:"node" json:"node"`
	ConfirmList map[*base.Gpid][]*DuplicationConfirmEntry `thrift:"confirm_list,2" db:"confirm_list" json:"confirm_list"`
	HpNode      *base.HostPort                            `thrift:"hp_node,3" db:"hp_node" json:"hp_node"`
}

func NewDuplicationSyncRequest() *DuplicationSyncRequest {
	return &DuplicationSyncRequest{}
}

var DuplicationSyncRequest_Node_DEFAULT *base.RPCAddress

func (p *DuplicationSyncRequest) GetNode() *base.RPCAddress {
	if !p.IsSetNode() {
		return DuplicationSyncRequest_Node_DEFAULT
	}
	return p.Node
}

func (p *DuplicationSyncRequest) GetConfirmList() map[*base.Gpid][]*DuplicationConfirmEntry {
	return p.ConfirmList
}

var DuplicationSyncRequest_HpNode_DEFAULT *base.HostPort

func (p *DuplicationSyncRequest) GetHpNode() *base.HostPort {
	if !p.IsSetHpNode() {
		return DuplicationSyncRequest_HpNode_DEFAULT
	}
	return p.HpNode
}
func (p *DuplicationSyncRequest) IsSetNode() bool {
	return p.Node != nil
}

func (p *DuplicationSyncRequest) IsSetHpNode() bool {
	return p.HpNode != nil
}

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

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

func (p *DuplicationSyncRequest) ReadField1(iprot thrift.TProtocol) error {
	p.Node = &base.RPCAddress{}
	if err := p.Node.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Node), err)
	}
	return nil
}

func (p *DuplicationSyncRequest) ReadField2(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return thrift.PrependError("error reading map begin: ", err)
	}
	tMap := make(map[*base.Gpid][]*DuplicationConfirmEntry, size)
	p.ConfirmList = tMap
	for i := 0; i < size; i++ {
		_key7 := &base.Gpid{}
		if err := _key7.Read(iprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _key7), err)
		}
		_, size, err := iprot.ReadListBegin()
		if err != nil {
			return thrift.PrependError("error reading list begin: ", err)
		}
		tSlice := make([]*DuplicationConfirmEntry, 0, size)
		_val8 := tSlice
		for i := 0; i < size; i++ {
			_elem9 := &DuplicationConfirmEntry{}
			if err := _elem9.Read(iprot); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _elem9), err)
			}
			_val8 = append(_val8, _elem9)
		}
		if err := iprot.ReadListEnd(); err != nil {
			return thrift.PrependError("error reading list end: ", err)
		}
		p.ConfirmList[_key7] = _val8
	}
	if err := iprot.ReadMapEnd(); err != nil {
		return thrift.PrependError("error reading map end: ", err)
	}
	return nil
}

func (p *DuplicationSyncRequest) ReadField3(iprot thrift.TProtocol) error {
	p.HpNode = &base.HostPort{}
	if err := p.HpNode.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.HpNode), err)
	}
	return nil
}

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

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

func (p *DuplicationSyncRequest) writeField2(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("confirm_list", thrift.MAP, 2); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 2:confirm_list: ", p), err)
	}
	if err := oprot.WriteMapBegin(thrift.STRUCT, thrift.LIST, len(p.ConfirmList)); err != nil {
		return thrift.PrependError("error writing map begin: ", err)
	}
	for k, v := range p.ConfirmList {
		if err := k.Write(oprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", k), err)
		}
		if err := oprot.WriteListBegin(thrift.STRUCT, len(v)); err != nil {
			return thrift.PrependError("error writing list begin: ", err)
		}
		for _, v := range v {
			if err := v.Write(oprot); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", v), err)
			}
		}
		if err := oprot.WriteListEnd(); err != nil {
			return thrift.PrependError("error writing list end: ", err)
		}
	}
	if err := oprot.WriteMapEnd(); err != nil {
		return thrift.PrependError("error writing map end: ", err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 2:confirm_list: ", p), err)
	}
	return err
}

func (p *DuplicationSyncRequest) writeField3(oprot thrift.TProtocol) (err error) {
	if err := oprot.WriteFieldBegin("hp_node", thrift.STRUCT, 3); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field begin error 3:hp_node: ", p), err)
	}
	if err := p.HpNode.Write(oprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error writing struct: ", p.HpNode), err)
	}
	if err := oprot.WriteFieldEnd(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T write field end error 3:hp_node: ", p), err)
	}
	return err
}

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

// Attributes:
//  - Err
//  - DupMap
type DuplicationSyncResponse struct {
	Err    *base.ErrorCode                       `thrift:"err,1" db:"err" json:"err"`
	DupMap map[int32]map[int32]*DuplicationEntry `thrift:"dup_map,2" db:"dup_map" json:"dup_map"`
}

func NewDuplicationSyncResponse() *DuplicationSyncResponse {
	return &DuplicationSyncResponse{}
}

var DuplicationSyncResponse_Err_DEFAULT *base.ErrorCode

func (p *DuplicationSyncResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return DuplicationSyncResponse_Err_DEFAULT
	}
	return p.Err
}

func (p *DuplicationSyncResponse) GetDupMap() map[int32]map[int32]*DuplicationEntry {
	return p.DupMap
}
func (p *DuplicationSyncResponse) IsSetErr() bool {
	return p.Err != nil
}

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

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

func (p *DuplicationSyncResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

func (p *DuplicationSyncResponse) ReadField2(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return thrift.PrependError("error reading map begin: ", err)
	}
	tMap := make(map[int32]map[int32]*DuplicationEntry, size)
	p.DupMap = tMap
	for i := 0; i < size; i++ {
		var _key10 int32
		if v, err := iprot.ReadI32(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_key10 = v
		}
		_, _, size, err := iprot.ReadMapBegin()
		if err != nil {
			return thrift.PrependError("error reading map begin: ", err)
		}
		tMap := make(map[int32]*DuplicationEntry, size)
		_val11 := tMap
		for i := 0; i < size; i++ {
			var _key12 int32
			if v, err := iprot.ReadI32(); err != nil {
				return thrift.PrependError("error reading field 0: ", err)
			} else {
				_key12 = v
			}
			_val13 := &DuplicationEntry{}
			if err := _val13.Read(iprot); err != nil {
				return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _val13), err)
			}
			_val11[_key12] = _val13
		}
		if err := iprot.ReadMapEnd(); err != nil {
			return thrift.PrependError("error reading map end: ", err)
		}
		p.DupMap[_key10] = _val11
	}
	if err := iprot.ReadMapEnd(); err != nil {
		return thrift.PrependError("error reading map end: ", err)
	}
	return nil
}

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

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

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

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

// Attributes:
//  - AppNamePattern
//  - MatchType
type DuplicationListRequest struct {
	AppNamePattern string                 `thrift:"app_name_pattern,1" db:"app_name_pattern" json:"app_name_pattern"`
	MatchType      utils.PatternMatchType `thrift:"match_type,2" db:"match_type" json:"match_type"`
}

func NewDuplicationListRequest() *DuplicationListRequest {
	return &DuplicationListRequest{}
}

func (p *DuplicationListRequest) GetAppNamePattern() string {
	return p.AppNamePattern
}

func (p *DuplicationListRequest) GetMatchType() utils.PatternMatchType {
	return p.MatchType
}
func (p *DuplicationListRequest) Read(iprot thrift.TProtocol) error {
	if _, err := iprot.ReadStructBegin(); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T read error: ", p), err)
	}

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

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

func (p *DuplicationListRequest) ReadField2(iprot thrift.TProtocol) error {
	if v, err := iprot.ReadI32(); err != nil {
		return thrift.PrependError("error reading field 2: ", err)
	} else {
		temp := utils.PatternMatchType(v)
		p.MatchType = temp
	}
	return nil
}

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

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

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

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

// Attributes:
//  - Err
//  - HintMessage
//  - AppStates
type DuplicationListResponse struct {
	Err         *base.ErrorCode                 `thrift:"err,1" db:"err" json:"err"`
	HintMessage string                          `thrift:"hint_message,2" db:"hint_message" json:"hint_message"`
	AppStates   map[string]*DuplicationAppState `thrift:"app_states,3" db:"app_states" json:"app_states"`
}

func NewDuplicationListResponse() *DuplicationListResponse {
	return &DuplicationListResponse{}
}

var DuplicationListResponse_Err_DEFAULT *base.ErrorCode

func (p *DuplicationListResponse) GetErr() *base.ErrorCode {
	if !p.IsSetErr() {
		return DuplicationListResponse_Err_DEFAULT
	}
	return p.Err
}

func (p *DuplicationListResponse) GetHintMessage() string {
	return p.HintMessage
}

func (p *DuplicationListResponse) GetAppStates() map[string]*DuplicationAppState {
	return p.AppStates
}
func (p *DuplicationListResponse) IsSetErr() bool {
	return p.Err != nil
}

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

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

func (p *DuplicationListResponse) ReadField1(iprot thrift.TProtocol) error {
	p.Err = &base.ErrorCode{}
	if err := p.Err.Read(iprot); err != nil {
		return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", p.Err), err)
	}
	return nil
}

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

func (p *DuplicationListResponse) ReadField3(iprot thrift.TProtocol) error {
	_, _, size, err := iprot.ReadMapBegin()
	if err != nil {
		return thrift.PrependError("error reading map begin: ", err)
	}
	tMap := make(map[string]*DuplicationAppState, size)
	p.AppStates = tMap
	for i := 0; i < size; i++ {
		var _key14 string
		if v, err := iprot.ReadString(); err != nil {
			return thrift.PrependError("error reading field 0: ", err)
		} else {
			_key14 = v
		}
		_val15 := &DuplicationAppState{}
		if err := _val15.Read(iprot); err != nil {
			return thrift.PrependError(fmt.Sprintf("%T error reading struct: ", _val15), err)
		}
		p.AppStates[_key14] = _val15
	}
	if err := iprot.ReadMapEnd(); err != nil {
		return thrift.PrependError("error reading map end: ", err)
	}
	return nil
}

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

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

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

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

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