thriftrw: go.uber.org/thriftrw/gen/internal/tests/services Index | Files

package services

import "go.uber.org/thriftrw/gen/internal/tests/services"

Index

Package Files

services.go

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v *Cache_ClearAfter_Args) IsSetDurationMS() bool

IsSetDurationMS returns true if DurationMS is not nil.

func (*Cache_ClearAfter_Args) MarshalLogObject Uses

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 Uses

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 Uses

func (v *Cache_ClearAfter_Args) String() string

String returns a readable string representation of a Cache_ClearAfter_Args struct.

func (*Cache_ClearAfter_Args) ToWire Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v *Cache_Clear_Args) String() string

String returns a readable string representation of a Cache_Clear_Args struct.

func (*Cache_Clear_Args) ToWire Uses

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 Uses

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

func (*ConflictingNamesSetValueArgs) Equals Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v *ConflictingNamesSetValueArgs) IsSetValue() bool

IsSetValue returns true if Value is not nil.

func (*ConflictingNamesSetValueArgs) MarshalLogObject Uses

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

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

func (*ConflictingNamesSetValueArgs) String Uses

func (v *ConflictingNamesSetValueArgs) String() string

String returns a readable string representation of a ConflictingNamesSetValueArgs struct.

func (*ConflictingNamesSetValueArgs) ToWire Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v *ConflictingNames_SetValue_Args) IsSetRequest() bool

IsSetRequest returns true if Request is not nil.

func (*ConflictingNames_SetValue_Args) MarshalLogObject Uses

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 Uses

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 Uses

func (v *ConflictingNames_SetValue_Args) String() string

String returns a readable string representation of a ConflictingNames_SetValue_Args struct.

func (*ConflictingNames_SetValue_Args) ToWire Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v *ConflictingNames_SetValue_Result) String() string

String returns a readable string representation of a ConflictingNames_SetValue_Result struct.

func (*ConflictingNames_SetValue_Result) ToWire Uses

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 Uses

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

func (*InternalError) Equals Uses

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 Uses

func (v *InternalError) Error() string

func (*InternalError) ErrorName Uses

func (*InternalError) ErrorName() string

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

func (*InternalError) FromWire Uses

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 Uses

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 Uses

func (v *InternalError) IsSetMessage() bool

IsSetMessage returns true if Message is not nil.

func (*InternalError) MarshalLogObject Uses

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

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

func (*InternalError) String Uses

func (v *InternalError) String() string

String returns a readable string representation of a InternalError struct.

func (*InternalError) ToWire Uses

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 Uses

type Key string

func (Key) Equals Uses

func (lhs Key) Equals(rhs Key) bool

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

func (*Key) FromWire Uses

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 Uses

func (v Key) Ptr() *Key

KeyPtr returns a pointer to a Key

func (Key) String Uses

func (v Key) String() string

String returns a readable string representation of Key.

func (Key) ToWire Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v *KeyValue_DeleteValue_Args) IsSetKey() bool

IsSetKey returns true if Key is not nil.

func (*KeyValue_DeleteValue_Args) MarshalLogObject Uses

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 Uses

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 Uses

func (v *KeyValue_DeleteValue_Args) String() string

String returns a readable string representation of a KeyValue_DeleteValue_Args struct.

func (*KeyValue_DeleteValue_Args) ToWire Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v *KeyValue_DeleteValue_Result) IsSetDoesNotExist() bool

IsSetDoesNotExist returns true if DoesNotExist is not nil.

func (*KeyValue_DeleteValue_Result) IsSetInternalError Uses

func (v *KeyValue_DeleteValue_Result) IsSetInternalError() bool

IsSetInternalError returns true if InternalError is not nil.

func (*KeyValue_DeleteValue_Result) MarshalLogObject Uses

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 Uses

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 Uses

func (v *KeyValue_DeleteValue_Result) String() string

String returns a readable string representation of a KeyValue_DeleteValue_Result struct.

func (*KeyValue_DeleteValue_Result) ToWire Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v *KeyValue_GetManyValues_Args) IsSetRange() bool

IsSetRange returns true if Range is not nil.

func (*KeyValue_GetManyValues_Args) MarshalLogObject Uses

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 Uses

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 Uses

func (v *KeyValue_GetManyValues_Args) String() string

String returns a readable string representation of a KeyValue_GetManyValues_Args struct.

func (*KeyValue_GetManyValues_Args) ToWire Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v *KeyValue_GetManyValues_Result) IsSetDoesNotExist() bool

IsSetDoesNotExist returns true if DoesNotExist is not nil.

func (*KeyValue_GetManyValues_Result) IsSetSuccess Uses

func (v *KeyValue_GetManyValues_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*KeyValue_GetManyValues_Result) MarshalLogObject Uses

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 Uses

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 Uses

func (v *KeyValue_GetManyValues_Result) String() string

String returns a readable string representation of a KeyValue_GetManyValues_Result struct.

func (*KeyValue_GetManyValues_Result) ToWire Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v *KeyValue_GetValue_Args) IsSetKey() bool

IsSetKey returns true if Key is not nil.

func (*KeyValue_GetValue_Args) MarshalLogObject Uses

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 Uses

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 Uses

func (v *KeyValue_GetValue_Args) String() string

String returns a readable string representation of a KeyValue_GetValue_Args struct.

func (*KeyValue_GetValue_Args) ToWire Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v *KeyValue_GetValue_Result) IsSetDoesNotExist() bool

IsSetDoesNotExist returns true if DoesNotExist is not nil.

func (*KeyValue_GetValue_Result) IsSetSuccess Uses

func (v *KeyValue_GetValue_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*KeyValue_GetValue_Result) MarshalLogObject Uses

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 Uses

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 Uses

func (v *KeyValue_GetValue_Result) String() string

String returns a readable string representation of a KeyValue_GetValue_Result struct.

func (*KeyValue_GetValue_Result) ToWire Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v *KeyValue_SetValueV2_Args) IsSetValue() bool

IsSetValue returns true if Value is not nil.

func (*KeyValue_SetValueV2_Args) MarshalLogObject Uses

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 Uses

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 Uses

func (v *KeyValue_SetValueV2_Args) String() string

String returns a readable string representation of a KeyValue_SetValueV2_Args struct.

func (*KeyValue_SetValueV2_Args) ToWire Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v *KeyValue_SetValueV2_Result) String() string

String returns a readable string representation of a KeyValue_SetValueV2_Result struct.

func (*KeyValue_SetValueV2_Result) ToWire Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v *KeyValue_SetValue_Args) IsSetKey() bool

IsSetKey returns true if Key is not nil.

func (*KeyValue_SetValue_Args) IsSetValue Uses

func (v *KeyValue_SetValue_Args) IsSetValue() bool

IsSetValue returns true if Value is not nil.

func (*KeyValue_SetValue_Args) MarshalLogObject Uses

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 Uses

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 Uses

func (v *KeyValue_SetValue_Args) String() string

String returns a readable string representation of a KeyValue_SetValue_Args struct.

func (*KeyValue_SetValue_Args) ToWire Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v *KeyValue_SetValue_Result) String() string

String returns a readable string representation of a KeyValue_SetValue_Result struct.

func (*KeyValue_SetValue_Result) ToWire Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v *KeyValue_Size_Args) String() string

String returns a readable string representation of a KeyValue_Size_Args struct.

func (*KeyValue_Size_Args) ToWire Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v *KeyValue_Size_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*KeyValue_Size_Result) MarshalLogObject Uses

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 Uses

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 Uses

func (v *KeyValue_Size_Result) String() string

String returns a readable string representation of a KeyValue_Size_Result struct.

func (*KeyValue_Size_Result) ToWire Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v *NonStandardServiceName_NonStandardFunctionName_Args) String() string

String returns a readable string representation of a NonStandardServiceName_NonStandardFunctionName_Args struct.

func (*NonStandardServiceName_NonStandardFunctionName_Args) ToWire Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v *NonStandardServiceName_NonStandardFunctionName_Result) String() string

String returns a readable string representation of a NonStandardServiceName_NonStandardFunctionName_Result struct.

func (*NonStandardServiceName_NonStandardFunctionName_Result) ToWire Uses

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
}

Package services imports 11 packages (graph). Updated 2020-01-25. Refresh now. Tools for package owners.