Documentation

Index

Constants

This section is empty.

Variables

View Source
var Cache_ClearAfter_Helper = struct {
	// Args accepts the parameters of clearAfter in-order and returns
	// the arguments struct for the function.
	Args func(
		durationMS *int64,
	) *Cache_ClearAfter_Args
}{}

    Cache_ClearAfter_Helper provides functions that aid in handling the parameters and return values of the Cache.clearAfter function.

    View Source
    var Cache_Clear_Helper = struct {
    	// Args accepts the parameters of clear in-order and returns
    	// the arguments struct for the function.
    	Args func() *Cache_Clear_Args
    }{}

      Cache_Clear_Helper provides functions that aid in handling the parameters and return values of the Cache.clear function.

      View Source
      var ConflictingNames_SetValue_Helper = struct {
      	// Args accepts the parameters of setValue in-order and returns
      	// the arguments struct for the function.
      	Args func(
      		request *ConflictingNamesSetValueArgs,
      	) *ConflictingNames_SetValue_Args
      
      	// IsException returns true if the given error can be thrown
      	// by setValue.
      	//
      	// An error can be thrown by setValue only if the
      	// corresponding exception type was mentioned in the 'throws'
      	// section for it in the Thrift file.
      	IsException func(error) bool
      
      	// WrapResponse returns the result struct for setValue
      	// given the error returned by it. The provided error may
      	// be nil if setValue did not fail.
      	//
      	// This allows mapping errors returned by setValue into a
      	// serializable result struct. WrapResponse returns a
      	// non-nil error if the provided error cannot be thrown by
      	// setValue
      	//
      	//   err := setValue(args)
      	//   result, err := ConflictingNames_SetValue_Helper.WrapResponse(err)
      	//   if err != nil {
      	//     return fmt.Errorf("unexpected error from setValue: %v", err)
      	//   }
      	//   serialize(result)
      	WrapResponse func(error) (*ConflictingNames_SetValue_Result, error)
      
      	// UnwrapResponse takes the result struct for setValue
      	// and returns the erorr returned by it (if any).
      	//
      	// The error is non-nil only if setValue threw an
      	// exception.
      	//
      	//   result := deserialize(bytes)
      	//   err := ConflictingNames_SetValue_Helper.UnwrapResponse(result)
      	UnwrapResponse func(*ConflictingNames_SetValue_Result) error
      }{}

        ConflictingNames_SetValue_Helper provides functions that aid in handling the parameters and return values of the ConflictingNames.setValue function.

        View Source
        var KeyValue_DeleteValue_Helper = struct {
        	// Args accepts the parameters of deleteValue in-order and returns
        	// the arguments struct for the function.
        	Args func(
        		key *Key,
        	) *KeyValue_DeleteValue_Args
        
        	// IsException returns true if the given error can be thrown
        	// by deleteValue.
        	//
        	// An error can be thrown by deleteValue only if the
        	// corresponding exception type was mentioned in the 'throws'
        	// section for it in the Thrift file.
        	IsException func(error) bool
        
        	// WrapResponse returns the result struct for deleteValue
        	// given the error returned by it. The provided error may
        	// be nil if deleteValue did not fail.
        	//
        	// This allows mapping errors returned by deleteValue into a
        	// serializable result struct. WrapResponse returns a
        	// non-nil error if the provided error cannot be thrown by
        	// deleteValue
        	//
        	//   err := deleteValue(args)
        	//   result, err := KeyValue_DeleteValue_Helper.WrapResponse(err)
        	//   if err != nil {
        	//     return fmt.Errorf("unexpected error from deleteValue: %v", err)
        	//   }
        	//   serialize(result)
        	WrapResponse func(error) (*KeyValue_DeleteValue_Result, error)
        
        	// UnwrapResponse takes the result struct for deleteValue
        	// and returns the erorr returned by it (if any).
        	//
        	// The error is non-nil only if deleteValue threw an
        	// exception.
        	//
        	//   result := deserialize(bytes)
        	//   err := KeyValue_DeleteValue_Helper.UnwrapResponse(result)
        	UnwrapResponse func(*KeyValue_DeleteValue_Result) error
        }{}

          KeyValue_DeleteValue_Helper provides functions that aid in handling the parameters and return values of the KeyValue.deleteValue function.

          View Source
          var KeyValue_GetManyValues_Helper = struct {
          	// Args accepts the parameters of getManyValues in-order and returns
          	// the arguments struct for the function.
          	Args func(
          		range2 []Key,
          	) *KeyValue_GetManyValues_Args
          
          	// IsException returns true if the given error can be thrown
          	// by getManyValues.
          	//
          	// An error can be thrown by getManyValues only if the
          	// corresponding exception type was mentioned in the 'throws'
          	// section for it in the Thrift file.
          	IsException func(error) bool
          
          	// WrapResponse returns the result struct for getManyValues
          	// given its return value and error.
          	//
          	// This allows mapping values and errors returned by
          	// getManyValues into a serializable result struct.
          	// WrapResponse returns a non-nil error if the provided
          	// error cannot be thrown by getManyValues
          	//
          	//   value, err := getManyValues(args)
          	//   result, err := KeyValue_GetManyValues_Helper.WrapResponse(value, err)
          	//   if err != nil {
          	//     return fmt.Errorf("unexpected error from getManyValues: %v", err)
          	//   }
          	//   serialize(result)
          	WrapResponse func([]*unions.ArbitraryValue, error) (*KeyValue_GetManyValues_Result, error)
          
          	// UnwrapResponse takes the result struct for getManyValues
          	// and returns the value or error returned by it.
          	//
          	// The error is non-nil only if getManyValues threw an
          	// exception.
          	//
          	//   result := deserialize(bytes)
          	//   value, err := KeyValue_GetManyValues_Helper.UnwrapResponse(result)
          	UnwrapResponse func(*KeyValue_GetManyValues_Result) ([]*unions.ArbitraryValue, error)
          }{}

            KeyValue_GetManyValues_Helper provides functions that aid in handling the parameters and return values of the KeyValue.getManyValues function.

            View Source
            var KeyValue_GetValue_Helper = struct {
            	// Args accepts the parameters of getValue in-order and returns
            	// the arguments struct for the function.
            	Args func(
            		key *Key,
            	) *KeyValue_GetValue_Args
            
            	// IsException returns true if the given error can be thrown
            	// by getValue.
            	//
            	// An error can be thrown by getValue only if the
            	// corresponding exception type was mentioned in the 'throws'
            	// section for it in the Thrift file.
            	IsException func(error) bool
            
            	// WrapResponse returns the result struct for getValue
            	// given its return value and error.
            	//
            	// This allows mapping values and errors returned by
            	// getValue into a serializable result struct.
            	// WrapResponse returns a non-nil error if the provided
            	// error cannot be thrown by getValue
            	//
            	//   value, err := getValue(args)
            	//   result, err := KeyValue_GetValue_Helper.WrapResponse(value, err)
            	//   if err != nil {
            	//     return fmt.Errorf("unexpected error from getValue: %v", err)
            	//   }
            	//   serialize(result)
            	WrapResponse func(*unions.ArbitraryValue, error) (*KeyValue_GetValue_Result, error)
            
            	// UnwrapResponse takes the result struct for getValue
            	// and returns the value or error returned by it.
            	//
            	// The error is non-nil only if getValue threw an
            	// exception.
            	//
            	//   result := deserialize(bytes)
            	//   value, err := KeyValue_GetValue_Helper.UnwrapResponse(result)
            	UnwrapResponse func(*KeyValue_GetValue_Result) (*unions.ArbitraryValue, error)
            }{}

              KeyValue_GetValue_Helper provides functions that aid in handling the parameters and return values of the KeyValue.getValue function.

              View Source
              var KeyValue_SetValueV2_Helper = struct {
              	// Args accepts the parameters of setValueV2 in-order and returns
              	// the arguments struct for the function.
              	Args func(
              		key Key,
              		value *unions.ArbitraryValue,
              	) *KeyValue_SetValueV2_Args
              
              	// IsException returns true if the given error can be thrown
              	// by setValueV2.
              	//
              	// An error can be thrown by setValueV2 only if the
              	// corresponding exception type was mentioned in the 'throws'
              	// section for it in the Thrift file.
              	IsException func(error) bool
              
              	// WrapResponse returns the result struct for setValueV2
              	// given the error returned by it. The provided error may
              	// be nil if setValueV2 did not fail.
              	//
              	// This allows mapping errors returned by setValueV2 into a
              	// serializable result struct. WrapResponse returns a
              	// non-nil error if the provided error cannot be thrown by
              	// setValueV2
              	//
              	//   err := setValueV2(args)
              	//   result, err := KeyValue_SetValueV2_Helper.WrapResponse(err)
              	//   if err != nil {
              	//     return fmt.Errorf("unexpected error from setValueV2: %v", err)
              	//   }
              	//   serialize(result)
              	WrapResponse func(error) (*KeyValue_SetValueV2_Result, error)
              
              	// UnwrapResponse takes the result struct for setValueV2
              	// and returns the erorr returned by it (if any).
              	//
              	// The error is non-nil only if setValueV2 threw an
              	// exception.
              	//
              	//   result := deserialize(bytes)
              	//   err := KeyValue_SetValueV2_Helper.UnwrapResponse(result)
              	UnwrapResponse func(*KeyValue_SetValueV2_Result) error
              }{}

                KeyValue_SetValueV2_Helper provides functions that aid in handling the parameters and return values of the KeyValue.setValueV2 function.

                View Source
                var KeyValue_SetValue_Helper = struct {
                	// Args accepts the parameters of setValue in-order and returns
                	// the arguments struct for the function.
                	Args func(
                		key *Key,
                		value *unions.ArbitraryValue,
                	) *KeyValue_SetValue_Args
                
                	// IsException returns true if the given error can be thrown
                	// by setValue.
                	//
                	// An error can be thrown by setValue only if the
                	// corresponding exception type was mentioned in the 'throws'
                	// section for it in the Thrift file.
                	IsException func(error) bool
                
                	// WrapResponse returns the result struct for setValue
                	// given the error returned by it. The provided error may
                	// be nil if setValue did not fail.
                	//
                	// This allows mapping errors returned by setValue into a
                	// serializable result struct. WrapResponse returns a
                	// non-nil error if the provided error cannot be thrown by
                	// setValue
                	//
                	//   err := setValue(args)
                	//   result, err := KeyValue_SetValue_Helper.WrapResponse(err)
                	//   if err != nil {
                	//     return fmt.Errorf("unexpected error from setValue: %v", err)
                	//   }
                	//   serialize(result)
                	WrapResponse func(error) (*KeyValue_SetValue_Result, error)
                
                	// UnwrapResponse takes the result struct for setValue
                	// and returns the erorr returned by it (if any).
                	//
                	// The error is non-nil only if setValue threw an
                	// exception.
                	//
                	//   result := deserialize(bytes)
                	//   err := KeyValue_SetValue_Helper.UnwrapResponse(result)
                	UnwrapResponse func(*KeyValue_SetValue_Result) error
                }{}

                  KeyValue_SetValue_Helper provides functions that aid in handling the parameters and return values of the KeyValue.setValue function.

                  View Source
                  var KeyValue_Size_Helper = struct {
                  	// Args accepts the parameters of size in-order and returns
                  	// the arguments struct for the function.
                  	Args func() *KeyValue_Size_Args
                  
                  	// IsException returns true if the given error can be thrown
                  	// by size.
                  	//
                  	// An error can be thrown by size only if the
                  	// corresponding exception type was mentioned in the 'throws'
                  	// section for it in the Thrift file.
                  	IsException func(error) bool
                  
                  	// WrapResponse returns the result struct for size
                  	// given its return value and error.
                  	//
                  	// This allows mapping values and errors returned by
                  	// size into a serializable result struct.
                  	// WrapResponse returns a non-nil error if the provided
                  	// error cannot be thrown by size
                  	//
                  	//   value, err := size(args)
                  	//   result, err := KeyValue_Size_Helper.WrapResponse(value, err)
                  	//   if err != nil {
                  	//     return fmt.Errorf("unexpected error from size: %v", err)
                  	//   }
                  	//   serialize(result)
                  	WrapResponse func(int64, error) (*KeyValue_Size_Result, error)
                  
                  	// UnwrapResponse takes the result struct for size
                  	// and returns the value or error returned by it.
                  	//
                  	// The error is non-nil only if size threw an
                  	// exception.
                  	//
                  	//   result := deserialize(bytes)
                  	//   value, err := KeyValue_Size_Helper.UnwrapResponse(result)
                  	UnwrapResponse func(*KeyValue_Size_Result) (int64, error)
                  }{}

                    KeyValue_Size_Helper provides functions that aid in handling the parameters and return values of the KeyValue.size function.

                    View Source
                    var NonStandardServiceName_NonStandardFunctionName_Helper = struct {
                    	// Args accepts the parameters of non_standard_function_name in-order and returns
                    	// the arguments struct for the function.
                    	Args func() *NonStandardServiceName_NonStandardFunctionName_Args
                    
                    	// IsException returns true if the given error can be thrown
                    	// by non_standard_function_name.
                    	//
                    	// An error can be thrown by non_standard_function_name only if the
                    	// corresponding exception type was mentioned in the 'throws'
                    	// section for it in the Thrift file.
                    	IsException func(error) bool
                    
                    	// WrapResponse returns the result struct for non_standard_function_name
                    	// given the error returned by it. The provided error may
                    	// be nil if non_standard_function_name did not fail.
                    	//
                    	// This allows mapping errors returned by non_standard_function_name into a
                    	// serializable result struct. WrapResponse returns a
                    	// non-nil error if the provided error cannot be thrown by
                    	// non_standard_function_name
                    	//
                    	//   err := non_standard_function_name(args)
                    	//   result, err := NonStandardServiceName_NonStandardFunctionName_Helper.WrapResponse(err)
                    	//   if err != nil {
                    	//     return fmt.Errorf("unexpected error from non_standard_function_name: %v", err)
                    	//   }
                    	//   serialize(result)
                    	WrapResponse func(error) (*NonStandardServiceName_NonStandardFunctionName_Result, error)
                    
                    	// UnwrapResponse takes the result struct for non_standard_function_name
                    	// and returns the erorr returned by it (if any).
                    	//
                    	// The error is non-nil only if non_standard_function_name threw an
                    	// exception.
                    	//
                    	//   result := deserialize(bytes)
                    	//   err := NonStandardServiceName_NonStandardFunctionName_Helper.UnwrapResponse(result)
                    	UnwrapResponse func(*NonStandardServiceName_NonStandardFunctionName_Result) error
                    }{}

                      NonStandardServiceName_NonStandardFunctionName_Helper provides functions that aid in handling the parameters and return values of the non_standard_service_name.non_standard_function_name function.

                      View Source
                      var ThriftModule = &thriftreflect.ThriftModule{
                      	Name:     "services",
                      	Package:  "go.uber.org/thriftrw/gen/internal/tests/services",
                      	FilePath: "services.thrift",
                      	SHA1:     "22d2183c133fb327925d7288a6191b17e8f28175",
                      	Includes: []*thriftreflect.ThriftModule{
                      		exceptions.ThriftModule,
                      		unions.ThriftModule,
                      	},
                      	Raw: rawIDL,
                      }

                        ThriftModule represents the IDL file used to generate this package.

                        Functions

                        This section is empty.

                        Types

                        type Cache_ClearAfter_Args

                        type Cache_ClearAfter_Args struct {
                        	DurationMS *int64 `json:"durationMS,omitempty"`
                        }

                          Cache_ClearAfter_Args represents the arguments for the Cache.clearAfter function.

                          The arguments for clearAfter are sent and received over the wire as this struct.

                          func (*Cache_ClearAfter_Args) EnvelopeType

                          func (v *Cache_ClearAfter_Args) EnvelopeType() wire.EnvelopeType

                            EnvelopeType returns the kind of value inside this struct.

                            This will always be OneWay for this struct.

                            func (*Cache_ClearAfter_Args) Equals

                              Equals returns true if all the fields of this Cache_ClearAfter_Args match the provided Cache_ClearAfter_Args.

                              This function performs a deep comparison.

                              func (*Cache_ClearAfter_Args) FromWire

                              func (v *Cache_ClearAfter_Args) FromWire(w wire.Value) error

                                FromWire deserializes a Cache_ClearAfter_Args struct from its Thrift-level representation. The Thrift-level representation may be obtained from a ThriftRW protocol implementation.

                                An error is returned if we were unable to build a Cache_ClearAfter_Args struct from the provided intermediate representation.

                                x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                if err != nil {
                                  return nil, err
                                }
                                
                                var v Cache_ClearAfter_Args
                                if err := v.FromWire(x); err != nil {
                                  return nil, err
                                }
                                return &v, nil
                                

                                func (*Cache_ClearAfter_Args) GetDurationMS

                                func (v *Cache_ClearAfter_Args) GetDurationMS() (o int64)

                                  GetDurationMS returns the value of DurationMS if it is set or its zero value if it is unset.

                                  func (*Cache_ClearAfter_Args) IsSetDurationMS

                                  func (v *Cache_ClearAfter_Args) IsSetDurationMS() bool

                                    IsSetDurationMS returns true if DurationMS is not nil.

                                    func (*Cache_ClearAfter_Args) MarshalLogObject

                                    func (v *Cache_ClearAfter_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

                                      MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of Cache_ClearAfter_Args.

                                      func (*Cache_ClearAfter_Args) MethodName

                                      func (v *Cache_ClearAfter_Args) MethodName() string

                                        MethodName returns the name of the Thrift function as specified in the IDL, for which this struct represent the arguments.

                                        This will always be "clearAfter" for this struct.

                                        func (*Cache_ClearAfter_Args) String

                                        func (v *Cache_ClearAfter_Args) String() string

                                          String returns a readable string representation of a Cache_ClearAfter_Args struct.

                                          func (*Cache_ClearAfter_Args) ToWire

                                          func (v *Cache_ClearAfter_Args) ToWire() (wire.Value, error)

                                            ToWire translates a Cache_ClearAfter_Args struct into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

                                            An error is returned if the struct or any of its fields failed to validate.

                                            x, err := v.ToWire()
                                            if err != nil {
                                              return err
                                            }
                                            
                                            if err := binaryProtocol.Encode(x, writer); err != nil {
                                              return err
                                            }
                                            

                                            type Cache_Clear_Args

                                            type Cache_Clear_Args struct {
                                            }

                                              Cache_Clear_Args represents the arguments for the Cache.clear function.

                                              The arguments for clear are sent and received over the wire as this struct.

                                              func (*Cache_Clear_Args) EnvelopeType

                                              func (v *Cache_Clear_Args) EnvelopeType() wire.EnvelopeType

                                                EnvelopeType returns the kind of value inside this struct.

                                                This will always be OneWay for this struct.

                                                func (*Cache_Clear_Args) Equals

                                                func (v *Cache_Clear_Args) Equals(rhs *Cache_Clear_Args) bool

                                                  Equals returns true if all the fields of this Cache_Clear_Args match the provided Cache_Clear_Args.

                                                  This function performs a deep comparison.

                                                  func (*Cache_Clear_Args) FromWire

                                                  func (v *Cache_Clear_Args) FromWire(w wire.Value) error

                                                    FromWire deserializes a Cache_Clear_Args struct from its Thrift-level representation. The Thrift-level representation may be obtained from a ThriftRW protocol implementation.

                                                    An error is returned if we were unable to build a Cache_Clear_Args struct from the provided intermediate representation.

                                                    x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                    if err != nil {
                                                      return nil, err
                                                    }
                                                    
                                                    var v Cache_Clear_Args
                                                    if err := v.FromWire(x); err != nil {
                                                      return nil, err
                                                    }
                                                    return &v, nil
                                                    

                                                    func (*Cache_Clear_Args) MarshalLogObject

                                                    func (v *Cache_Clear_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

                                                      MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of Cache_Clear_Args.

                                                      func (*Cache_Clear_Args) MethodName

                                                      func (v *Cache_Clear_Args) MethodName() string

                                                        MethodName returns the name of the Thrift function as specified in the IDL, for which this struct represent the arguments.

                                                        This will always be "clear" for this struct.

                                                        func (*Cache_Clear_Args) String

                                                        func (v *Cache_Clear_Args) String() string

                                                          String returns a readable string representation of a Cache_Clear_Args struct.

                                                          func (*Cache_Clear_Args) ToWire

                                                          func (v *Cache_Clear_Args) ToWire() (wire.Value, error)

                                                            ToWire translates a Cache_Clear_Args struct into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

                                                            An error is returned if the struct or any of its fields failed to validate.

                                                            x, err := v.ToWire()
                                                            if err != nil {
                                                              return err
                                                            }
                                                            
                                                            if err := binaryProtocol.Encode(x, writer); err != nil {
                                                              return err
                                                            }
                                                            

                                                            type ConflictingNamesSetValueArgs

                                                            type ConflictingNamesSetValueArgs struct {
                                                            	Key   string `json:"key,required"`
                                                            	Value []byte `json:"value,required"`
                                                            }

                                                            func (*ConflictingNamesSetValueArgs) Equals

                                                              Equals returns true if all the fields of this ConflictingNamesSetValueArgs match the provided ConflictingNamesSetValueArgs.

                                                              This function performs a deep comparison.

                                                              func (*ConflictingNamesSetValueArgs) FromWire

                                                                FromWire deserializes a ConflictingNamesSetValueArgs struct from its Thrift-level representation. The Thrift-level representation may be obtained from a ThriftRW protocol implementation.

                                                                An error is returned if we were unable to build a ConflictingNamesSetValueArgs struct from the provided intermediate representation.

                                                                x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                if err != nil {
                                                                  return nil, err
                                                                }
                                                                
                                                                var v ConflictingNamesSetValueArgs
                                                                if err := v.FromWire(x); err != nil {
                                                                  return nil, err
                                                                }
                                                                return &v, nil
                                                                

                                                                func (*ConflictingNamesSetValueArgs) GetKey

                                                                func (v *ConflictingNamesSetValueArgs) GetKey() (o string)

                                                                  GetKey returns the value of Key if it is set or its zero value if it is unset.

                                                                  func (*ConflictingNamesSetValueArgs) GetValue

                                                                  func (v *ConflictingNamesSetValueArgs) GetValue() (o []byte)

                                                                    GetValue returns the value of Value if it is set or its zero value if it is unset.

                                                                    func (*ConflictingNamesSetValueArgs) IsSetValue

                                                                    func (v *ConflictingNamesSetValueArgs) IsSetValue() bool

                                                                      IsSetValue returns true if Value is not nil.

                                                                      func (*ConflictingNamesSetValueArgs) MarshalLogObject

                                                                      func (v *ConflictingNamesSetValueArgs) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

                                                                        MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ConflictingNamesSetValueArgs.

                                                                        func (*ConflictingNamesSetValueArgs) String

                                                                          String returns a readable string representation of a ConflictingNamesSetValueArgs struct.

                                                                          func (*ConflictingNamesSetValueArgs) ToWire

                                                                            ToWire translates a ConflictingNamesSetValueArgs struct into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

                                                                            An error is returned if the struct or any of its fields failed to validate.

                                                                            x, err := v.ToWire()
                                                                            if err != nil {
                                                                              return err
                                                                            }
                                                                            
                                                                            if err := binaryProtocol.Encode(x, writer); err != nil {
                                                                              return err
                                                                            }
                                                                            

                                                                            type ConflictingNames_SetValue_Args

                                                                            type ConflictingNames_SetValue_Args struct {
                                                                            	Request *ConflictingNamesSetValueArgs `json:"request,omitempty"`
                                                                            }

                                                                              ConflictingNames_SetValue_Args represents the arguments for the ConflictingNames.setValue function.

                                                                              The arguments for setValue are sent and received over the wire as this struct.

                                                                              func (*ConflictingNames_SetValue_Args) EnvelopeType

                                                                                EnvelopeType returns the kind of value inside this struct.

                                                                                This will always be Call for this struct.

                                                                                func (*ConflictingNames_SetValue_Args) Equals

                                                                                  Equals returns true if all the fields of this ConflictingNames_SetValue_Args match the provided ConflictingNames_SetValue_Args.

                                                                                  This function performs a deep comparison.

                                                                                  func (*ConflictingNames_SetValue_Args) FromWire

                                                                                    FromWire deserializes a ConflictingNames_SetValue_Args struct from its Thrift-level representation. The Thrift-level representation may be obtained from a ThriftRW protocol implementation.

                                                                                    An error is returned if we were unable to build a ConflictingNames_SetValue_Args struct from the provided intermediate representation.

                                                                                    x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                    if err != nil {
                                                                                      return nil, err
                                                                                    }
                                                                                    
                                                                                    var v ConflictingNames_SetValue_Args
                                                                                    if err := v.FromWire(x); err != nil {
                                                                                      return nil, err
                                                                                    }
                                                                                    return &v, nil
                                                                                    

                                                                                    func (*ConflictingNames_SetValue_Args) GetRequest

                                                                                      GetRequest returns the value of Request if it is set or its zero value if it is unset.

                                                                                      func (*ConflictingNames_SetValue_Args) IsSetRequest

                                                                                      func (v *ConflictingNames_SetValue_Args) IsSetRequest() bool

                                                                                        IsSetRequest returns true if Request is not nil.

                                                                                        func (*ConflictingNames_SetValue_Args) MarshalLogObject

                                                                                        func (v *ConflictingNames_SetValue_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

                                                                                          MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ConflictingNames_SetValue_Args.

                                                                                          func (*ConflictingNames_SetValue_Args) MethodName

                                                                                          func (v *ConflictingNames_SetValue_Args) MethodName() string

                                                                                            MethodName returns the name of the Thrift function as specified in the IDL, for which this struct represent the arguments.

                                                                                            This will always be "setValue" for this struct.

                                                                                            func (*ConflictingNames_SetValue_Args) String

                                                                                              String returns a readable string representation of a ConflictingNames_SetValue_Args struct.

                                                                                              func (*ConflictingNames_SetValue_Args) ToWire

                                                                                                ToWire translates a ConflictingNames_SetValue_Args struct into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

                                                                                                An error is returned if the struct or any of its fields failed to validate.

                                                                                                x, err := v.ToWire()
                                                                                                if err != nil {
                                                                                                  return err
                                                                                                }
                                                                                                
                                                                                                if err := binaryProtocol.Encode(x, writer); err != nil {
                                                                                                  return err
                                                                                                }
                                                                                                

                                                                                                type ConflictingNames_SetValue_Result

                                                                                                type ConflictingNames_SetValue_Result struct {
                                                                                                }

                                                                                                  ConflictingNames_SetValue_Result represents the result of a ConflictingNames.setValue function call.

                                                                                                  The result of a setValue execution is sent and received over the wire as this struct.

                                                                                                  func (*ConflictingNames_SetValue_Result) EnvelopeType

                                                                                                    EnvelopeType returns the kind of value inside this struct.

                                                                                                    This will always be Reply for this struct.

                                                                                                    func (*ConflictingNames_SetValue_Result) Equals

                                                                                                      Equals returns true if all the fields of this ConflictingNames_SetValue_Result match the provided ConflictingNames_SetValue_Result.

                                                                                                      This function performs a deep comparison.

                                                                                                      func (*ConflictingNames_SetValue_Result) FromWire

                                                                                                        FromWire deserializes a ConflictingNames_SetValue_Result struct from its Thrift-level representation. The Thrift-level representation may be obtained from a ThriftRW protocol implementation.

                                                                                                        An error is returned if we were unable to build a ConflictingNames_SetValue_Result struct from the provided intermediate representation.

                                                                                                        x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                                        if err != nil {
                                                                                                          return nil, err
                                                                                                        }
                                                                                                        
                                                                                                        var v ConflictingNames_SetValue_Result
                                                                                                        if err := v.FromWire(x); err != nil {
                                                                                                          return nil, err
                                                                                                        }
                                                                                                        return &v, nil
                                                                                                        

                                                                                                        func (*ConflictingNames_SetValue_Result) MarshalLogObject

                                                                                                        func (v *ConflictingNames_SetValue_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

                                                                                                          MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ConflictingNames_SetValue_Result.

                                                                                                          func (*ConflictingNames_SetValue_Result) MethodName

                                                                                                          func (v *ConflictingNames_SetValue_Result) MethodName() string

                                                                                                            MethodName returns the name of the Thrift function as specified in the IDL, for which this struct represent the result.

                                                                                                            This will always be "setValue" for this struct.

                                                                                                            func (*ConflictingNames_SetValue_Result) String

                                                                                                              String returns a readable string representation of a ConflictingNames_SetValue_Result struct.

                                                                                                              func (*ConflictingNames_SetValue_Result) ToWire

                                                                                                                ToWire translates a ConflictingNames_SetValue_Result struct into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

                                                                                                                An error is returned if the struct or any of its fields failed to validate.

                                                                                                                x, err := v.ToWire()
                                                                                                                if err != nil {
                                                                                                                  return err
                                                                                                                }
                                                                                                                
                                                                                                                if err := binaryProtocol.Encode(x, writer); err != nil {
                                                                                                                  return err
                                                                                                                }
                                                                                                                

                                                                                                                type InternalError

                                                                                                                type InternalError struct {
                                                                                                                	Message *string `json:"message,omitempty"`
                                                                                                                }

                                                                                                                func (*InternalError) Equals

                                                                                                                func (v *InternalError) Equals(rhs *InternalError) bool

                                                                                                                  Equals returns true if all the fields of this InternalError match the provided InternalError.

                                                                                                                  This function performs a deep comparison.

                                                                                                                  func (*InternalError) Error

                                                                                                                  func (v *InternalError) Error() string

                                                                                                                  func (*InternalError) ErrorName

                                                                                                                  func (*InternalError) ErrorName() string

                                                                                                                    ErrorName is the name of this type as defined in the Thrift file.

                                                                                                                    func (*InternalError) FromWire

                                                                                                                    func (v *InternalError) FromWire(w wire.Value) error

                                                                                                                      FromWire deserializes a InternalError struct from its Thrift-level representation. The Thrift-level representation may be obtained from a ThriftRW protocol implementation.

                                                                                                                      An error is returned if we were unable to build a InternalError struct from the provided intermediate representation.

                                                                                                                      x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                                                      if err != nil {
                                                                                                                        return nil, err
                                                                                                                      }
                                                                                                                      
                                                                                                                      var v InternalError
                                                                                                                      if err := v.FromWire(x); err != nil {
                                                                                                                        return nil, err
                                                                                                                      }
                                                                                                                      return &v, nil
                                                                                                                      

                                                                                                                      func (*InternalError) GetMessage

                                                                                                                      func (v *InternalError) GetMessage() (o string)

                                                                                                                        GetMessage returns the value of Message if it is set or its zero value if it is unset.

                                                                                                                        func (*InternalError) IsSetMessage

                                                                                                                        func (v *InternalError) IsSetMessage() bool

                                                                                                                          IsSetMessage returns true if Message is not nil.

                                                                                                                          func (*InternalError) MarshalLogObject

                                                                                                                          func (v *InternalError) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

                                                                                                                            MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of InternalError.

                                                                                                                            func (*InternalError) String

                                                                                                                            func (v *InternalError) String() string

                                                                                                                              String returns a readable string representation of a InternalError struct.

                                                                                                                              func (*InternalError) ToWire

                                                                                                                              func (v *InternalError) ToWire() (wire.Value, error)

                                                                                                                                ToWire translates a InternalError struct into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

                                                                                                                                An error is returned if the struct or any of its fields failed to validate.

                                                                                                                                x, err := v.ToWire()
                                                                                                                                if err != nil {
                                                                                                                                  return err
                                                                                                                                }
                                                                                                                                
                                                                                                                                if err := binaryProtocol.Encode(x, writer); err != nil {
                                                                                                                                  return err
                                                                                                                                }
                                                                                                                                

                                                                                                                                type Key

                                                                                                                                type Key string

                                                                                                                                func (Key) Equals

                                                                                                                                func (lhs Key) Equals(rhs Key) bool

                                                                                                                                  Equals returns true if this Key is equal to the provided Key.

                                                                                                                                  func (*Key) FromWire

                                                                                                                                  func (v *Key) FromWire(w wire.Value) error

                                                                                                                                    FromWire deserializes Key from its Thrift-level representation. The Thrift-level representation may be obtained from a ThriftRW protocol implementation.

                                                                                                                                    func (Key) Ptr

                                                                                                                                    func (v Key) Ptr() *Key

                                                                                                                                      KeyPtr returns a pointer to a Key

                                                                                                                                      func (Key) String

                                                                                                                                      func (v Key) String() string

                                                                                                                                        String returns a readable string representation of Key.

                                                                                                                                        func (Key) ToWire

                                                                                                                                        func (v Key) ToWire() (wire.Value, error)

                                                                                                                                          ToWire translates Key into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

                                                                                                                                          type KeyValue_DeleteValue_Args

                                                                                                                                          type KeyValue_DeleteValue_Args struct {
                                                                                                                                          	Key *Key `json:"key,omitempty"`
                                                                                                                                          }

                                                                                                                                            KeyValue_DeleteValue_Args represents the arguments for the KeyValue.deleteValue function.

                                                                                                                                            The arguments for deleteValue are sent and received over the wire as this struct.

                                                                                                                                            func (*KeyValue_DeleteValue_Args) EnvelopeType

                                                                                                                                            func (v *KeyValue_DeleteValue_Args) EnvelopeType() wire.EnvelopeType

                                                                                                                                              EnvelopeType returns the kind of value inside this struct.

                                                                                                                                              This will always be Call for this struct.

                                                                                                                                              func (*KeyValue_DeleteValue_Args) Equals

                                                                                                                                                Equals returns true if all the fields of this KeyValue_DeleteValue_Args match the provided KeyValue_DeleteValue_Args.

                                                                                                                                                This function performs a deep comparison.

                                                                                                                                                func (*KeyValue_DeleteValue_Args) FromWire

                                                                                                                                                func (v *KeyValue_DeleteValue_Args) FromWire(w wire.Value) error

                                                                                                                                                  FromWire deserializes a KeyValue_DeleteValue_Args struct from its Thrift-level representation. The Thrift-level representation may be obtained from a ThriftRW protocol implementation.

                                                                                                                                                  An error is returned if we were unable to build a KeyValue_DeleteValue_Args struct from the provided intermediate representation.

                                                                                                                                                  x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                                                                                  if err != nil {
                                                                                                                                                    return nil, err
                                                                                                                                                  }
                                                                                                                                                  
                                                                                                                                                  var v KeyValue_DeleteValue_Args
                                                                                                                                                  if err := v.FromWire(x); err != nil {
                                                                                                                                                    return nil, err
                                                                                                                                                  }
                                                                                                                                                  return &v, nil
                                                                                                                                                  

                                                                                                                                                  func (*KeyValue_DeleteValue_Args) GetKey

                                                                                                                                                  func (v *KeyValue_DeleteValue_Args) GetKey() (o Key)

                                                                                                                                                    GetKey returns the value of Key if it is set or its zero value if it is unset.

                                                                                                                                                    func (*KeyValue_DeleteValue_Args) IsSetKey

                                                                                                                                                    func (v *KeyValue_DeleteValue_Args) IsSetKey() bool

                                                                                                                                                      IsSetKey returns true if Key is not nil.

                                                                                                                                                      func (*KeyValue_DeleteValue_Args) MarshalLogObject

                                                                                                                                                      func (v *KeyValue_DeleteValue_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

                                                                                                                                                        MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of KeyValue_DeleteValue_Args.

                                                                                                                                                        func (*KeyValue_DeleteValue_Args) MethodName

                                                                                                                                                        func (v *KeyValue_DeleteValue_Args) MethodName() string

                                                                                                                                                          MethodName returns the name of the Thrift function as specified in the IDL, for which this struct represent the arguments.

                                                                                                                                                          This will always be "deleteValue" for this struct.

                                                                                                                                                          func (*KeyValue_DeleteValue_Args) String

                                                                                                                                                          func (v *KeyValue_DeleteValue_Args) String() string

                                                                                                                                                            String returns a readable string representation of a KeyValue_DeleteValue_Args struct.

                                                                                                                                                            func (*KeyValue_DeleteValue_Args) ToWire

                                                                                                                                                            func (v *KeyValue_DeleteValue_Args) ToWire() (wire.Value, error)

                                                                                                                                                              ToWire translates a KeyValue_DeleteValue_Args struct into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

                                                                                                                                                              An error is returned if the struct or any of its fields failed to validate.

                                                                                                                                                              x, err := v.ToWire()
                                                                                                                                                              if err != nil {
                                                                                                                                                                return err
                                                                                                                                                              }
                                                                                                                                                              
                                                                                                                                                              if err := binaryProtocol.Encode(x, writer); err != nil {
                                                                                                                                                                return err
                                                                                                                                                              }
                                                                                                                                                              

                                                                                                                                                              type KeyValue_DeleteValue_Result

                                                                                                                                                              type KeyValue_DeleteValue_Result struct {
                                                                                                                                                              	// Raised if a value with the given key doesn't exist.
                                                                                                                                                              	DoesNotExist  *exceptions.DoesNotExistException `json:"doesNotExist,omitempty"`
                                                                                                                                                              	InternalError *InternalError                    `json:"internalError,omitempty"`
                                                                                                                                                              }

                                                                                                                                                                KeyValue_DeleteValue_Result represents the result of a KeyValue.deleteValue function call.

                                                                                                                                                                The result of a deleteValue execution is sent and received over the wire as this struct.

                                                                                                                                                                func (*KeyValue_DeleteValue_Result) EnvelopeType

                                                                                                                                                                func (v *KeyValue_DeleteValue_Result) EnvelopeType() wire.EnvelopeType

                                                                                                                                                                  EnvelopeType returns the kind of value inside this struct.

                                                                                                                                                                  This will always be Reply for this struct.

                                                                                                                                                                  func (*KeyValue_DeleteValue_Result) Equals

                                                                                                                                                                    Equals returns true if all the fields of this KeyValue_DeleteValue_Result match the provided KeyValue_DeleteValue_Result.

                                                                                                                                                                    This function performs a deep comparison.

                                                                                                                                                                    func (*KeyValue_DeleteValue_Result) FromWire

                                                                                                                                                                      FromWire deserializes a KeyValue_DeleteValue_Result struct from its Thrift-level representation. The Thrift-level representation may be obtained from a ThriftRW protocol implementation.

                                                                                                                                                                      An error is returned if we were unable to build a KeyValue_DeleteValue_Result struct from the provided intermediate representation.

                                                                                                                                                                      x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                                                                                                      if err != nil {
                                                                                                                                                                        return nil, err
                                                                                                                                                                      }
                                                                                                                                                                      
                                                                                                                                                                      var v KeyValue_DeleteValue_Result
                                                                                                                                                                      if err := v.FromWire(x); err != nil {
                                                                                                                                                                        return nil, err
                                                                                                                                                                      }
                                                                                                                                                                      return &v, nil
                                                                                                                                                                      

                                                                                                                                                                      func (*KeyValue_DeleteValue_Result) GetDoesNotExist

                                                                                                                                                                        GetDoesNotExist returns the value of DoesNotExist if it is set or its zero value if it is unset.

                                                                                                                                                                        func (*KeyValue_DeleteValue_Result) GetInternalError

                                                                                                                                                                        func (v *KeyValue_DeleteValue_Result) GetInternalError() (o *InternalError)

                                                                                                                                                                          GetInternalError returns the value of InternalError if it is set or its zero value if it is unset.

                                                                                                                                                                          func (*KeyValue_DeleteValue_Result) IsSetDoesNotExist

                                                                                                                                                                          func (v *KeyValue_DeleteValue_Result) IsSetDoesNotExist() bool

                                                                                                                                                                            IsSetDoesNotExist returns true if DoesNotExist is not nil.

                                                                                                                                                                            func (*KeyValue_DeleteValue_Result) IsSetInternalError

                                                                                                                                                                            func (v *KeyValue_DeleteValue_Result) IsSetInternalError() bool

                                                                                                                                                                              IsSetInternalError returns true if InternalError is not nil.

                                                                                                                                                                              func (*KeyValue_DeleteValue_Result) MarshalLogObject

                                                                                                                                                                              func (v *KeyValue_DeleteValue_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

                                                                                                                                                                                MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of KeyValue_DeleteValue_Result.

                                                                                                                                                                                func (*KeyValue_DeleteValue_Result) MethodName

                                                                                                                                                                                func (v *KeyValue_DeleteValue_Result) MethodName() string

                                                                                                                                                                                  MethodName returns the name of the Thrift function as specified in the IDL, for which this struct represent the result.

                                                                                                                                                                                  This will always be "deleteValue" for this struct.

                                                                                                                                                                                  func (*KeyValue_DeleteValue_Result) String

                                                                                                                                                                                  func (v *KeyValue_DeleteValue_Result) String() string

                                                                                                                                                                                    String returns a readable string representation of a KeyValue_DeleteValue_Result struct.

                                                                                                                                                                                    func (*KeyValue_DeleteValue_Result) ToWire

                                                                                                                                                                                      ToWire translates a KeyValue_DeleteValue_Result struct into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

                                                                                                                                                                                      An error is returned if the struct or any of its fields failed to validate.

                                                                                                                                                                                      x, err := v.ToWire()
                                                                                                                                                                                      if err != nil {
                                                                                                                                                                                        return err
                                                                                                                                                                                      }
                                                                                                                                                                                      
                                                                                                                                                                                      if err := binaryProtocol.Encode(x, writer); err != nil {
                                                                                                                                                                                        return err
                                                                                                                                                                                      }
                                                                                                                                                                                      

                                                                                                                                                                                      type KeyValue_GetManyValues_Args

                                                                                                                                                                                      type KeyValue_GetManyValues_Args struct {
                                                                                                                                                                                      	Range []Key `json:"range,omitempty"`
                                                                                                                                                                                      }

                                                                                                                                                                                        KeyValue_GetManyValues_Args represents the arguments for the KeyValue.getManyValues function.

                                                                                                                                                                                        The arguments for getManyValues are sent and received over the wire as this struct.

                                                                                                                                                                                        func (*KeyValue_GetManyValues_Args) EnvelopeType

                                                                                                                                                                                        func (v *KeyValue_GetManyValues_Args) EnvelopeType() wire.EnvelopeType

                                                                                                                                                                                          EnvelopeType returns the kind of value inside this struct.

                                                                                                                                                                                          This will always be Call for this struct.

                                                                                                                                                                                          func (*KeyValue_GetManyValues_Args) Equals

                                                                                                                                                                                            Equals returns true if all the fields of this KeyValue_GetManyValues_Args match the provided KeyValue_GetManyValues_Args.

                                                                                                                                                                                            This function performs a deep comparison.

                                                                                                                                                                                            func (*KeyValue_GetManyValues_Args) FromWire

                                                                                                                                                                                              FromWire deserializes a KeyValue_GetManyValues_Args struct from its Thrift-level representation. The Thrift-level representation may be obtained from a ThriftRW protocol implementation.

                                                                                                                                                                                              An error is returned if we were unable to build a KeyValue_GetManyValues_Args struct from the provided intermediate representation.

                                                                                                                                                                                              x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                                                                                                                              if err != nil {
                                                                                                                                                                                                return nil, err
                                                                                                                                                                                              }
                                                                                                                                                                                              
                                                                                                                                                                                              var v KeyValue_GetManyValues_Args
                                                                                                                                                                                              if err := v.FromWire(x); err != nil {
                                                                                                                                                                                                return nil, err
                                                                                                                                                                                              }
                                                                                                                                                                                              return &v, nil
                                                                                                                                                                                              

                                                                                                                                                                                              func (*KeyValue_GetManyValues_Args) GetRange

                                                                                                                                                                                              func (v *KeyValue_GetManyValues_Args) GetRange() (o []Key)

                                                                                                                                                                                                GetRange returns the value of Range if it is set or its zero value if it is unset.

                                                                                                                                                                                                func (*KeyValue_GetManyValues_Args) IsSetRange

                                                                                                                                                                                                func (v *KeyValue_GetManyValues_Args) IsSetRange() bool

                                                                                                                                                                                                  IsSetRange returns true if Range is not nil.

                                                                                                                                                                                                  func (*KeyValue_GetManyValues_Args) MarshalLogObject

                                                                                                                                                                                                  func (v *KeyValue_GetManyValues_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

                                                                                                                                                                                                    MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of KeyValue_GetManyValues_Args.

                                                                                                                                                                                                    func (*KeyValue_GetManyValues_Args) MethodName

                                                                                                                                                                                                    func (v *KeyValue_GetManyValues_Args) MethodName() string

                                                                                                                                                                                                      MethodName returns the name of the Thrift function as specified in the IDL, for which this struct represent the arguments.

                                                                                                                                                                                                      This will always be "getManyValues" for this struct.

                                                                                                                                                                                                      func (*KeyValue_GetManyValues_Args) String

                                                                                                                                                                                                      func (v *KeyValue_GetManyValues_Args) String() string

                                                                                                                                                                                                        String returns a readable string representation of a KeyValue_GetManyValues_Args struct.

                                                                                                                                                                                                        func (*KeyValue_GetManyValues_Args) ToWire

                                                                                                                                                                                                          ToWire translates a KeyValue_GetManyValues_Args struct into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

                                                                                                                                                                                                          An error is returned if the struct or any of its fields failed to validate.

                                                                                                                                                                                                          x, err := v.ToWire()
                                                                                                                                                                                                          if err != nil {
                                                                                                                                                                                                            return err
                                                                                                                                                                                                          }
                                                                                                                                                                                                          
                                                                                                                                                                                                          if err := binaryProtocol.Encode(x, writer); err != nil {
                                                                                                                                                                                                            return err
                                                                                                                                                                                                          }
                                                                                                                                                                                                          

                                                                                                                                                                                                          type KeyValue_GetManyValues_Result

                                                                                                                                                                                                          type KeyValue_GetManyValues_Result struct {
                                                                                                                                                                                                          	// Value returned by getManyValues after a successful execution.
                                                                                                                                                                                                          	Success      []*unions.ArbitraryValue          `json:"success,omitempty"`
                                                                                                                                                                                                          	DoesNotExist *exceptions.DoesNotExistException `json:"doesNotExist,omitempty"`
                                                                                                                                                                                                          }

                                                                                                                                                                                                            KeyValue_GetManyValues_Result represents the result of a KeyValue.getManyValues function call.

                                                                                                                                                                                                            The result of a getManyValues execution is sent and received over the wire as this struct.

                                                                                                                                                                                                            Success is set only if the function did not throw an exception.

                                                                                                                                                                                                            func (*KeyValue_GetManyValues_Result) EnvelopeType

                                                                                                                                                                                                              EnvelopeType returns the kind of value inside this struct.

                                                                                                                                                                                                              This will always be Reply for this struct.

                                                                                                                                                                                                              func (*KeyValue_GetManyValues_Result) Equals

                                                                                                                                                                                                                Equals returns true if all the fields of this KeyValue_GetManyValues_Result match the provided KeyValue_GetManyValues_Result.

                                                                                                                                                                                                                This function performs a deep comparison.

                                                                                                                                                                                                                func (*KeyValue_GetManyValues_Result) FromWire

                                                                                                                                                                                                                  FromWire deserializes a KeyValue_GetManyValues_Result struct from its Thrift-level representation. The Thrift-level representation may be obtained from a ThriftRW protocol implementation.

                                                                                                                                                                                                                  An error is returned if we were unable to build a KeyValue_GetManyValues_Result struct from the provided intermediate representation.

                                                                                                                                                                                                                  x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                                                                                                                                                  if err != nil {
                                                                                                                                                                                                                    return nil, err
                                                                                                                                                                                                                  }
                                                                                                                                                                                                                  
                                                                                                                                                                                                                  var v KeyValue_GetManyValues_Result
                                                                                                                                                                                                                  if err := v.FromWire(x); err != nil {
                                                                                                                                                                                                                    return nil, err
                                                                                                                                                                                                                  }
                                                                                                                                                                                                                  return &v, nil
                                                                                                                                                                                                                  

                                                                                                                                                                                                                  func (*KeyValue_GetManyValues_Result) GetDoesNotExist

                                                                                                                                                                                                                    GetDoesNotExist returns the value of DoesNotExist if it is set or its zero value if it is unset.

                                                                                                                                                                                                                    func (*KeyValue_GetManyValues_Result) GetSuccess

                                                                                                                                                                                                                    func (v *KeyValue_GetManyValues_Result) GetSuccess() (o []*unions.ArbitraryValue)

                                                                                                                                                                                                                      GetSuccess returns the value of Success if it is set or its zero value if it is unset.

                                                                                                                                                                                                                      func (*KeyValue_GetManyValues_Result) IsSetDoesNotExist

                                                                                                                                                                                                                      func (v *KeyValue_GetManyValues_Result) IsSetDoesNotExist() bool

                                                                                                                                                                                                                        IsSetDoesNotExist returns true if DoesNotExist is not nil.

                                                                                                                                                                                                                        func (*KeyValue_GetManyValues_Result) IsSetSuccess

                                                                                                                                                                                                                        func (v *KeyValue_GetManyValues_Result) IsSetSuccess() bool

                                                                                                                                                                                                                          IsSetSuccess returns true if Success is not nil.

                                                                                                                                                                                                                          func (*KeyValue_GetManyValues_Result) MarshalLogObject

                                                                                                                                                                                                                          func (v *KeyValue_GetManyValues_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

                                                                                                                                                                                                                            MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of KeyValue_GetManyValues_Result.

                                                                                                                                                                                                                            func (*KeyValue_GetManyValues_Result) MethodName

                                                                                                                                                                                                                            func (v *KeyValue_GetManyValues_Result) MethodName() string

                                                                                                                                                                                                                              MethodName returns the name of the Thrift function as specified in the IDL, for which this struct represent the result.

                                                                                                                                                                                                                              This will always be "getManyValues" for this struct.

                                                                                                                                                                                                                              func (*KeyValue_GetManyValues_Result) String

                                                                                                                                                                                                                                String returns a readable string representation of a KeyValue_GetManyValues_Result struct.

                                                                                                                                                                                                                                func (*KeyValue_GetManyValues_Result) ToWire

                                                                                                                                                                                                                                  ToWire translates a KeyValue_GetManyValues_Result struct into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

                                                                                                                                                                                                                                  An error is returned if the struct or any of its fields failed to validate.

                                                                                                                                                                                                                                  x, err := v.ToWire()
                                                                                                                                                                                                                                  if err != nil {
                                                                                                                                                                                                                                    return err
                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                  
                                                                                                                                                                                                                                  if err := binaryProtocol.Encode(x, writer); err != nil {
                                                                                                                                                                                                                                    return err
                                                                                                                                                                                                                                  }
                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                  type KeyValue_GetValue_Args

                                                                                                                                                                                                                                  type KeyValue_GetValue_Args struct {
                                                                                                                                                                                                                                  	Key *Key `json:"key,omitempty"`
                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                    KeyValue_GetValue_Args represents the arguments for the KeyValue.getValue function.

                                                                                                                                                                                                                                    The arguments for getValue are sent and received over the wire as this struct.

                                                                                                                                                                                                                                    func (*KeyValue_GetValue_Args) EnvelopeType

                                                                                                                                                                                                                                    func (v *KeyValue_GetValue_Args) EnvelopeType() wire.EnvelopeType

                                                                                                                                                                                                                                      EnvelopeType returns the kind of value inside this struct.

                                                                                                                                                                                                                                      This will always be Call for this struct.

                                                                                                                                                                                                                                      func (*KeyValue_GetValue_Args) Equals

                                                                                                                                                                                                                                        Equals returns true if all the fields of this KeyValue_GetValue_Args match the provided KeyValue_GetValue_Args.

                                                                                                                                                                                                                                        This function performs a deep comparison.

                                                                                                                                                                                                                                        func (*KeyValue_GetValue_Args) FromWire

                                                                                                                                                                                                                                        func (v *KeyValue_GetValue_Args) FromWire(w wire.Value) error

                                                                                                                                                                                                                                          FromWire deserializes a KeyValue_GetValue_Args struct from its Thrift-level representation. The Thrift-level representation may be obtained from a ThriftRW protocol implementation.

                                                                                                                                                                                                                                          An error is returned if we were unable to build a KeyValue_GetValue_Args struct from the provided intermediate representation.

                                                                                                                                                                                                                                          x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                                                                                                                                                                          if err != nil {
                                                                                                                                                                                                                                            return nil, err
                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                          var v KeyValue_GetValue_Args
                                                                                                                                                                                                                                          if err := v.FromWire(x); err != nil {
                                                                                                                                                                                                                                            return nil, err
                                                                                                                                                                                                                                          }
                                                                                                                                                                                                                                          return &v, nil
                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                          func (*KeyValue_GetValue_Args) GetKey

                                                                                                                                                                                                                                          func (v *KeyValue_GetValue_Args) GetKey() (o Key)

                                                                                                                                                                                                                                            GetKey returns the value of Key if it is set or its zero value if it is unset.

                                                                                                                                                                                                                                            func (*KeyValue_GetValue_Args) IsSetKey

                                                                                                                                                                                                                                            func (v *KeyValue_GetValue_Args) IsSetKey() bool

                                                                                                                                                                                                                                              IsSetKey returns true if Key is not nil.

                                                                                                                                                                                                                                              func (*KeyValue_GetValue_Args) MarshalLogObject

                                                                                                                                                                                                                                              func (v *KeyValue_GetValue_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

                                                                                                                                                                                                                                                MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of KeyValue_GetValue_Args.

                                                                                                                                                                                                                                                func (*KeyValue_GetValue_Args) MethodName

                                                                                                                                                                                                                                                func (v *KeyValue_GetValue_Args) MethodName() string

                                                                                                                                                                                                                                                  MethodName returns the name of the Thrift function as specified in the IDL, for which this struct represent the arguments.

                                                                                                                                                                                                                                                  This will always be "getValue" for this struct.

                                                                                                                                                                                                                                                  func (*KeyValue_GetValue_Args) String

                                                                                                                                                                                                                                                  func (v *KeyValue_GetValue_Args) String() string

                                                                                                                                                                                                                                                    String returns a readable string representation of a KeyValue_GetValue_Args struct.

                                                                                                                                                                                                                                                    func (*KeyValue_GetValue_Args) ToWire

                                                                                                                                                                                                                                                    func (v *KeyValue_GetValue_Args) ToWire() (wire.Value, error)

                                                                                                                                                                                                                                                      ToWire translates a KeyValue_GetValue_Args struct into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

                                                                                                                                                                                                                                                      An error is returned if the struct or any of its fields failed to validate.

                                                                                                                                                                                                                                                      x, err := v.ToWire()
                                                                                                                                                                                                                                                      if err != nil {
                                                                                                                                                                                                                                                        return err
                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                      if err := binaryProtocol.Encode(x, writer); err != nil {
                                                                                                                                                                                                                                                        return err
                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                      type KeyValue_GetValue_Result

                                                                                                                                                                                                                                                      type KeyValue_GetValue_Result struct {
                                                                                                                                                                                                                                                      	// Value returned by getValue after a successful execution.
                                                                                                                                                                                                                                                      	Success      *unions.ArbitraryValue            `json:"success,omitempty"`
                                                                                                                                                                                                                                                      	DoesNotExist *exceptions.DoesNotExistException `json:"doesNotExist,omitempty"`
                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                        KeyValue_GetValue_Result represents the result of a KeyValue.getValue function call.

                                                                                                                                                                                                                                                        The result of a getValue execution is sent and received over the wire as this struct.

                                                                                                                                                                                                                                                        Success is set only if the function did not throw an exception.

                                                                                                                                                                                                                                                        func (*KeyValue_GetValue_Result) EnvelopeType

                                                                                                                                                                                                                                                        func (v *KeyValue_GetValue_Result) EnvelopeType() wire.EnvelopeType

                                                                                                                                                                                                                                                          EnvelopeType returns the kind of value inside this struct.

                                                                                                                                                                                                                                                          This will always be Reply for this struct.

                                                                                                                                                                                                                                                          func (*KeyValue_GetValue_Result) Equals

                                                                                                                                                                                                                                                            Equals returns true if all the fields of this KeyValue_GetValue_Result match the provided KeyValue_GetValue_Result.

                                                                                                                                                                                                                                                            This function performs a deep comparison.

                                                                                                                                                                                                                                                            func (*KeyValue_GetValue_Result) FromWire

                                                                                                                                                                                                                                                            func (v *KeyValue_GetValue_Result) FromWire(w wire.Value) error

                                                                                                                                                                                                                                                              FromWire deserializes a KeyValue_GetValue_Result struct from its Thrift-level representation. The Thrift-level representation may be obtained from a ThriftRW protocol implementation.

                                                                                                                                                                                                                                                              An error is returned if we were unable to build a KeyValue_GetValue_Result struct from the provided intermediate representation.

                                                                                                                                                                                                                                                              x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                                                                                                                                                                                              if err != nil {
                                                                                                                                                                                                                                                                return nil, err
                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                              var v KeyValue_GetValue_Result
                                                                                                                                                                                                                                                              if err := v.FromWire(x); err != nil {
                                                                                                                                                                                                                                                                return nil, err
                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                              return &v, nil
                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                              func (*KeyValue_GetValue_Result) GetDoesNotExist

                                                                                                                                                                                                                                                              func (v *KeyValue_GetValue_Result) GetDoesNotExist() (o *exceptions.DoesNotExistException)

                                                                                                                                                                                                                                                                GetDoesNotExist returns the value of DoesNotExist if it is set or its zero value if it is unset.

                                                                                                                                                                                                                                                                func (*KeyValue_GetValue_Result) GetSuccess

                                                                                                                                                                                                                                                                func (v *KeyValue_GetValue_Result) GetSuccess() (o *unions.ArbitraryValue)

                                                                                                                                                                                                                                                                  GetSuccess returns the value of Success if it is set or its zero value if it is unset.

                                                                                                                                                                                                                                                                  func (*KeyValue_GetValue_Result) IsSetDoesNotExist

                                                                                                                                                                                                                                                                  func (v *KeyValue_GetValue_Result) IsSetDoesNotExist() bool

                                                                                                                                                                                                                                                                    IsSetDoesNotExist returns true if DoesNotExist is not nil.

                                                                                                                                                                                                                                                                    func (*KeyValue_GetValue_Result) IsSetSuccess

                                                                                                                                                                                                                                                                    func (v *KeyValue_GetValue_Result) IsSetSuccess() bool

                                                                                                                                                                                                                                                                      IsSetSuccess returns true if Success is not nil.

                                                                                                                                                                                                                                                                      func (*KeyValue_GetValue_Result) MarshalLogObject

                                                                                                                                                                                                                                                                      func (v *KeyValue_GetValue_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

                                                                                                                                                                                                                                                                        MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of KeyValue_GetValue_Result.

                                                                                                                                                                                                                                                                        func (*KeyValue_GetValue_Result) MethodName

                                                                                                                                                                                                                                                                        func (v *KeyValue_GetValue_Result) MethodName() string

                                                                                                                                                                                                                                                                          MethodName returns the name of the Thrift function as specified in the IDL, for which this struct represent the result.

                                                                                                                                                                                                                                                                          This will always be "getValue" for this struct.

                                                                                                                                                                                                                                                                          func (*KeyValue_GetValue_Result) String

                                                                                                                                                                                                                                                                          func (v *KeyValue_GetValue_Result) String() string

                                                                                                                                                                                                                                                                            String returns a readable string representation of a KeyValue_GetValue_Result struct.

                                                                                                                                                                                                                                                                            func (*KeyValue_GetValue_Result) ToWire

                                                                                                                                                                                                                                                                            func (v *KeyValue_GetValue_Result) ToWire() (wire.Value, error)

                                                                                                                                                                                                                                                                              ToWire translates a KeyValue_GetValue_Result struct into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

                                                                                                                                                                                                                                                                              An error is returned if the struct or any of its fields failed to validate.

                                                                                                                                                                                                                                                                              x, err := v.ToWire()
                                                                                                                                                                                                                                                                              if err != nil {
                                                                                                                                                                                                                                                                                return err
                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                              if err := binaryProtocol.Encode(x, writer); err != nil {
                                                                                                                                                                                                                                                                                return err
                                                                                                                                                                                                                                                                              }
                                                                                                                                                                                                                                                                              

                                                                                                                                                                                                                                                                              type KeyValue_SetValueV2_Args

                                                                                                                                                                                                                                                                              type KeyValue_SetValueV2_Args struct {
                                                                                                                                                                                                                                                                              	// Key to change.
                                                                                                                                                                                                                                                                              	Key Key `json:"key,required"`
                                                                                                                                                                                                                                                                              	// New value for the key.
                                                                                                                                                                                                                                                                              	//
                                                                                                                                                                                                                                                                              	// If the key already has an existing value, it will be overwritten.
                                                                                                                                                                                                                                                                              	Value *unions.ArbitraryValue `json:"value,required"`
                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                KeyValue_SetValueV2_Args represents the arguments for the KeyValue.setValueV2 function.

                                                                                                                                                                                                                                                                                The arguments for setValueV2 are sent and received over the wire as this struct.

                                                                                                                                                                                                                                                                                func (*KeyValue_SetValueV2_Args) EnvelopeType

                                                                                                                                                                                                                                                                                func (v *KeyValue_SetValueV2_Args) EnvelopeType() wire.EnvelopeType

                                                                                                                                                                                                                                                                                  EnvelopeType returns the kind of value inside this struct.

                                                                                                                                                                                                                                                                                  This will always be Call for this struct.

                                                                                                                                                                                                                                                                                  func (*KeyValue_SetValueV2_Args) Equals

                                                                                                                                                                                                                                                                                    Equals returns true if all the fields of this KeyValue_SetValueV2_Args match the provided KeyValue_SetValueV2_Args.

                                                                                                                                                                                                                                                                                    This function performs a deep comparison.

                                                                                                                                                                                                                                                                                    func (*KeyValue_SetValueV2_Args) FromWire

                                                                                                                                                                                                                                                                                    func (v *KeyValue_SetValueV2_Args) FromWire(w wire.Value) error

                                                                                                                                                                                                                                                                                      FromWire deserializes a KeyValue_SetValueV2_Args struct from its Thrift-level representation. The Thrift-level representation may be obtained from a ThriftRW protocol implementation.

                                                                                                                                                                                                                                                                                      An error is returned if we were unable to build a KeyValue_SetValueV2_Args struct from the provided intermediate representation.

                                                                                                                                                                                                                                                                                      x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                                                                                                                                                                                                                      if err != nil {
                                                                                                                                                                                                                                                                                        return nil, err
                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                                      var v KeyValue_SetValueV2_Args
                                                                                                                                                                                                                                                                                      if err := v.FromWire(x); err != nil {
                                                                                                                                                                                                                                                                                        return nil, err
                                                                                                                                                                                                                                                                                      }
                                                                                                                                                                                                                                                                                      return &v, nil
                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                      func (*KeyValue_SetValueV2_Args) GetKey

                                                                                                                                                                                                                                                                                      func (v *KeyValue_SetValueV2_Args) GetKey() (o Key)

                                                                                                                                                                                                                                                                                        GetKey returns the value of Key if it is set or its zero value if it is unset.

                                                                                                                                                                                                                                                                                        func (*KeyValue_SetValueV2_Args) GetValue

                                                                                                                                                                                                                                                                                        func (v *KeyValue_SetValueV2_Args) GetValue() (o *unions.ArbitraryValue)

                                                                                                                                                                                                                                                                                          GetValue returns the value of Value if it is set or its zero value if it is unset.

                                                                                                                                                                                                                                                                                          func (*KeyValue_SetValueV2_Args) IsSetValue

                                                                                                                                                                                                                                                                                          func (v *KeyValue_SetValueV2_Args) IsSetValue() bool

                                                                                                                                                                                                                                                                                            IsSetValue returns true if Value is not nil.

                                                                                                                                                                                                                                                                                            func (*KeyValue_SetValueV2_Args) MarshalLogObject

                                                                                                                                                                                                                                                                                            func (v *KeyValue_SetValueV2_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

                                                                                                                                                                                                                                                                                              MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of KeyValue_SetValueV2_Args.

                                                                                                                                                                                                                                                                                              func (*KeyValue_SetValueV2_Args) MethodName

                                                                                                                                                                                                                                                                                              func (v *KeyValue_SetValueV2_Args) MethodName() string

                                                                                                                                                                                                                                                                                                MethodName returns the name of the Thrift function as specified in the IDL, for which this struct represent the arguments.

                                                                                                                                                                                                                                                                                                This will always be "setValueV2" for this struct.

                                                                                                                                                                                                                                                                                                func (*KeyValue_SetValueV2_Args) String

                                                                                                                                                                                                                                                                                                func (v *KeyValue_SetValueV2_Args) String() string

                                                                                                                                                                                                                                                                                                  String returns a readable string representation of a KeyValue_SetValueV2_Args struct.

                                                                                                                                                                                                                                                                                                  func (*KeyValue_SetValueV2_Args) ToWire

                                                                                                                                                                                                                                                                                                  func (v *KeyValue_SetValueV2_Args) ToWire() (wire.Value, error)

                                                                                                                                                                                                                                                                                                    ToWire translates a KeyValue_SetValueV2_Args struct into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

                                                                                                                                                                                                                                                                                                    An error is returned if the struct or any of its fields failed to validate.

                                                                                                                                                                                                                                                                                                    x, err := v.ToWire()
                                                                                                                                                                                                                                                                                                    if err != nil {
                                                                                                                                                                                                                                                                                                      return err
                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                    if err := binaryProtocol.Encode(x, writer); err != nil {
                                                                                                                                                                                                                                                                                                      return err
                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                    type KeyValue_SetValueV2_Result

                                                                                                                                                                                                                                                                                                    type KeyValue_SetValueV2_Result struct {
                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                      KeyValue_SetValueV2_Result represents the result of a KeyValue.setValueV2 function call.

                                                                                                                                                                                                                                                                                                      The result of a setValueV2 execution is sent and received over the wire as this struct.

                                                                                                                                                                                                                                                                                                      func (*KeyValue_SetValueV2_Result) EnvelopeType

                                                                                                                                                                                                                                                                                                      func (v *KeyValue_SetValueV2_Result) EnvelopeType() wire.EnvelopeType

                                                                                                                                                                                                                                                                                                        EnvelopeType returns the kind of value inside this struct.

                                                                                                                                                                                                                                                                                                        This will always be Reply for this struct.

                                                                                                                                                                                                                                                                                                        func (*KeyValue_SetValueV2_Result) Equals

                                                                                                                                                                                                                                                                                                          Equals returns true if all the fields of this KeyValue_SetValueV2_Result match the provided KeyValue_SetValueV2_Result.

                                                                                                                                                                                                                                                                                                          This function performs a deep comparison.

                                                                                                                                                                                                                                                                                                          func (*KeyValue_SetValueV2_Result) FromWire

                                                                                                                                                                                                                                                                                                          func (v *KeyValue_SetValueV2_Result) FromWire(w wire.Value) error

                                                                                                                                                                                                                                                                                                            FromWire deserializes a KeyValue_SetValueV2_Result struct from its Thrift-level representation. The Thrift-level representation may be obtained from a ThriftRW protocol implementation.

                                                                                                                                                                                                                                                                                                            An error is returned if we were unable to build a KeyValue_SetValueV2_Result struct from the provided intermediate representation.

                                                                                                                                                                                                                                                                                                            x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                                                                                                                                                                                                                                            if err != nil {
                                                                                                                                                                                                                                                                                                              return nil, err
                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                            var v KeyValue_SetValueV2_Result
                                                                                                                                                                                                                                                                                                            if err := v.FromWire(x); err != nil {
                                                                                                                                                                                                                                                                                                              return nil, err
                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                            return &v, nil
                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                            func (*KeyValue_SetValueV2_Result) MarshalLogObject

                                                                                                                                                                                                                                                                                                            func (v *KeyValue_SetValueV2_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

                                                                                                                                                                                                                                                                                                              MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of KeyValue_SetValueV2_Result.

                                                                                                                                                                                                                                                                                                              func (*KeyValue_SetValueV2_Result) MethodName

                                                                                                                                                                                                                                                                                                              func (v *KeyValue_SetValueV2_Result) MethodName() string

                                                                                                                                                                                                                                                                                                                MethodName returns the name of the Thrift function as specified in the IDL, for which this struct represent the result.

                                                                                                                                                                                                                                                                                                                This will always be "setValueV2" for this struct.

                                                                                                                                                                                                                                                                                                                func (*KeyValue_SetValueV2_Result) String

                                                                                                                                                                                                                                                                                                                func (v *KeyValue_SetValueV2_Result) String() string

                                                                                                                                                                                                                                                                                                                  String returns a readable string representation of a KeyValue_SetValueV2_Result struct.

                                                                                                                                                                                                                                                                                                                  func (*KeyValue_SetValueV2_Result) ToWire

                                                                                                                                                                                                                                                                                                                  func (v *KeyValue_SetValueV2_Result) ToWire() (wire.Value, error)

                                                                                                                                                                                                                                                                                                                    ToWire translates a KeyValue_SetValueV2_Result struct into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

                                                                                                                                                                                                                                                                                                                    An error is returned if the struct or any of its fields failed to validate.

                                                                                                                                                                                                                                                                                                                    x, err := v.ToWire()
                                                                                                                                                                                                                                                                                                                    if err != nil {
                                                                                                                                                                                                                                                                                                                      return err
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                    if err := binaryProtocol.Encode(x, writer); err != nil {
                                                                                                                                                                                                                                                                                                                      return err
                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                    type KeyValue_SetValue_Args

                                                                                                                                                                                                                                                                                                                    type KeyValue_SetValue_Args struct {
                                                                                                                                                                                                                                                                                                                    	Key   *Key                   `json:"key,omitempty"`
                                                                                                                                                                                                                                                                                                                    	Value *unions.ArbitraryValue `json:"value,omitempty"`
                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                      KeyValue_SetValue_Args represents the arguments for the KeyValue.setValue function.

                                                                                                                                                                                                                                                                                                                      The arguments for setValue are sent and received over the wire as this struct.

                                                                                                                                                                                                                                                                                                                      func (*KeyValue_SetValue_Args) EnvelopeType

                                                                                                                                                                                                                                                                                                                      func (v *KeyValue_SetValue_Args) EnvelopeType() wire.EnvelopeType

                                                                                                                                                                                                                                                                                                                        EnvelopeType returns the kind of value inside this struct.

                                                                                                                                                                                                                                                                                                                        This will always be Call for this struct.

                                                                                                                                                                                                                                                                                                                        func (*KeyValue_SetValue_Args) Equals

                                                                                                                                                                                                                                                                                                                          Equals returns true if all the fields of this KeyValue_SetValue_Args match the provided KeyValue_SetValue_Args.

                                                                                                                                                                                                                                                                                                                          This function performs a deep comparison.

                                                                                                                                                                                                                                                                                                                          func (*KeyValue_SetValue_Args) FromWire

                                                                                                                                                                                                                                                                                                                          func (v *KeyValue_SetValue_Args) FromWire(w wire.Value) error

                                                                                                                                                                                                                                                                                                                            FromWire deserializes a KeyValue_SetValue_Args struct from its Thrift-level representation. The Thrift-level representation may be obtained from a ThriftRW protocol implementation.

                                                                                                                                                                                                                                                                                                                            An error is returned if we were unable to build a KeyValue_SetValue_Args struct from the provided intermediate representation.

                                                                                                                                                                                                                                                                                                                            x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                                                                                                                                                                                                                                                            if err != nil {
                                                                                                                                                                                                                                                                                                                              return nil, err
                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                            var v KeyValue_SetValue_Args
                                                                                                                                                                                                                                                                                                                            if err := v.FromWire(x); err != nil {
                                                                                                                                                                                                                                                                                                                              return nil, err
                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                            return &v, nil
                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                            func (*KeyValue_SetValue_Args) GetKey

                                                                                                                                                                                                                                                                                                                            func (v *KeyValue_SetValue_Args) GetKey() (o Key)

                                                                                                                                                                                                                                                                                                                              GetKey returns the value of Key if it is set or its zero value if it is unset.

                                                                                                                                                                                                                                                                                                                              func (*KeyValue_SetValue_Args) GetValue

                                                                                                                                                                                                                                                                                                                              func (v *KeyValue_SetValue_Args) GetValue() (o *unions.ArbitraryValue)

                                                                                                                                                                                                                                                                                                                                GetValue returns the value of Value if it is set or its zero value if it is unset.

                                                                                                                                                                                                                                                                                                                                func (*KeyValue_SetValue_Args) IsSetKey

                                                                                                                                                                                                                                                                                                                                func (v *KeyValue_SetValue_Args) IsSetKey() bool

                                                                                                                                                                                                                                                                                                                                  IsSetKey returns true if Key is not nil.

                                                                                                                                                                                                                                                                                                                                  func (*KeyValue_SetValue_Args) IsSetValue

                                                                                                                                                                                                                                                                                                                                  func (v *KeyValue_SetValue_Args) IsSetValue() bool

                                                                                                                                                                                                                                                                                                                                    IsSetValue returns true if Value is not nil.

                                                                                                                                                                                                                                                                                                                                    func (*KeyValue_SetValue_Args) MarshalLogObject

                                                                                                                                                                                                                                                                                                                                    func (v *KeyValue_SetValue_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

                                                                                                                                                                                                                                                                                                                                      MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of KeyValue_SetValue_Args.

                                                                                                                                                                                                                                                                                                                                      func (*KeyValue_SetValue_Args) MethodName

                                                                                                                                                                                                                                                                                                                                      func (v *KeyValue_SetValue_Args) MethodName() string

                                                                                                                                                                                                                                                                                                                                        MethodName returns the name of the Thrift function as specified in the IDL, for which this struct represent the arguments.

                                                                                                                                                                                                                                                                                                                                        This will always be "setValue" for this struct.

                                                                                                                                                                                                                                                                                                                                        func (*KeyValue_SetValue_Args) String

                                                                                                                                                                                                                                                                                                                                        func (v *KeyValue_SetValue_Args) String() string

                                                                                                                                                                                                                                                                                                                                          String returns a readable string representation of a KeyValue_SetValue_Args struct.

                                                                                                                                                                                                                                                                                                                                          func (*KeyValue_SetValue_Args) ToWire

                                                                                                                                                                                                                                                                                                                                          func (v *KeyValue_SetValue_Args) ToWire() (wire.Value, error)

                                                                                                                                                                                                                                                                                                                                            ToWire translates a KeyValue_SetValue_Args struct into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

                                                                                                                                                                                                                                                                                                                                            An error is returned if the struct or any of its fields failed to validate.

                                                                                                                                                                                                                                                                                                                                            x, err := v.ToWire()
                                                                                                                                                                                                                                                                                                                                            if err != nil {
                                                                                                                                                                                                                                                                                                                                              return err
                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                            if err := binaryProtocol.Encode(x, writer); err != nil {
                                                                                                                                                                                                                                                                                                                                              return err
                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                            type KeyValue_SetValue_Result

                                                                                                                                                                                                                                                                                                                                            type KeyValue_SetValue_Result struct {
                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                              KeyValue_SetValue_Result represents the result of a KeyValue.setValue function call.

                                                                                                                                                                                                                                                                                                                                              The result of a setValue execution is sent and received over the wire as this struct.

                                                                                                                                                                                                                                                                                                                                              func (*KeyValue_SetValue_Result) EnvelopeType

                                                                                                                                                                                                                                                                                                                                              func (v *KeyValue_SetValue_Result) EnvelopeType() wire.EnvelopeType

                                                                                                                                                                                                                                                                                                                                                EnvelopeType returns the kind of value inside this struct.

                                                                                                                                                                                                                                                                                                                                                This will always be Reply for this struct.

                                                                                                                                                                                                                                                                                                                                                func (*KeyValue_SetValue_Result) Equals

                                                                                                                                                                                                                                                                                                                                                  Equals returns true if all the fields of this KeyValue_SetValue_Result match the provided KeyValue_SetValue_Result.

                                                                                                                                                                                                                                                                                                                                                  This function performs a deep comparison.

                                                                                                                                                                                                                                                                                                                                                  func (*KeyValue_SetValue_Result) FromWire

                                                                                                                                                                                                                                                                                                                                                  func (v *KeyValue_SetValue_Result) FromWire(w wire.Value) error

                                                                                                                                                                                                                                                                                                                                                    FromWire deserializes a KeyValue_SetValue_Result struct from its Thrift-level representation. The Thrift-level representation may be obtained from a ThriftRW protocol implementation.

                                                                                                                                                                                                                                                                                                                                                    An error is returned if we were unable to build a KeyValue_SetValue_Result struct from the provided intermediate representation.

                                                                                                                                                                                                                                                                                                                                                    x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                                                                                                                                                                                                                                                                                    if err != nil {
                                                                                                                                                                                                                                                                                                                                                      return nil, err
                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                    var v KeyValue_SetValue_Result
                                                                                                                                                                                                                                                                                                                                                    if err := v.FromWire(x); err != nil {
                                                                                                                                                                                                                                                                                                                                                      return nil, err
                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                    return &v, nil
                                                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                                                    func (*KeyValue_SetValue_Result) MarshalLogObject

                                                                                                                                                                                                                                                                                                                                                    func (v *KeyValue_SetValue_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

                                                                                                                                                                                                                                                                                                                                                      MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of KeyValue_SetValue_Result.

                                                                                                                                                                                                                                                                                                                                                      func (*KeyValue_SetValue_Result) MethodName

                                                                                                                                                                                                                                                                                                                                                      func (v *KeyValue_SetValue_Result) MethodName() string

                                                                                                                                                                                                                                                                                                                                                        MethodName returns the name of the Thrift function as specified in the IDL, for which this struct represent the result.

                                                                                                                                                                                                                                                                                                                                                        This will always be "setValue" for this struct.

                                                                                                                                                                                                                                                                                                                                                        func (*KeyValue_SetValue_Result) String

                                                                                                                                                                                                                                                                                                                                                        func (v *KeyValue_SetValue_Result) String() string

                                                                                                                                                                                                                                                                                                                                                          String returns a readable string representation of a KeyValue_SetValue_Result struct.

                                                                                                                                                                                                                                                                                                                                                          func (*KeyValue_SetValue_Result) ToWire

                                                                                                                                                                                                                                                                                                                                                          func (v *KeyValue_SetValue_Result) ToWire() (wire.Value, error)

                                                                                                                                                                                                                                                                                                                                                            ToWire translates a KeyValue_SetValue_Result struct into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

                                                                                                                                                                                                                                                                                                                                                            An error is returned if the struct or any of its fields failed to validate.

                                                                                                                                                                                                                                                                                                                                                            x, err := v.ToWire()
                                                                                                                                                                                                                                                                                                                                                            if err != nil {
                                                                                                                                                                                                                                                                                                                                                              return err
                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                            if err := binaryProtocol.Encode(x, writer); err != nil {
                                                                                                                                                                                                                                                                                                                                                              return err
                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                            type KeyValue_Size_Args

                                                                                                                                                                                                                                                                                                                                                            type KeyValue_Size_Args struct {
                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                              KeyValue_Size_Args represents the arguments for the KeyValue.size function.

                                                                                                                                                                                                                                                                                                                                                              The arguments for size are sent and received over the wire as this struct.

                                                                                                                                                                                                                                                                                                                                                              func (*KeyValue_Size_Args) EnvelopeType

                                                                                                                                                                                                                                                                                                                                                              func (v *KeyValue_Size_Args) EnvelopeType() wire.EnvelopeType

                                                                                                                                                                                                                                                                                                                                                                EnvelopeType returns the kind of value inside this struct.

                                                                                                                                                                                                                                                                                                                                                                This will always be Call for this struct.

                                                                                                                                                                                                                                                                                                                                                                func (*KeyValue_Size_Args) Equals

                                                                                                                                                                                                                                                                                                                                                                func (v *KeyValue_Size_Args) Equals(rhs *KeyValue_Size_Args) bool

                                                                                                                                                                                                                                                                                                                                                                  Equals returns true if all the fields of this KeyValue_Size_Args match the provided KeyValue_Size_Args.

                                                                                                                                                                                                                                                                                                                                                                  This function performs a deep comparison.

                                                                                                                                                                                                                                                                                                                                                                  func (*KeyValue_Size_Args) FromWire

                                                                                                                                                                                                                                                                                                                                                                  func (v *KeyValue_Size_Args) FromWire(w wire.Value) error

                                                                                                                                                                                                                                                                                                                                                                    FromWire deserializes a KeyValue_Size_Args struct from its Thrift-level representation. The Thrift-level representation may be obtained from a ThriftRW protocol implementation.

                                                                                                                                                                                                                                                                                                                                                                    An error is returned if we were unable to build a KeyValue_Size_Args struct from the provided intermediate representation.

                                                                                                                                                                                                                                                                                                                                                                    x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                                                                                                                                                                                                                                                                                                    if err != nil {
                                                                                                                                                                                                                                                                                                                                                                      return nil, err
                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                    var v KeyValue_Size_Args
                                                                                                                                                                                                                                                                                                                                                                    if err := v.FromWire(x); err != nil {
                                                                                                                                                                                                                                                                                                                                                                      return nil, err
                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                    return &v, nil
                                                                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                                                                    func (*KeyValue_Size_Args) MarshalLogObject

                                                                                                                                                                                                                                                                                                                                                                    func (v *KeyValue_Size_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

                                                                                                                                                                                                                                                                                                                                                                      MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of KeyValue_Size_Args.

                                                                                                                                                                                                                                                                                                                                                                      func (*KeyValue_Size_Args) MethodName

                                                                                                                                                                                                                                                                                                                                                                      func (v *KeyValue_Size_Args) MethodName() string

                                                                                                                                                                                                                                                                                                                                                                        MethodName returns the name of the Thrift function as specified in the IDL, for which this struct represent the arguments.

                                                                                                                                                                                                                                                                                                                                                                        This will always be "size" for this struct.

                                                                                                                                                                                                                                                                                                                                                                        func (*KeyValue_Size_Args) String

                                                                                                                                                                                                                                                                                                                                                                        func (v *KeyValue_Size_Args) String() string

                                                                                                                                                                                                                                                                                                                                                                          String returns a readable string representation of a KeyValue_Size_Args struct.

                                                                                                                                                                                                                                                                                                                                                                          func (*KeyValue_Size_Args) ToWire

                                                                                                                                                                                                                                                                                                                                                                          func (v *KeyValue_Size_Args) ToWire() (wire.Value, error)

                                                                                                                                                                                                                                                                                                                                                                            ToWire translates a KeyValue_Size_Args struct into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

                                                                                                                                                                                                                                                                                                                                                                            An error is returned if the struct or any of its fields failed to validate.

                                                                                                                                                                                                                                                                                                                                                                            x, err := v.ToWire()
                                                                                                                                                                                                                                                                                                                                                                            if err != nil {
                                                                                                                                                                                                                                                                                                                                                                              return err
                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                            
                                                                                                                                                                                                                                                                                                                                                                            if err := binaryProtocol.Encode(x, writer); err != nil {
                                                                                                                                                                                                                                                                                                                                                                              return err
                                                                                                                                                                                                                                                                                                                                                                            }
                                                                                                                                                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                                                                                                                                                            type KeyValue_Size_Result

                                                                                                                                                                                                                                                                                                                                                                            type KeyValue_Size_Result struct {
                                                                                                                                                                                                                                                                                                                                                                            	// Value returned by size after a successful execution.
                                                                                                                                                                                                                                                                                                                                                                            	Success *int64 `json:"success,omitempty"`
                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                              KeyValue_Size_Result represents the result of a KeyValue.size function call.

                                                                                                                                                                                                                                                                                                                                                                              The result of a size execution is sent and received over the wire as this struct.

                                                                                                                                                                                                                                                                                                                                                                              Success is set only if the function did not throw an exception.

                                                                                                                                                                                                                                                                                                                                                                              func (*KeyValue_Size_Result) EnvelopeType

                                                                                                                                                                                                                                                                                                                                                                              func (v *KeyValue_Size_Result) EnvelopeType() wire.EnvelopeType

                                                                                                                                                                                                                                                                                                                                                                                EnvelopeType returns the kind of value inside this struct.

                                                                                                                                                                                                                                                                                                                                                                                This will always be Reply for this struct.

                                                                                                                                                                                                                                                                                                                                                                                func (*KeyValue_Size_Result) Equals

                                                                                                                                                                                                                                                                                                                                                                                  Equals returns true if all the fields of this KeyValue_Size_Result match the provided KeyValue_Size_Result.

                                                                                                                                                                                                                                                                                                                                                                                  This function performs a deep comparison.

                                                                                                                                                                                                                                                                                                                                                                                  func (*KeyValue_Size_Result) FromWire

                                                                                                                                                                                                                                                                                                                                                                                  func (v *KeyValue_Size_Result) FromWire(w wire.Value) error

                                                                                                                                                                                                                                                                                                                                                                                    FromWire deserializes a KeyValue_Size_Result struct from its Thrift-level representation. The Thrift-level representation may be obtained from a ThriftRW protocol implementation.

                                                                                                                                                                                                                                                                                                                                                                                    An error is returned if we were unable to build a KeyValue_Size_Result struct from the provided intermediate representation.

                                                                                                                                                                                                                                                                                                                                                                                    x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                                                                                                                                                                                                                                                                                                                    if err != nil {
                                                                                                                                                                                                                                                                                                                                                                                      return nil, err
                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                    var v KeyValue_Size_Result
                                                                                                                                                                                                                                                                                                                                                                                    if err := v.FromWire(x); err != nil {
                                                                                                                                                                                                                                                                                                                                                                                      return nil, err
                                                                                                                                                                                                                                                                                                                                                                                    }
                                                                                                                                                                                                                                                                                                                                                                                    return &v, nil
                                                                                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                                                                                    func (*KeyValue_Size_Result) GetSuccess

                                                                                                                                                                                                                                                                                                                                                                                    func (v *KeyValue_Size_Result) GetSuccess() (o int64)

                                                                                                                                                                                                                                                                                                                                                                                      GetSuccess returns the value of Success if it is set or its zero value if it is unset.

                                                                                                                                                                                                                                                                                                                                                                                      func (*KeyValue_Size_Result) IsSetSuccess

                                                                                                                                                                                                                                                                                                                                                                                      func (v *KeyValue_Size_Result) IsSetSuccess() bool

                                                                                                                                                                                                                                                                                                                                                                                        IsSetSuccess returns true if Success is not nil.

                                                                                                                                                                                                                                                                                                                                                                                        func (*KeyValue_Size_Result) MarshalLogObject

                                                                                                                                                                                                                                                                                                                                                                                        func (v *KeyValue_Size_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

                                                                                                                                                                                                                                                                                                                                                                                          MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of KeyValue_Size_Result.

                                                                                                                                                                                                                                                                                                                                                                                          func (*KeyValue_Size_Result) MethodName

                                                                                                                                                                                                                                                                                                                                                                                          func (v *KeyValue_Size_Result) MethodName() string

                                                                                                                                                                                                                                                                                                                                                                                            MethodName returns the name of the Thrift function as specified in the IDL, for which this struct represent the result.

                                                                                                                                                                                                                                                                                                                                                                                            This will always be "size" for this struct.

                                                                                                                                                                                                                                                                                                                                                                                            func (*KeyValue_Size_Result) String

                                                                                                                                                                                                                                                                                                                                                                                            func (v *KeyValue_Size_Result) String() string

                                                                                                                                                                                                                                                                                                                                                                                              String returns a readable string representation of a KeyValue_Size_Result struct.

                                                                                                                                                                                                                                                                                                                                                                                              func (*KeyValue_Size_Result) ToWire

                                                                                                                                                                                                                                                                                                                                                                                              func (v *KeyValue_Size_Result) ToWire() (wire.Value, error)

                                                                                                                                                                                                                                                                                                                                                                                                ToWire translates a KeyValue_Size_Result struct into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

                                                                                                                                                                                                                                                                                                                                                                                                An error is returned if the struct or any of its fields failed to validate.

                                                                                                                                                                                                                                                                                                                                                                                                x, err := v.ToWire()
                                                                                                                                                                                                                                                                                                                                                                                                if err != nil {
                                                                                                                                                                                                                                                                                                                                                                                                  return err
                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                if err := binaryProtocol.Encode(x, writer); err != nil {
                                                                                                                                                                                                                                                                                                                                                                                                  return err
                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                type NonStandardServiceName_NonStandardFunctionName_Args

                                                                                                                                                                                                                                                                                                                                                                                                type NonStandardServiceName_NonStandardFunctionName_Args struct {
                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                  NonStandardServiceName_NonStandardFunctionName_Args represents the arguments for the non_standard_service_name.non_standard_function_name function.

                                                                                                                                                                                                                                                                                                                                                                                                  The arguments for non_standard_function_name are sent and received over the wire as this struct.

                                                                                                                                                                                                                                                                                                                                                                                                  func (*NonStandardServiceName_NonStandardFunctionName_Args) EnvelopeType

                                                                                                                                                                                                                                                                                                                                                                                                    EnvelopeType returns the kind of value inside this struct.

                                                                                                                                                                                                                                                                                                                                                                                                    This will always be Call for this struct.

                                                                                                                                                                                                                                                                                                                                                                                                    func (*NonStandardServiceName_NonStandardFunctionName_Args) Equals

                                                                                                                                                                                                                                                                                                                                                                                                      Equals returns true if all the fields of this NonStandardServiceName_NonStandardFunctionName_Args match the provided NonStandardServiceName_NonStandardFunctionName_Args.

                                                                                                                                                                                                                                                                                                                                                                                                      This function performs a deep comparison.

                                                                                                                                                                                                                                                                                                                                                                                                      func (*NonStandardServiceName_NonStandardFunctionName_Args) FromWire

                                                                                                                                                                                                                                                                                                                                                                                                        FromWire deserializes a NonStandardServiceName_NonStandardFunctionName_Args struct from its Thrift-level representation. The Thrift-level representation may be obtained from a ThriftRW protocol implementation.

                                                                                                                                                                                                                                                                                                                                                                                                        An error is returned if we were unable to build a NonStandardServiceName_NonStandardFunctionName_Args struct from the provided intermediate representation.

                                                                                                                                                                                                                                                                                                                                                                                                        x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                                                                                                                                                                                                                                                                                                                                        if err != nil {
                                                                                                                                                                                                                                                                                                                                                                                                          return nil, err
                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                        var v NonStandardServiceName_NonStandardFunctionName_Args
                                                                                                                                                                                                                                                                                                                                                                                                        if err := v.FromWire(x); err != nil {
                                                                                                                                                                                                                                                                                                                                                                                                          return nil, err
                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                        return &v, nil
                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                        func (*NonStandardServiceName_NonStandardFunctionName_Args) MarshalLogObject

                                                                                                                                                                                                                                                                                                                                                                                                          MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of NonStandardServiceName_NonStandardFunctionName_Args.

                                                                                                                                                                                                                                                                                                                                                                                                          func (*NonStandardServiceName_NonStandardFunctionName_Args) MethodName

                                                                                                                                                                                                                                                                                                                                                                                                            MethodName returns the name of the Thrift function as specified in the IDL, for which this struct represent the arguments.

                                                                                                                                                                                                                                                                                                                                                                                                            This will always be "non_standard_function_name" for this struct.

                                                                                                                                                                                                                                                                                                                                                                                                            func (*NonStandardServiceName_NonStandardFunctionName_Args) String

                                                                                                                                                                                                                                                                                                                                                                                                              String returns a readable string representation of a NonStandardServiceName_NonStandardFunctionName_Args struct.

                                                                                                                                                                                                                                                                                                                                                                                                              func (*NonStandardServiceName_NonStandardFunctionName_Args) ToWire

                                                                                                                                                                                                                                                                                                                                                                                                                ToWire translates a NonStandardServiceName_NonStandardFunctionName_Args struct into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

                                                                                                                                                                                                                                                                                                                                                                                                                An error is returned if the struct or any of its fields failed to validate.

                                                                                                                                                                                                                                                                                                                                                                                                                x, err := v.ToWire()
                                                                                                                                                                                                                                                                                                                                                                                                                if err != nil {
                                                                                                                                                                                                                                                                                                                                                                                                                  return err
                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                if err := binaryProtocol.Encode(x, writer); err != nil {
                                                                                                                                                                                                                                                                                                                                                                                                                  return err
                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                                type NonStandardServiceName_NonStandardFunctionName_Result

                                                                                                                                                                                                                                                                                                                                                                                                                type NonStandardServiceName_NonStandardFunctionName_Result struct {
                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                  NonStandardServiceName_NonStandardFunctionName_Result represents the result of a non_standard_service_name.non_standard_function_name function call.

                                                                                                                                                                                                                                                                                                                                                                                                                  The result of a non_standard_function_name execution is sent and received over the wire as this struct.

                                                                                                                                                                                                                                                                                                                                                                                                                  func (*NonStandardServiceName_NonStandardFunctionName_Result) EnvelopeType

                                                                                                                                                                                                                                                                                                                                                                                                                    EnvelopeType returns the kind of value inside this struct.

                                                                                                                                                                                                                                                                                                                                                                                                                    This will always be Reply for this struct.

                                                                                                                                                                                                                                                                                                                                                                                                                    func (*NonStandardServiceName_NonStandardFunctionName_Result) Equals

                                                                                                                                                                                                                                                                                                                                                                                                                      Equals returns true if all the fields of this NonStandardServiceName_NonStandardFunctionName_Result match the provided NonStandardServiceName_NonStandardFunctionName_Result.

                                                                                                                                                                                                                                                                                                                                                                                                                      This function performs a deep comparison.

                                                                                                                                                                                                                                                                                                                                                                                                                      func (*NonStandardServiceName_NonStandardFunctionName_Result) FromWire

                                                                                                                                                                                                                                                                                                                                                                                                                        FromWire deserializes a NonStandardServiceName_NonStandardFunctionName_Result struct from its Thrift-level representation. The Thrift-level representation may be obtained from a ThriftRW protocol implementation.

                                                                                                                                                                                                                                                                                                                                                                                                                        An error is returned if we were unable to build a NonStandardServiceName_NonStandardFunctionName_Result struct from the provided intermediate representation.

                                                                                                                                                                                                                                                                                                                                                                                                                        x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                                                                                                                                                                                                                                                                                                                                                        if err != nil {
                                                                                                                                                                                                                                                                                                                                                                                                                          return nil, err
                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                        var v NonStandardServiceName_NonStandardFunctionName_Result
                                                                                                                                                                                                                                                                                                                                                                                                                        if err := v.FromWire(x); err != nil {
                                                                                                                                                                                                                                                                                                                                                                                                                          return nil, err
                                                                                                                                                                                                                                                                                                                                                                                                                        }
                                                                                                                                                                                                                                                                                                                                                                                                                        return &v, nil
                                                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                                                        func (*NonStandardServiceName_NonStandardFunctionName_Result) MarshalLogObject

                                                                                                                                                                                                                                                                                                                                                                                                                          MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of NonStandardServiceName_NonStandardFunctionName_Result.

                                                                                                                                                                                                                                                                                                                                                                                                                          func (*NonStandardServiceName_NonStandardFunctionName_Result) MethodName

                                                                                                                                                                                                                                                                                                                                                                                                                            MethodName returns the name of the Thrift function as specified in the IDL, for which this struct represent the result.

                                                                                                                                                                                                                                                                                                                                                                                                                            This will always be "non_standard_function_name" for this struct.

                                                                                                                                                                                                                                                                                                                                                                                                                            func (*NonStandardServiceName_NonStandardFunctionName_Result) String

                                                                                                                                                                                                                                                                                                                                                                                                                              String returns a readable string representation of a NonStandardServiceName_NonStandardFunctionName_Result struct.

                                                                                                                                                                                                                                                                                                                                                                                                                              func (*NonStandardServiceName_NonStandardFunctionName_Result) ToWire

                                                                                                                                                                                                                                                                                                                                                                                                                                ToWire translates a NonStandardServiceName_NonStandardFunctionName_Result struct into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

                                                                                                                                                                                                                                                                                                                                                                                                                                An error is returned if the struct or any of its fields failed to validate.

                                                                                                                                                                                                                                                                                                                                                                                                                                x, err := v.ToWire()
                                                                                                                                                                                                                                                                                                                                                                                                                                if err != nil {
                                                                                                                                                                                                                                                                                                                                                                                                                                  return err
                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                if err := binaryProtocol.Encode(x, writer); err != nil {
                                                                                                                                                                                                                                                                                                                                                                                                                                  return err
                                                                                                                                                                                                                                                                                                                                                                                                                                }
                                                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                                                Source Files