Back to godoc.org

Package services

v1.20.2
Latest Go to latest
Published: Oct 17, 2019 | License: MIT | Module: github.com/thriftrw/thriftrw-go

Index

Package Files

Variables

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

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

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

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

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) 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

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) 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) 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) 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

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

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

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

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

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) 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

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) 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

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

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) 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

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

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

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

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

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

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) 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

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

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) 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

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

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

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) 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
}
Documentation was rendered with GOOS=linux and GOARCH=amd64.

Jump to identifier

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to identifier