baz

package
v2.0.13 Latest Latest
Warning

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

 Go to latest Published: Mar 19, 2024 License: MIT Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var SimpleService_AnotherCall_Helper = struct {
	// Args accepts the parameters of AnotherCall in-order and returns
	// the arguments struct for the function.
	Args func(
		arg *BazRequest,
		i64Optional *int64,
		testUUID *UUID,
	) *SimpleService_AnotherCall_Args

	// IsException returns true if the given error can be thrown
	// by AnotherCall.
	//
	// An error can be thrown by AnotherCall 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 AnotherCall
	// given the error returned by it. The provided error may
	// be nil if AnotherCall did not fail.
	//
	// This allows mapping errors returned by AnotherCall into a
	// serializable result struct. WrapResponse returns a
	// non-nil error if the provided error cannot be thrown by
	// AnotherCall
	//
	//   err := AnotherCall(args)
	//   result, err := SimpleService_AnotherCall_Helper.WrapResponse(err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from AnotherCall: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(error) (*SimpleService_AnotherCall_Result, error)

	// UnwrapResponse takes the result struct for AnotherCall
	// and returns the erorr returned by it (if any).
	//
	// The error is non-nil only if AnotherCall threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   err := SimpleService_AnotherCall_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SimpleService_AnotherCall_Result) error
}{}

SimpleService_AnotherCall_Helper provides functions that aid in handling the parameters and return values of the SimpleService.AnotherCall function.

View Source 
var SimpleService_Call_Helper = struct {
	// Args accepts the parameters of Call in-order and returns
	// the arguments struct for the function.
	Args func(
		arg *BazRequest,
		i64Optional *int64,
		testUUID *UUID,
	) *SimpleService_Call_Args

	// IsException returns true if the given error can be thrown
	// by Call.
	//
	// An error can be thrown by Call 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 Call
	// given the error returned by it. The provided error may
	// be nil if Call did not fail.
	//
	// This allows mapping errors returned by Call into a
	// serializable result struct. WrapResponse returns a
	// non-nil error if the provided error cannot be thrown by
	// Call
	//
	//   err := Call(args)
	//   result, err := SimpleService_Call_Helper.WrapResponse(err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from Call: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(error) (*SimpleService_Call_Result, error)

	// UnwrapResponse takes the result struct for Call
	// and returns the erorr returned by it (if any).
	//
	// The error is non-nil only if Call threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   err := SimpleService_Call_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SimpleService_Call_Result) error
}{}

SimpleService_Call_Helper provides functions that aid in handling the parameters and return values of the SimpleService.Call function.

View Source 
var SimpleService_Compare_Helper = struct {
	// Args accepts the parameters of Compare in-order and returns
	// the arguments struct for the function.
	Args func(
		arg1 *BazRequest,
		arg2 *BazRequest,
	) *SimpleService_Compare_Args

	// IsException returns true if the given error can be thrown
	// by Compare.
	//
	// An error can be thrown by Compare 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 Compare
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// Compare into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by Compare
	//
	//   value, err := Compare(args)
	//   result, err := SimpleService_Compare_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from Compare: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(*BazResponse, error) (*SimpleService_Compare_Result, error)

	// UnwrapResponse takes the result struct for Compare
	// and returns the value or error returned by it.
	//
	// The error is non-nil only if Compare threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   value, err := SimpleService_Compare_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SimpleService_Compare_Result) (*BazResponse, error)
}{}

SimpleService_Compare_Helper provides functions that aid in handling the parameters and return values of the SimpleService.Compare function.

View Source 
var SimpleService_Echo_Helper = struct {
	// Args accepts the parameters of Echo in-order and returns
	// the arguments struct for the function.
	Args func(
		msg string,
	) *SimpleService_Echo_Args

	// IsException returns true if the given error can be thrown
	// by Echo.
	//
	// An error can be thrown by Echo 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 Echo
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// Echo into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by Echo
	//
	//   value, err := Echo(args)
	//   result, err := SimpleService_Echo_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from Echo: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(string, error) (*SimpleService_Echo_Result, error)

	// UnwrapResponse takes the result struct for Echo
	// and returns the value or error returned by it.
	//
	// The error is non-nil only if Echo threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   value, err := SimpleService_Echo_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SimpleService_Echo_Result) (string, error)
}{}

SimpleService_Echo_Helper provides functions that aid in handling the parameters and return values of the SimpleService.Echo function.

View Source 
var SimpleService_Ping_Helper = struct {
	// Args accepts the parameters of Ping in-order and returns
	// the arguments struct for the function.
	Args func() *SimpleService_Ping_Args

	// IsException returns true if the given error can be thrown
	// by Ping.
	//
	// An error can be thrown by Ping 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 Ping
	// given its return value and error.
	//
	// This allows mapping values and errors returned by
	// Ping into a serializable result struct.
	// WrapResponse returns a non-nil error if the provided
	// error cannot be thrown by Ping
	//
	//   value, err := Ping(args)
	//   result, err := SimpleService_Ping_Helper.WrapResponse(value, err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from Ping: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(*BazResponse, error) (*SimpleService_Ping_Result, error)

	// UnwrapResponse takes the result struct for Ping
	// and returns the value or error returned by it.
	//
	// The error is non-nil only if Ping threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   value, err := SimpleService_Ping_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SimpleService_Ping_Result) (*BazResponse, error)
}{}

SimpleService_Ping_Helper provides functions that aid in handling the parameters and return values of the SimpleService.Ping function.

View Source 
var SimpleService_SillyNoop_Helper = struct {
	// Args accepts the parameters of SillyNoop in-order and returns
	// the arguments struct for the function.
	Args func() *SimpleService_SillyNoop_Args

	// IsException returns true if the given error can be thrown
	// by SillyNoop.
	//
	// An error can be thrown by SillyNoop 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 SillyNoop
	// given the error returned by it. The provided error may
	// be nil if SillyNoop did not fail.
	//
	// This allows mapping errors returned by SillyNoop into a
	// serializable result struct. WrapResponse returns a
	// non-nil error if the provided error cannot be thrown by
	// SillyNoop
	//
	//   err := SillyNoop(args)
	//   result, err := SimpleService_SillyNoop_Helper.WrapResponse(err)
	//   if err != nil {
	//     return fmt.Errorf("unexpected error from SillyNoop: %v", err)
	//   }
	//   serialize(result)
	WrapResponse func(error) (*SimpleService_SillyNoop_Result, error)

	// UnwrapResponse takes the result struct for SillyNoop
	// and returns the erorr returned by it (if any).
	//
	// The error is non-nil only if SillyNoop threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   err := SimpleService_SillyNoop_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SimpleService_SillyNoop_Result) error
}{}

SimpleService_SillyNoop_Helper provides functions that aid in handling the parameters and return values of the SimpleService.SillyNoop function.

Functions

This section is empty.

Types

type AuthErr 

type AuthErr struct {
	Message string `json:"message,required"`
}

func (*AuthErr) Decode 

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

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

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

func (*AuthErr) Encode 

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

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

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

func (*AuthErr) Equals 

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

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

This function performs a deep comparison.

func (*AuthErr) Error 

func (v *AuthErr) Error() string

func (*AuthErr) ErrorName 

func (*AuthErr) ErrorName() string

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

func (*AuthErr) FromWire 

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

FromWire deserializes a AuthErr 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 AuthErr struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
  return nil, err
}

var v AuthErr
if err := v.FromWire(x); err != nil {
  return nil, err
}
return &v, nil

func (*AuthErr) GetMessage 

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

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

func (*AuthErr) MarshalLogObject 

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

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

func (*AuthErr) String 

func (v *AuthErr) String() string

String returns a readable string representation of a AuthErr struct.

func (*AuthErr) ToWire 

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

ToWire translates a AuthErr 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 BazRequest 

type BazRequest struct {
	B1 bool   `json:"b1,required"`
	S2 string `json:"s2,required"`
	I3 int32  `json:"i3,required"`
}

func (*BazRequest) Decode 

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

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

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

func (*BazRequest) Encode 

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

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

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

func (*BazRequest) Equals 

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

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

This function performs a deep comparison.

func (*BazRequest) FromWire 

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

FromWire deserializes a BazRequest 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 BazRequest struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
  return nil, err
}

var v BazRequest
if err := v.FromWire(x); err != nil {
  return nil, err
}
return &v, nil

func (*BazRequest) GetB1 

func (v *BazRequest) GetB1() (o bool)

GetB1 returns the value of B1 if it is set or its zero value if it is unset.

func (*BazRequest) GetI3 

func (v *BazRequest) GetI3() (o int32)

GetI3 returns the value of I3 if it is set or its zero value if it is unset.

func (*BazRequest) GetS2 

func (v *BazRequest) GetS2() (o string)

GetS2 returns the value of S2 if it is set or its zero value if it is unset.

func (*BazRequest) MarshalLogObject 

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

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

func (*BazRequest) String 

func (v *BazRequest) String() string

String returns a readable string representation of a BazRequest struct.

func (*BazRequest) ToWire 

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

ToWire translates a BazRequest 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 BazResponse 

type BazResponse struct {
	Message string `json:"message,required"`
}

func (*BazResponse) Decode 

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

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

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

func (*BazResponse) Encode 

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

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

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

func (*BazResponse) Equals 

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

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

This function performs a deep comparison.

func (*BazResponse) FromWire 

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

FromWire deserializes a BazResponse 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 BazResponse struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
  return nil, err
}

var v BazResponse
if err := v.FromWire(x); err != nil {
  return nil, err
}
return &v, nil

func (*BazResponse) GetMessage 

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

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

func (*BazResponse) MarshalLogObject 

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

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

func (*BazResponse) String 

func (v *BazResponse) String() string

String returns a readable string representation of a BazResponse struct.

func (*BazResponse) ToWire 

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

ToWire translates a BazResponse 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 ServerErr 

type ServerErr struct {
	Message string `json:"message,required"`
}

func (*ServerErr) Decode 

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

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

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

func (*ServerErr) Encode 

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

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

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

func (*ServerErr) Equals 

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

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

This function performs a deep comparison.

func (*ServerErr) Error 

func (v *ServerErr) Error() string

func (*ServerErr) ErrorName 

func (*ServerErr) ErrorName() string

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

func (*ServerErr) FromWire 

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

FromWire deserializes a ServerErr 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 ServerErr struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
  return nil, err
}

var v ServerErr
if err := v.FromWire(x); err != nil {
  return nil, err
}
return &v, nil

func (*ServerErr) GetMessage 

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

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

func (*ServerErr) MarshalLogObject 

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

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

func (*ServerErr) String 

func (v *ServerErr) String() string

String returns a readable string representation of a ServerErr struct.

func (*ServerErr) ToWire 

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

ToWire translates a ServerErr 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 SimpleService_AnotherCall_Args 

type SimpleService_AnotherCall_Args struct {
	Arg         *BazRequest `json:"arg,required"`
	I64Optional *int64      `json:"i64Optional,omitempty"`
	TestUUID    *UUID       `json:"testUUID,omitempty"`
}

SimpleService_AnotherCall_Args represents the arguments for the SimpleService.AnotherCall function.

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

func (*SimpleService_AnotherCall_Args) Decode 

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

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

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

func (*SimpleService_AnotherCall_Args) Encode 

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

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

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

func (*SimpleService_AnotherCall_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SimpleService_AnotherCall_Args) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_AnotherCall_Args) FromWire 

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

FromWire deserializes a SimpleService_AnotherCall_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 SimpleService_AnotherCall_Args struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
  return nil, err
}

var v SimpleService_AnotherCall_Args
if err := v.FromWire(x); err != nil {
  return nil, err
}
return &v, nil

func (*SimpleService_AnotherCall_Args) GetArg 

func (v *SimpleService_AnotherCall_Args) GetArg() (o *BazRequest)

GetArg returns the value of Arg if it is set or its zero value if it is unset.

func (*SimpleService_AnotherCall_Args) GetI64Optional 

func (v *SimpleService_AnotherCall_Args) GetI64Optional() (o int64)

GetI64Optional returns the value of I64Optional if it is set or its zero value if it is unset.

func (*SimpleService_AnotherCall_Args) GetTestUUID 

func (v *SimpleService_AnotherCall_Args) GetTestUUID() (o UUID)

GetTestUUID returns the value of TestUUID if it is set or its zero value if it is unset.

func (*SimpleService_AnotherCall_Args) IsSetArg 

func (v *SimpleService_AnotherCall_Args) IsSetArg() bool

IsSetArg returns true if Arg is not nil.

func (*SimpleService_AnotherCall_Args) IsSetI64Optional 

func (v *SimpleService_AnotherCall_Args) IsSetI64Optional() bool

IsSetI64Optional returns true if I64Optional is not nil.

func (*SimpleService_AnotherCall_Args) IsSetTestUUID 

func (v *SimpleService_AnotherCall_Args) IsSetTestUUID() bool

IsSetTestUUID returns true if TestUUID is not nil.

func (*SimpleService_AnotherCall_Args) MarshalLogObject 

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

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

func (*SimpleService_AnotherCall_Args) MethodName 

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

func (*SimpleService_AnotherCall_Args) String 

func (v *SimpleService_AnotherCall_Args) String() string

String returns a readable string representation of a SimpleService_AnotherCall_Args struct.

func (*SimpleService_AnotherCall_Args) ToWire 

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

ToWire translates a SimpleService_AnotherCall_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 SimpleService_AnotherCall_Result 

type SimpleService_AnotherCall_Result struct {
	AuthErr *AuthErr `json:"authErr,omitempty"`
}

SimpleService_AnotherCall_Result represents the result of a SimpleService.AnotherCall function call.

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

func (*SimpleService_AnotherCall_Result) Decode 

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

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

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

func (*SimpleService_AnotherCall_Result) Encode 

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

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

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

func (*SimpleService_AnotherCall_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SimpleService_AnotherCall_Result) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_AnotherCall_Result) FromWire 

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

FromWire deserializes a SimpleService_AnotherCall_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 SimpleService_AnotherCall_Result struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
  return nil, err
}

var v SimpleService_AnotherCall_Result
if err := v.FromWire(x); err != nil {
  return nil, err
}
return &v, nil

func (*SimpleService_AnotherCall_Result) GetAuthErr 

func (v *SimpleService_AnotherCall_Result) GetAuthErr() (o *AuthErr)

GetAuthErr returns the value of AuthErr if it is set or its zero value if it is unset.

func (*SimpleService_AnotherCall_Result) IsSetAuthErr 

func (v *SimpleService_AnotherCall_Result) IsSetAuthErr() bool

IsSetAuthErr returns true if AuthErr is not nil.

func (*SimpleService_AnotherCall_Result) MarshalLogObject 

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

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

func (*SimpleService_AnotherCall_Result) MethodName 

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

func (*SimpleService_AnotherCall_Result) String 

func (v *SimpleService_AnotherCall_Result) String() string

String returns a readable string representation of a SimpleService_AnotherCall_Result struct.

func (*SimpleService_AnotherCall_Result) ToWire 

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

ToWire translates a SimpleService_AnotherCall_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 SimpleService_Call_Args 

type SimpleService_Call_Args struct {
	Arg         *BazRequest `json:"arg,required"`
	I64Optional *int64      `json:"i64Optional,omitempty"`
	TestUUID    *UUID       `json:"testUUID,omitempty"`
}

SimpleService_Call_Args represents the arguments for the SimpleService.Call function.

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

func (*SimpleService_Call_Args) Decode 

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

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

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

func (*SimpleService_Call_Args) Encode 

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

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

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

func (*SimpleService_Call_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SimpleService_Call_Args) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_Call_Args) FromWire 

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

FromWire deserializes a SimpleService_Call_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 SimpleService_Call_Args struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
  return nil, err
}

var v SimpleService_Call_Args
if err := v.FromWire(x); err != nil {
  return nil, err
}
return &v, nil

func (*SimpleService_Call_Args) GetArg 

func (v *SimpleService_Call_Args) GetArg() (o *BazRequest)

GetArg returns the value of Arg if it is set or its zero value if it is unset.

func (*SimpleService_Call_Args) GetI64Optional 

func (v *SimpleService_Call_Args) GetI64Optional() (o int64)

GetI64Optional returns the value of I64Optional if it is set or its zero value if it is unset.

func (*SimpleService_Call_Args) GetTestUUID 

func (v *SimpleService_Call_Args) GetTestUUID() (o UUID)

GetTestUUID returns the value of TestUUID if it is set or its zero value if it is unset.

func (*SimpleService_Call_Args) IsSetArg 

func (v *SimpleService_Call_Args) IsSetArg() bool

IsSetArg returns true if Arg is not nil.

func (*SimpleService_Call_Args) IsSetI64Optional 

func (v *SimpleService_Call_Args) IsSetI64Optional() bool

IsSetI64Optional returns true if I64Optional is not nil.

func (*SimpleService_Call_Args) IsSetTestUUID 

func (v *SimpleService_Call_Args) IsSetTestUUID() bool

IsSetTestUUID returns true if TestUUID is not nil.

func (*SimpleService_Call_Args) MarshalLogObject 

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

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

func (*SimpleService_Call_Args) MethodName 

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

func (*SimpleService_Call_Args) String 

func (v *SimpleService_Call_Args) String() string

String returns a readable string representation of a SimpleService_Call_Args struct.

func (*SimpleService_Call_Args) ToWire 

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

ToWire translates a SimpleService_Call_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 SimpleService_Call_Result 

type SimpleService_Call_Result struct {
	AuthErr *AuthErr `json:"authErr,omitempty"`
}

SimpleService_Call_Result represents the result of a SimpleService.Call function call.

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

func (*SimpleService_Call_Result) Decode 

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

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

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

func (*SimpleService_Call_Result) Encode 

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

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

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

func (*SimpleService_Call_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SimpleService_Call_Result) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_Call_Result) FromWire 

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

FromWire deserializes a SimpleService_Call_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 SimpleService_Call_Result struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
  return nil, err
}

var v SimpleService_Call_Result
if err := v.FromWire(x); err != nil {
  return nil, err
}
return &v, nil

func (*SimpleService_Call_Result) GetAuthErr 

func (v *SimpleService_Call_Result) GetAuthErr() (o *AuthErr)

GetAuthErr returns the value of AuthErr if it is set or its zero value if it is unset.

func (*SimpleService_Call_Result) IsSetAuthErr 

func (v *SimpleService_Call_Result) IsSetAuthErr() bool

IsSetAuthErr returns true if AuthErr is not nil.

func (*SimpleService_Call_Result) MarshalLogObject 

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

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

func (*SimpleService_Call_Result) MethodName 

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

func (*SimpleService_Call_Result) String 

func (v *SimpleService_Call_Result) String() string

String returns a readable string representation of a SimpleService_Call_Result struct.

func (*SimpleService_Call_Result) ToWire 

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

ToWire translates a SimpleService_Call_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 SimpleService_Compare_Args 

type SimpleService_Compare_Args struct {
	Arg1 *BazRequest `json:"arg1,required"`
	Arg2 *BazRequest `json:"arg2,required"`
}

SimpleService_Compare_Args represents the arguments for the SimpleService.Compare function.

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

func (*SimpleService_Compare_Args) Decode 

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

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

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

func (*SimpleService_Compare_Args) Encode 

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

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

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

func (*SimpleService_Compare_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SimpleService_Compare_Args) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_Compare_Args) FromWire 

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

FromWire deserializes a SimpleService_Compare_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 SimpleService_Compare_Args struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
  return nil, err
}

var v SimpleService_Compare_Args
if err := v.FromWire(x); err != nil {
  return nil, err
}
return &v, nil

func (*SimpleService_Compare_Args) GetArg1 

func (v *SimpleService_Compare_Args) GetArg1() (o *BazRequest)

GetArg1 returns the value of Arg1 if it is set or its zero value if it is unset.

func (*SimpleService_Compare_Args) GetArg2 

func (v *SimpleService_Compare_Args) GetArg2() (o *BazRequest)

GetArg2 returns the value of Arg2 if it is set or its zero value if it is unset.

func (*SimpleService_Compare_Args) IsSetArg1 

func (v *SimpleService_Compare_Args) IsSetArg1() bool

IsSetArg1 returns true if Arg1 is not nil.

func (*SimpleService_Compare_Args) IsSetArg2 

func (v *SimpleService_Compare_Args) IsSetArg2() bool

IsSetArg2 returns true if Arg2 is not nil.

func (*SimpleService_Compare_Args) MarshalLogObject 

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

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

func (*SimpleService_Compare_Args) MethodName 

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

func (*SimpleService_Compare_Args) String 

func (v *SimpleService_Compare_Args) String() string

String returns a readable string representation of a SimpleService_Compare_Args struct.

func (*SimpleService_Compare_Args) ToWire 

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

ToWire translates a SimpleService_Compare_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 SimpleService_Compare_Result 

type SimpleService_Compare_Result struct {
	// Value returned by Compare after a successful execution.
	Success *BazResponse `json:"success,omitempty"`
	AuthErr *AuthErr     `json:"authErr,omitempty"`
}

SimpleService_Compare_Result represents the result of a SimpleService.Compare function call.

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

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

func (*SimpleService_Compare_Result) Decode 

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

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

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

func (*SimpleService_Compare_Result) Encode 

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

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

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

func (*SimpleService_Compare_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SimpleService_Compare_Result) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_Compare_Result) FromWire 

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

FromWire deserializes a SimpleService_Compare_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 SimpleService_Compare_Result struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
  return nil, err
}

var v SimpleService_Compare_Result
if err := v.FromWire(x); err != nil {
  return nil, err
}
return &v, nil

func (*SimpleService_Compare_Result) GetAuthErr 

func (v *SimpleService_Compare_Result) GetAuthErr() (o *AuthErr)

GetAuthErr returns the value of AuthErr if it is set or its zero value if it is unset.

func (*SimpleService_Compare_Result) GetSuccess 

func (v *SimpleService_Compare_Result) GetSuccess() (o *BazResponse)

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

func (*SimpleService_Compare_Result) IsSetAuthErr 

func (v *SimpleService_Compare_Result) IsSetAuthErr() bool

IsSetAuthErr returns true if AuthErr is not nil.

func (*SimpleService_Compare_Result) IsSetSuccess 

func (v *SimpleService_Compare_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SimpleService_Compare_Result) MarshalLogObject 

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

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

func (*SimpleService_Compare_Result) MethodName 

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

func (*SimpleService_Compare_Result) String 

func (v *SimpleService_Compare_Result) String() string

String returns a readable string representation of a SimpleService_Compare_Result struct.

func (*SimpleService_Compare_Result) ToWire 

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

ToWire translates a SimpleService_Compare_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 SimpleService_Echo_Args 

type SimpleService_Echo_Args struct {
	Msg string `json:"msg,required"`
}

SimpleService_Echo_Args represents the arguments for the SimpleService.Echo function.

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

func (*SimpleService_Echo_Args) Decode 

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

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

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

func (*SimpleService_Echo_Args) Encode 

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

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

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

func (*SimpleService_Echo_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SimpleService_Echo_Args) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_Echo_Args) FromWire 

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

FromWire deserializes a SimpleService_Echo_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 SimpleService_Echo_Args struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
  return nil, err
}

var v SimpleService_Echo_Args
if err := v.FromWire(x); err != nil {
  return nil, err
}
return &v, nil

func (*SimpleService_Echo_Args) GetMsg 

func (v *SimpleService_Echo_Args) GetMsg() (o string)

GetMsg returns the value of Msg if it is set or its zero value if it is unset.

func (*SimpleService_Echo_Args) MarshalLogObject 

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

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

func (*SimpleService_Echo_Args) MethodName 

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

func (*SimpleService_Echo_Args) String 

func (v *SimpleService_Echo_Args) String() string

String returns a readable string representation of a SimpleService_Echo_Args struct.

func (*SimpleService_Echo_Args) ToWire 

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

ToWire translates a SimpleService_Echo_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 SimpleService_Echo_Result 

type SimpleService_Echo_Result struct {
	// Value returned by Echo after a successful execution.
	Success *string `json:"success,omitempty"`
}

SimpleService_Echo_Result represents the result of a SimpleService.Echo function call.

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

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

func (*SimpleService_Echo_Result) Decode 

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

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

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

func (*SimpleService_Echo_Result) Encode 

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

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

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

func (*SimpleService_Echo_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SimpleService_Echo_Result) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_Echo_Result) FromWire 

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

FromWire deserializes a SimpleService_Echo_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 SimpleService_Echo_Result struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
  return nil, err
}

var v SimpleService_Echo_Result
if err := v.FromWire(x); err != nil {
  return nil, err
}
return &v, nil

func (*SimpleService_Echo_Result) GetSuccess 

func (v *SimpleService_Echo_Result) GetSuccess() (o string)

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

func (*SimpleService_Echo_Result) IsSetSuccess 

func (v *SimpleService_Echo_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SimpleService_Echo_Result) MarshalLogObject 

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

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

func (*SimpleService_Echo_Result) MethodName 

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

func (*SimpleService_Echo_Result) String 

func (v *SimpleService_Echo_Result) String() string

String returns a readable string representation of a SimpleService_Echo_Result struct.

func (*SimpleService_Echo_Result) ToWire 

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

ToWire translates a SimpleService_Echo_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 SimpleService_Ping_Args 

type SimpleService_Ping_Args struct {
}

SimpleService_Ping_Args represents the arguments for the SimpleService.Ping function.

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

func (*SimpleService_Ping_Args) Decode 

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

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

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

func (*SimpleService_Ping_Args) Encode 

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

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

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

func (*SimpleService_Ping_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SimpleService_Ping_Args) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_Ping_Args) FromWire 

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

FromWire deserializes a SimpleService_Ping_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 SimpleService_Ping_Args struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
  return nil, err
}

var v SimpleService_Ping_Args
if err := v.FromWire(x); err != nil {
  return nil, err
}
return &v, nil

func (*SimpleService_Ping_Args) MarshalLogObject 

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

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

func (*SimpleService_Ping_Args) MethodName 

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

func (*SimpleService_Ping_Args) String 

func (v *SimpleService_Ping_Args) String() string

String returns a readable string representation of a SimpleService_Ping_Args struct.

func (*SimpleService_Ping_Args) ToWire 

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

ToWire translates a SimpleService_Ping_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 SimpleService_Ping_Result 

type SimpleService_Ping_Result struct {
	// Value returned by Ping after a successful execution.
	Success *BazResponse `json:"success,omitempty"`
}

SimpleService_Ping_Result represents the result of a SimpleService.Ping function call.

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

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

func (*SimpleService_Ping_Result) Decode 

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

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

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

func (*SimpleService_Ping_Result) Encode 

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

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

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

func (*SimpleService_Ping_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SimpleService_Ping_Result) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_Ping_Result) FromWire 

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

FromWire deserializes a SimpleService_Ping_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 SimpleService_Ping_Result struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
  return nil, err
}

var v SimpleService_Ping_Result
if err := v.FromWire(x); err != nil {
  return nil, err
}
return &v, nil

func (*SimpleService_Ping_Result) GetSuccess 

func (v *SimpleService_Ping_Result) GetSuccess() (o *BazResponse)

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

func (*SimpleService_Ping_Result) IsSetSuccess 

func (v *SimpleService_Ping_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SimpleService_Ping_Result) MarshalLogObject 

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

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

func (*SimpleService_Ping_Result) MethodName 

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

func (*SimpleService_Ping_Result) String 

func (v *SimpleService_Ping_Result) String() string

String returns a readable string representation of a SimpleService_Ping_Result struct.

func (*SimpleService_Ping_Result) ToWire 

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

ToWire translates a SimpleService_Ping_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 SimpleService_SillyNoop_Args 

type SimpleService_SillyNoop_Args struct {
}

SimpleService_SillyNoop_Args represents the arguments for the SimpleService.SillyNoop function.

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

func (*SimpleService_SillyNoop_Args) Decode 

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

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

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

func (*SimpleService_SillyNoop_Args) Encode 

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

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

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

func (*SimpleService_SillyNoop_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SimpleService_SillyNoop_Args) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_SillyNoop_Args) FromWire 

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

FromWire deserializes a SimpleService_SillyNoop_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 SimpleService_SillyNoop_Args struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
  return nil, err
}

var v SimpleService_SillyNoop_Args
if err := v.FromWire(x); err != nil {
  return nil, err
}
return &v, nil

func (*SimpleService_SillyNoop_Args) MarshalLogObject 

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

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

func (*SimpleService_SillyNoop_Args) MethodName 

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

func (*SimpleService_SillyNoop_Args) String 

func (v *SimpleService_SillyNoop_Args) String() string

String returns a readable string representation of a SimpleService_SillyNoop_Args struct.

func (*SimpleService_SillyNoop_Args) ToWire 

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

ToWire translates a SimpleService_SillyNoop_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 SimpleService_SillyNoop_Result 

type SimpleService_SillyNoop_Result struct {
	AuthErr   *AuthErr   `json:"authErr,omitempty"`
	ServerErr *ServerErr `json:"serverErr,omitempty"`
}

SimpleService_SillyNoop_Result represents the result of a SimpleService.SillyNoop function call.

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

func (*SimpleService_SillyNoop_Result) Decode 

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

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

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

func (*SimpleService_SillyNoop_Result) Encode 

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

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

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

func (*SimpleService_SillyNoop_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SimpleService_SillyNoop_Result) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_SillyNoop_Result) FromWire 

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

FromWire deserializes a SimpleService_SillyNoop_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 SimpleService_SillyNoop_Result struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
  return nil, err
}

var v SimpleService_SillyNoop_Result
if err := v.FromWire(x); err != nil {
  return nil, err
}
return &v, nil

func (*SimpleService_SillyNoop_Result) GetAuthErr 

func (v *SimpleService_SillyNoop_Result) GetAuthErr() (o *AuthErr)

GetAuthErr returns the value of AuthErr if it is set or its zero value if it is unset.

func (*SimpleService_SillyNoop_Result) GetServerErr 

func (v *SimpleService_SillyNoop_Result) GetServerErr() (o *ServerErr)

GetServerErr returns the value of ServerErr if it is set or its zero value if it is unset.

func (*SimpleService_SillyNoop_Result) IsSetAuthErr 

func (v *SimpleService_SillyNoop_Result) IsSetAuthErr() bool

IsSetAuthErr returns true if AuthErr is not nil.

func (*SimpleService_SillyNoop_Result) IsSetServerErr 

func (v *SimpleService_SillyNoop_Result) IsSetServerErr() bool

IsSetServerErr returns true if ServerErr is not nil.

func (*SimpleService_SillyNoop_Result) MarshalLogObject 

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

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

func (*SimpleService_SillyNoop_Result) MethodName 

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

func (*SimpleService_SillyNoop_Result) String 

func (v *SimpleService_SillyNoop_Result) String() string

String returns a readable string representation of a SimpleService_SillyNoop_Result struct.

func (*SimpleService_SillyNoop_Result) ToWire 

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

ToWire translates a SimpleService_SillyNoop_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 UUID 

type UUID string

func (*UUID) Decode 

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

Decode deserializes UUID directly off the wire.

func (UUID) Encode 

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

func (UUID) Equals 

func (lhs UUID) Equals(rhs UUID) bool

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

func (*UUID) FromWire 

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

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

func (UUID) Ptr 

func (v UUID) Ptr() *UUID

UUIDPtr returns a pointer to a UUID

func (UUID) String 

func (v UUID) String() string

String returns a readable string representation of UUID.

func (UUID) ToWire 

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

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

Source Files

View all Source files

Jump to

Keyboard shortcuts

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