services

package
v1.31.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jun 9, 2023 License: MIT Imports: 12 Imported by: 0

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) Decode added in v1.29.0 

func (v *Cache_ClearAfter_Args) Decode(sr stream.Reader) error

Decode deserializes a Cache_ClearAfter_Args struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a Cache_ClearAfter_Args struct could not be generated from the wire representation.

func (*Cache_ClearAfter_Args) Encode added in v1.29.0 

func (v *Cache_ClearAfter_Args) Encode(sw stream.Writer) error

Encode serializes a Cache_ClearAfter_Args struct directly into bytes, without going through an intermediary type.

An error is returned if a Cache_ClearAfter_Args struct could not be encoded.

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 

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

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 added in v1.14.0 

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) Decode added in v1.29.0 

func (v *Cache_Clear_Args) Decode(sr stream.Reader) error

Decode deserializes a Cache_Clear_Args struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a Cache_Clear_Args struct could not be generated from the wire representation.

func (*Cache_Clear_Args) Encode added in v1.29.0 

func (v *Cache_Clear_Args) Encode(sw stream.Writer) error

Encode serializes a Cache_Clear_Args struct directly into bytes, without going through an intermediary type.

An error is returned if a Cache_Clear_Args struct could not be encoded.

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) Decode added in v1.29.0 

func (v *ConflictingNamesSetValueArgs) Decode(sr stream.Reader) error

Decode deserializes a ConflictingNamesSetValueArgs struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ConflictingNamesSetValueArgs struct could not be generated from the wire representation.

func (*ConflictingNamesSetValueArgs) Encode added in v1.29.0 

func (v *ConflictingNamesSetValueArgs) Encode(sw stream.Writer) error

Encode serializes a ConflictingNamesSetValueArgs struct directly into bytes, without going through an intermediary type.

An error is returned if a ConflictingNamesSetValueArgs struct could not be encoded.

func (*ConflictingNamesSetValueArgs) Equals 

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

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

This function performs a deep comparison.

func (*ConflictingNamesSetValueArgs) FromWire 

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

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 added in v1.14.0 

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 

func (v *ConflictingNamesSetValueArgs) String() string

String returns a readable string representation of a ConflictingNamesSetValueArgs struct.

func (*ConflictingNamesSetValueArgs) ToWire 

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

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) Decode added in v1.29.0 

func (v *ConflictingNames_SetValue_Args) Decode(sr stream.Reader) error

Decode deserializes a ConflictingNames_SetValue_Args struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ConflictingNames_SetValue_Args struct could not be generated from the wire representation.

func (*ConflictingNames_SetValue_Args) Encode added in v1.29.0 

func (v *ConflictingNames_SetValue_Args) Encode(sw stream.Writer) error

Encode serializes a ConflictingNames_SetValue_Args struct directly into bytes, without going through an intermediary type.

An error is returned if a ConflictingNames_SetValue_Args struct could not be encoded.

func (*ConflictingNames_SetValue_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*ConflictingNames_SetValue_Args) Equals 

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

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 

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

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 

func (v *ConflictingNames_SetValue_Args) GetRequest() (o *ConflictingNamesSetValueArgs)

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

func (*ConflictingNames_SetValue_Args) IsSetRequest added in v1.14.0 

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 

func (v *ConflictingNames_SetValue_Args) String() string

String returns a readable string representation of a ConflictingNames_SetValue_Args struct.

func (*ConflictingNames_SetValue_Args) ToWire 

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

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) Decode added in v1.29.0 

func (v *ConflictingNames_SetValue_Result) Decode(sr stream.Reader) error

Decode deserializes a ConflictingNames_SetValue_Result struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ConflictingNames_SetValue_Result struct could not be generated from the wire representation.

func (*ConflictingNames_SetValue_Result) Encode added in v1.29.0 

func (v *ConflictingNames_SetValue_Result) Encode(sw stream.Writer) error

Encode serializes a ConflictingNames_SetValue_Result struct directly into bytes, without going through an intermediary type.

An error is returned if a ConflictingNames_SetValue_Result struct could not be encoded.

func (*ConflictingNames_SetValue_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*ConflictingNames_SetValue_Result) Equals 

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

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 

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

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 

func (v *ConflictingNames_SetValue_Result) String() string

String returns a readable string representation of a ConflictingNames_SetValue_Result struct.

func (*ConflictingNames_SetValue_Result) ToWire 

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

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) Decode added in v1.29.0 

func (v *InternalError) Decode(sr stream.Reader) error

Decode deserializes a InternalError struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a InternalError struct could not be generated from the wire representation.

func (*InternalError) Encode added in v1.29.0 

func (v *InternalError) Encode(sw stream.Writer) error

Encode serializes a InternalError struct directly into bytes, without going through an intermediary type.

An error is returned if a InternalError struct could not be encoded.

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 added in v1.21.0 

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 added in v1.14.0 

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) Decode added in v1.29.0 

func (v *Key) Decode(sr stream.Reader) error

Decode deserializes Key directly off the wire.

func (Key) Encode added in v1.29.0 

func (v Key) Encode(sw stream.Writer) error

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 added in v1.18.0 

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) Decode added in v1.29.0 

func (v *KeyValue_DeleteValue_Args) Decode(sr stream.Reader) error

Decode deserializes a KeyValue_DeleteValue_Args struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a KeyValue_DeleteValue_Args struct could not be generated from the wire representation.

func (*KeyValue_DeleteValue_Args) Encode added in v1.29.0 

func (v *KeyValue_DeleteValue_Args) Encode(sw stream.Writer) error

Encode serializes a KeyValue_DeleteValue_Args struct directly into bytes, without going through an intermediary type.

An error is returned if a KeyValue_DeleteValue_Args struct could not be encoded.

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 

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

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 added in v1.14.0 

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) Decode added in v1.29.0 

func (v *KeyValue_DeleteValue_Result) Decode(sr stream.Reader) error

Decode deserializes a KeyValue_DeleteValue_Result struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a KeyValue_DeleteValue_Result struct could not be generated from the wire representation.

func (*KeyValue_DeleteValue_Result) Encode added in v1.29.0 

func (v *KeyValue_DeleteValue_Result) Encode(sw stream.Writer) error

Encode serializes a KeyValue_DeleteValue_Result struct directly into bytes, without going through an intermediary type.

An error is returned if a KeyValue_DeleteValue_Result struct could not be encoded.

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 

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

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 

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

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 

func (v *KeyValue_DeleteValue_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_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 added in v1.14.0 

func (v *KeyValue_DeleteValue_Result) IsSetDoesNotExist() bool

IsSetDoesNotExist returns true if DoesNotExist is not nil.

func (*KeyValue_DeleteValue_Result) IsSetInternalError added in v1.14.0 

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 

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

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) Decode added in v1.29.0 

func (v *KeyValue_GetManyValues_Args) Decode(sr stream.Reader) error

Decode deserializes a KeyValue_GetManyValues_Args struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a KeyValue_GetManyValues_Args struct could not be generated from the wire representation.

func (*KeyValue_GetManyValues_Args) Encode added in v1.29.0 

func (v *KeyValue_GetManyValues_Args) Encode(sw stream.Writer) error

Encode serializes a KeyValue_GetManyValues_Args struct directly into bytes, without going through an intermediary type.

An error is returned if a KeyValue_GetManyValues_Args struct could not be encoded.

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 

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

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 

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

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 added in v1.14.0 

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 

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

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) Decode added in v1.29.0 

func (v *KeyValue_GetManyValues_Result) Decode(sr stream.Reader) error

Decode deserializes a KeyValue_GetManyValues_Result struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a KeyValue_GetManyValues_Result struct could not be generated from the wire representation.

func (*KeyValue_GetManyValues_Result) Encode added in v1.29.0 

func (v *KeyValue_GetManyValues_Result) Encode(sw stream.Writer) error

Encode serializes a KeyValue_GetManyValues_Result struct directly into bytes, without going through an intermediary type.

An error is returned if a KeyValue_GetManyValues_Result struct could not be encoded.

func (*KeyValue_GetManyValues_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*KeyValue_GetManyValues_Result) Equals 

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

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 

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

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 

func (v *KeyValue_GetManyValues_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_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 added in v1.14.0 

func (v *KeyValue_GetManyValues_Result) IsSetDoesNotExist() bool

IsSetDoesNotExist returns true if DoesNotExist is not nil.

func (*KeyValue_GetManyValues_Result) IsSetSuccess added in v1.14.0 

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 

func (v *KeyValue_GetManyValues_Result) String() string

String returns a readable string representation of a KeyValue_GetManyValues_Result struct.

func (*KeyValue_GetManyValues_Result) ToWire 

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

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) Decode added in v1.29.0 

func (v *KeyValue_GetValue_Args) Decode(sr stream.Reader) error

Decode deserializes a KeyValue_GetValue_Args struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a KeyValue_GetValue_Args struct could not be generated from the wire representation.

func (*KeyValue_GetValue_Args) Encode added in v1.29.0 

func (v *KeyValue_GetValue_Args) Encode(sw stream.Writer) error

Encode serializes a KeyValue_GetValue_Args struct directly into bytes, without going through an intermediary type.

An error is returned if a KeyValue_GetValue_Args struct could not be encoded.

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 

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

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 added in v1.14.0 

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) Decode added in v1.29.0 

func (v *KeyValue_GetValue_Result) Decode(sr stream.Reader) error

Decode deserializes a KeyValue_GetValue_Result struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a KeyValue_GetValue_Result struct could not be generated from the wire representation.

func (*KeyValue_GetValue_Result) Encode added in v1.29.0 

func (v *KeyValue_GetValue_Result) Encode(sw stream.Writer) error

Encode serializes a KeyValue_GetValue_Result struct directly into bytes, without going through an intermediary type.

An error is returned if a KeyValue_GetValue_Result struct could not be encoded.

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 

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

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 added in v1.14.0 

func (v *KeyValue_GetValue_Result) IsSetDoesNotExist() bool

IsSetDoesNotExist returns true if DoesNotExist is not nil.

func (*KeyValue_GetValue_Result) IsSetSuccess added in v1.14.0 

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) Decode added in v1.29.0 

func (v *KeyValue_SetValueV2_Args) Decode(sr stream.Reader) error

Decode deserializes a KeyValue_SetValueV2_Args struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a KeyValue_SetValueV2_Args struct could not be generated from the wire representation.

func (*KeyValue_SetValueV2_Args) Encode added in v1.29.0 

func (v *KeyValue_SetValueV2_Args) Encode(sw stream.Writer) error

Encode serializes a KeyValue_SetValueV2_Args struct directly into bytes, without going through an intermediary type.

An error is returned if a KeyValue_SetValueV2_Args struct could not be encoded.

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 

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

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 added in v1.14.0 

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) Decode added in v1.29.0 

func (v *KeyValue_SetValueV2_Result) Decode(sr stream.Reader) error

Decode deserializes a KeyValue_SetValueV2_Result struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a KeyValue_SetValueV2_Result struct could not be generated from the wire representation.

func (*KeyValue_SetValueV2_Result) Encode added in v1.29.0 

func (v *KeyValue_SetValueV2_Result) Encode(sw stream.Writer) error

Encode serializes a KeyValue_SetValueV2_Result struct directly into bytes, without going through an intermediary type.

An error is returned if a KeyValue_SetValueV2_Result struct could not be encoded.

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 

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

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) Decode added in v1.29.0 

func (v *KeyValue_SetValue_Args) Decode(sr stream.Reader) error

Decode deserializes a KeyValue_SetValue_Args struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a KeyValue_SetValue_Args struct could not be generated from the wire representation.

func (*KeyValue_SetValue_Args) Encode added in v1.29.0 

func (v *KeyValue_SetValue_Args) Encode(sw stream.Writer) error

Encode serializes a KeyValue_SetValue_Args struct directly into bytes, without going through an intermediary type.

An error is returned if a KeyValue_SetValue_Args struct could not be encoded.

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 

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

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 added in v1.14.0 

func (v *KeyValue_SetValue_Args) IsSetKey() bool

IsSetKey returns true if Key is not nil.

func (*KeyValue_SetValue_Args) IsSetValue added in v1.14.0 

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) Decode added in v1.29.0 

func (v *KeyValue_SetValue_Result) Decode(sr stream.Reader) error

Decode deserializes a KeyValue_SetValue_Result struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a KeyValue_SetValue_Result struct could not be generated from the wire representation.

func (*KeyValue_SetValue_Result) Encode added in v1.29.0 

func (v *KeyValue_SetValue_Result) Encode(sw stream.Writer) error

Encode serializes a KeyValue_SetValue_Result struct directly into bytes, without going through an intermediary type.

An error is returned if a KeyValue_SetValue_Result struct could not be encoded.

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 

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

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) Decode added in v1.29.0 

func (v *KeyValue_Size_Args) Decode(sr stream.Reader) error

Decode deserializes a KeyValue_Size_Args struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a KeyValue_Size_Args struct could not be generated from the wire representation.

func (*KeyValue_Size_Args) Encode added in v1.29.0 

func (v *KeyValue_Size_Args) Encode(sw stream.Writer) error

Encode serializes a KeyValue_Size_Args struct directly into bytes, without going through an intermediary type.

An error is returned if a KeyValue_Size_Args struct could not be encoded.

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) Decode added in v1.29.0 

func (v *KeyValue_Size_Result) Decode(sr stream.Reader) error

Decode deserializes a KeyValue_Size_Result struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a KeyValue_Size_Result struct could not be generated from the wire representation.

func (*KeyValue_Size_Result) Encode added in v1.29.0 

func (v *KeyValue_Size_Result) Encode(sw stream.Writer) error

Encode serializes a KeyValue_Size_Result struct directly into bytes, without going through an intermediary type.

An error is returned if a KeyValue_Size_Result struct could not be encoded.

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 

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

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 added in v1.14.0 

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) Decode added in v1.29.0 

func (v *NonStandardServiceName_NonStandardFunctionName_Args) Decode(sr stream.Reader) error

Decode deserializes a NonStandardServiceName_NonStandardFunctionName_Args struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a NonStandardServiceName_NonStandardFunctionName_Args struct could not be generated from the wire representation.

func (*NonStandardServiceName_NonStandardFunctionName_Args) Encode added in v1.29.0 

func (v *NonStandardServiceName_NonStandardFunctionName_Args) Encode(sw stream.Writer) error

Encode serializes a NonStandardServiceName_NonStandardFunctionName_Args struct directly into bytes, without going through an intermediary type.

An error is returned if a NonStandardServiceName_NonStandardFunctionName_Args struct could not be encoded.

func (*NonStandardServiceName_NonStandardFunctionName_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*NonStandardServiceName_NonStandardFunctionName_Args) Equals 

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

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 

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

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 

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

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

func (*NonStandardServiceName_NonStandardFunctionName_Args) MethodName 

func (v *NonStandardServiceName_NonStandardFunctionName_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 "non_standard_function_name" for this struct.

func (*NonStandardServiceName_NonStandardFunctionName_Args) String 

func (v *NonStandardServiceName_NonStandardFunctionName_Args) String() string

String returns a readable string representation of a NonStandardServiceName_NonStandardFunctionName_Args struct.

func (*NonStandardServiceName_NonStandardFunctionName_Args) ToWire 

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

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) Decode added in v1.29.0 

func (v *NonStandardServiceName_NonStandardFunctionName_Result) Decode(sr stream.Reader) error

Decode deserializes a NonStandardServiceName_NonStandardFunctionName_Result struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a NonStandardServiceName_NonStandardFunctionName_Result struct could not be generated from the wire representation.

func (*NonStandardServiceName_NonStandardFunctionName_Result) Encode added in v1.29.0 

func (v *NonStandardServiceName_NonStandardFunctionName_Result) Encode(sw stream.Writer) error

Encode serializes a NonStandardServiceName_NonStandardFunctionName_Result struct directly into bytes, without going through an intermediary type.

An error is returned if a NonStandardServiceName_NonStandardFunctionName_Result struct could not be encoded.

func (*NonStandardServiceName_NonStandardFunctionName_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*NonStandardServiceName_NonStandardFunctionName_Result) Equals 

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

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 

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

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 

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

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

func (*NonStandardServiceName_NonStandardFunctionName_Result) MethodName 

func (v *NonStandardServiceName_NonStandardFunctionName_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 "non_standard_function_name" for this struct.

func (*NonStandardServiceName_NonStandardFunctionName_Result) String 

func (v *NonStandardServiceName_NonStandardFunctionName_Result) String() string

String returns a readable string representation of a NonStandardServiceName_NonStandardFunctionName_Result struct.

func (*NonStandardServiceName_NonStandardFunctionName_Result) ToWire 

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

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

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.