baz

package
v1.0.1 Latest Latest
Warning

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

 Go to latest Published: Aug 19, 2021 License: MIT Imports: 12 Imported by: 15

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var SecondService_EchoBinary_Helper = struct {
	// Args accepts the parameters of echoBinary in-order and returns
	// the arguments struct for the function.
	Args func(
		arg []byte,
	) *SecondService_EchoBinary_Args

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

	// UnwrapResponse takes the result struct for echoBinary
	// and returns the value or error returned by it.
	//
	// The error is non-nil only if echoBinary threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   value, err := SecondService_EchoBinary_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SecondService_EchoBinary_Result) ([]byte, error)
}{}

SecondService_EchoBinary_Helper provides functions that aid in handling the parameters and return values of the SecondService.echoBinary function.

View Source 
var SecondService_EchoBool_Helper = struct {
	// Args accepts the parameters of echoBool in-order and returns
	// the arguments struct for the function.
	Args func(
		arg bool,
	) *SecondService_EchoBool_Args

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

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

SecondService_EchoBool_Helper provides functions that aid in handling the parameters and return values of the SecondService.echoBool function.

View Source 
var SecondService_EchoDouble_Helper = struct {
	// Args accepts the parameters of echoDouble in-order and returns
	// the arguments struct for the function.
	Args func(
		arg float64,
	) *SecondService_EchoDouble_Args

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

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

SecondService_EchoDouble_Helper provides functions that aid in handling the parameters and return values of the SecondService.echoDouble function.

View Source 
var SecondService_EchoEnum_Helper = struct {
	// Args accepts the parameters of echoEnum in-order and returns
	// the arguments struct for the function.
	Args func(
		arg *Fruit,
	) *SecondService_EchoEnum_Args

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

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

SecondService_EchoEnum_Helper provides functions that aid in handling the parameters and return values of the SecondService.echoEnum function.

View Source 
var SecondService_EchoI16_Helper = struct {
	// Args accepts the parameters of echoI16 in-order and returns
	// the arguments struct for the function.
	Args func(
		arg int16,
	) *SecondService_EchoI16_Args

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

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

SecondService_EchoI16_Helper provides functions that aid in handling the parameters and return values of the SecondService.echoI16 function.

View Source 
var SecondService_EchoI32_Helper = struct {
	// Args accepts the parameters of echoI32 in-order and returns
	// the arguments struct for the function.
	Args func(
		arg int32,
	) *SecondService_EchoI32_Args

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

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

SecondService_EchoI32_Helper provides functions that aid in handling the parameters and return values of the SecondService.echoI32 function.

View Source 
var SecondService_EchoI64_Helper = struct {
	// Args accepts the parameters of echoI64 in-order and returns
	// the arguments struct for the function.
	Args func(
		arg int64,
	) *SecondService_EchoI64_Args

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

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

SecondService_EchoI64_Helper provides functions that aid in handling the parameters and return values of the SecondService.echoI64 function.

View Source 
var SecondService_EchoI8_Helper = struct {
	// Args accepts the parameters of echoI8 in-order and returns
	// the arguments struct for the function.
	Args func(
		arg int8,
	) *SecondService_EchoI8_Args

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

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

SecondService_EchoI8_Helper provides functions that aid in handling the parameters and return values of the SecondService.echoI8 function.

View Source 
var SecondService_EchoStringList_Helper = struct {
	// Args accepts the parameters of echoStringList in-order and returns
	// the arguments struct for the function.
	Args func(
		arg []string,
	) *SecondService_EchoStringList_Args

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

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

SecondService_EchoStringList_Helper provides functions that aid in handling the parameters and return values of the SecondService.echoStringList function.

View Source 
var SecondService_EchoStringMap_Helper = struct {
	// Args accepts the parameters of echoStringMap in-order and returns
	// the arguments struct for the function.
	Args func(
		arg map[string]*base.BazResponse,
	) *SecondService_EchoStringMap_Args

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

	// UnwrapResponse takes the result struct for echoStringMap
	// and returns the value or error returned by it.
	//
	// The error is non-nil only if echoStringMap threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   value, err := SecondService_EchoStringMap_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SecondService_EchoStringMap_Result) (map[string]*base.BazResponse, error)
}{}

SecondService_EchoStringMap_Helper provides functions that aid in handling the parameters and return values of the SecondService.echoStringMap function.

View Source 
var SecondService_EchoStringSet_Helper = struct {
	// Args accepts the parameters of echoStringSet in-order and returns
	// the arguments struct for the function.
	Args func(
		arg map[string]struct{},
	) *SecondService_EchoStringSet_Args

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

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

SecondService_EchoStringSet_Helper provides functions that aid in handling the parameters and return values of the SecondService.echoStringSet function.

View Source 
var SecondService_EchoString_Helper = struct {
	// Args accepts the parameters of echoString in-order and returns
	// the arguments struct for the function.
	Args func(
		arg string,
	) *SecondService_EchoString_Args

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

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

SecondService_EchoString_Helper provides functions that aid in handling the parameters and return values of the SecondService.echoString function.

View Source 
var SecondService_EchoStructList_Helper = struct {
	// Args accepts the parameters of echoStructList in-order and returns
	// the arguments struct for the function.
	Args func(
		arg []*base.BazResponse,
	) *SecondService_EchoStructList_Args

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

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

SecondService_EchoStructList_Helper provides functions that aid in handling the parameters and return values of the SecondService.echoStructList function.

View Source 
var SecondService_EchoStructMap_Helper = struct {
	// Args accepts the parameters of echoStructMap in-order and returns
	// the arguments struct for the function.
	Args func(
		arg []struct {
			Key   *base.BazResponse
			Value string
		},
	) *SecondService_EchoStructMap_Args

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

	// UnwrapResponse takes the result struct for echoStructMap
	// and returns the value or error returned by it.
	//
	// The error is non-nil only if echoStructMap threw an
	// exception.
	//
	//   result := deserialize(bytes)
	//   value, err := SecondService_EchoStructMap_Helper.UnwrapResponse(result)
	UnwrapResponse func(*SecondService_EchoStructMap_Result) ([]struct {
		Key   *base.BazResponse
		Value string
	}, error)
}{}

SecondService_EchoStructMap_Helper provides functions that aid in handling the parameters and return values of the SecondService.echoStructMap function.

View Source 
var SecondService_EchoStructSet_Helper = struct {
	// Args accepts the parameters of echoStructSet in-order and returns
	// the arguments struct for the function.
	Args func(
		arg []*base.BazResponse,
	) *SecondService_EchoStructSet_Args

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

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

SecondService_EchoStructSet_Helper provides functions that aid in handling the parameters and return values of the SecondService.echoStructSet function.

View Source 
var SecondService_EchoTypedef_Helper = struct {
	// Args accepts the parameters of echoTypedef in-order and returns
	// the arguments struct for the function.
	Args func(
		arg base.UUID,
	) *SecondService_EchoTypedef_Args

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

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

SecondService_EchoTypedef_Helper provides functions that aid in handling the parameters and return values of the SecondService.echoTypedef function.

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(*base.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) (*base.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_GetProfile_Helper = struct {
	// Args accepts the parameters of getProfile in-order and returns
	// the arguments struct for the function.
	Args func(
		request *GetProfileRequest,
	) *SimpleService_GetProfile_Args

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

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

SimpleService_GetProfile_Helper provides functions that aid in handling the parameters and return values of the SimpleService.getProfile function.

View Source 
var SimpleService_HeaderSchema_Helper = struct {
	// Args accepts the parameters of headerSchema in-order and returns
	// the arguments struct for the function.
	Args func(
		req *HeaderSchema,
	) *SimpleService_HeaderSchema_Args

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

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

SimpleService_HeaderSchema_Helper provides functions that aid in handling the parameters and return values of the SimpleService.headerSchema 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(*base.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) (*base.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.

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

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

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

SimpleService_TestUuid_Helper provides functions that aid in handling the parameters and return values of the SimpleService.testUuid function.

View Source 
var SimpleService_TransHeadersNoReq_Helper = struct {
	// Args accepts the parameters of transHeadersNoReq in-order and returns
	// the arguments struct for the function.
	Args func(
		req *base.NestedStruct,
		s2 *string,
		i3 int32,
		b4 *bool,
	) *SimpleService_TransHeadersNoReq_Args

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

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

SimpleService_TransHeadersNoReq_Helper provides functions that aid in handling the parameters and return values of the SimpleService.transHeadersNoReq function.

View Source 
var SimpleService_TransHeadersType_Helper = struct {
	// Args accepts the parameters of transHeadersType in-order and returns
	// the arguments struct for the function.
	Args func(
		req *TransHeaderType,
	) *SimpleService_TransHeadersType_Args

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

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

SimpleService_TransHeadersType_Helper provides functions that aid in handling the parameters and return values of the SimpleService.transHeadersType function.

View Source 
var SimpleService_TransHeaders_Helper = struct {
	// Args accepts the parameters of transHeaders in-order and returns
	// the arguments struct for the function.
	Args func(
		req *base.TransHeaders,
	) *SimpleService_TransHeaders_Args

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

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

SimpleService_TransHeaders_Helper provides functions that aid in handling the parameters and return values of the SimpleService.transHeaders function.

View Source 
var SimpleService_Trans_Helper = struct {
	// Args accepts the parameters of trans in-order and returns
	// the arguments struct for the function.
	Args func(
		arg1 *base.TransStruct,
		arg2 *base.TransStruct,
	) *SimpleService_Trans_Args

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

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

SimpleService_Trans_Helper provides functions that aid in handling the parameters and return values of the SimpleService.trans function.

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

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

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

SimpleService_UrlTest_Helper provides functions that aid in handling the parameters and return values of the SimpleService.urlTest function.

Functions

This section is empty.

Types

type AuthErr 

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

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

type Fruit int32
const (
	FruitApple  Fruit = 0
	FruitBanana Fruit = 1
)

func Fruit_Values 

func Fruit_Values() []Fruit

Fruit_Values returns all recognized values of Fruit.

func (Fruit) Equals 

func (v Fruit) Equals(rhs Fruit) bool

Equals returns true if this Fruit value matches the provided value.

func (*Fruit) FromWire 

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

FromWire deserializes Fruit from its Thrift-level representation. 

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

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

func (Fruit) MarshalJSON 

func (v Fruit) MarshalJSON() ([]byte, error)

MarshalJSON serializes Fruit into JSON.

If the enum value is recognized, its name is returned. Otherwise, its integer value is returned.

This implements json.Marshaler.

func (Fruit) MarshalLogObject 

func (v Fruit) MarshalLogObject(enc zapcore.ObjectEncoder) error

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of Fruit. Enums are logged as objects, where the value is logged with key "value", and if this value's name is known, the name is logged with key "name".

func (Fruit) MarshalText 

func (v Fruit) MarshalText() ([]byte, error)

MarshalText encodes Fruit to text.

If the enum value is recognized, its name is returned. Otherwise, its integer value is returned.

This implements the TextMarshaler interface.

func (Fruit) Ptr 

func (v Fruit) Ptr() *Fruit

Ptr returns a pointer to this enum value.

func (Fruit) String 

func (v Fruit) String() string

String returns a readable string representation of Fruit.

func (Fruit) ToWire 

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

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

Enums are represented as 32-bit integers over the wire.

func (*Fruit) UnmarshalJSON 

func (v *Fruit) UnmarshalJSON(text []byte) error

UnmarshalJSON attempts to decode Fruit from its JSON representation.

This implementation supports both, numeric and string inputs. If a string is provided, it must be a known enum name.

This implements json.Unmarshaler.

func (*Fruit) UnmarshalText 

func (v *Fruit) UnmarshalText(value []byte) error

UnmarshalText tries to decode Fruit from a byte slice containing its name. 

var v Fruit
err := v.UnmarshalText([]byte("APPLE"))

type GetProfileRequest 

type GetProfileRequest struct {
	Target UUID `json:"target,required"`
}

func (*GetProfileRequest) Equals 

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

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

This function performs a deep comparison.

func (*GetProfileRequest) FromWire 

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

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

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

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

func (*GetProfileRequest) GetTarget 

func (v *GetProfileRequest) GetTarget() (o UUID)

GetTarget returns the value of Target if it is set or its zero value if it is unset.

func (*GetProfileRequest) MarshalLogObject 

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

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

func (*GetProfileRequest) String 

func (v *GetProfileRequest) String() string

String returns a readable string representation of a GetProfileRequest struct.

func (*GetProfileRequest) ToWire 

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

ToWire translates a GetProfileRequest 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 GetProfileResponse 

type GetProfileResponse struct {
	Payloads []*Profile `json:"payloads,required"`
}

func (*GetProfileResponse) Equals 

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

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

This function performs a deep comparison.

func (*GetProfileResponse) FromWire 

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

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

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

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

func (*GetProfileResponse) GetPayloads 

func (v *GetProfileResponse) GetPayloads() (o []*Profile)

GetPayloads returns the value of Payloads if it is set or its zero value if it is unset.

func (*GetProfileResponse) IsSetPayloads 

func (v *GetProfileResponse) IsSetPayloads() bool

IsSetPayloads returns true if Payloads is not nil.

func (*GetProfileResponse) MarshalLogObject 

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

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

func (*GetProfileResponse) String 

func (v *GetProfileResponse) String() string

String returns a readable string representation of a GetProfileResponse struct.

func (*GetProfileResponse) ToWire 

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

ToWire translates a GetProfileResponse 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 HeaderSchema 

type HeaderSchema struct {
}

func (*HeaderSchema) Equals 

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

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

This function performs a deep comparison.

func (*HeaderSchema) FromWire 

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

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

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

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

func (*HeaderSchema) MarshalLogObject 

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

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

func (*HeaderSchema) String 

func (v *HeaderSchema) String() string

String returns a readable string representation of a HeaderSchema struct.

func (*HeaderSchema) ToWire 

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

ToWire translates a HeaderSchema 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 OtherAuthErr 

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

func (*OtherAuthErr) Equals 

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

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

This function performs a deep comparison.

func (*OtherAuthErr) Error 

func (v *OtherAuthErr) Error() string

func (*OtherAuthErr) ErrorName 

func (*OtherAuthErr) ErrorName() string

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

func (*OtherAuthErr) FromWire 

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

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

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

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

func (*OtherAuthErr) GetMessage 

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

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

func (*OtherAuthErr) MarshalLogObject 

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

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

func (*OtherAuthErr) String 

func (v *OtherAuthErr) String() string

String returns a readable string representation of a OtherAuthErr struct.

func (*OtherAuthErr) ToWire 

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

ToWire translates a OtherAuthErr 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 Profile 

type Profile struct {
	Recur1 *Recur1 `json:"recur1,required"`
}

func (*Profile) Equals 

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

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

This function performs a deep comparison.

func (*Profile) FromWire 

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

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

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

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

func (*Profile) GetRecur1 

func (v *Profile) GetRecur1() (o *Recur1)

GetRecur1 returns the value of Recur1 if it is set or its zero value if it is unset.

func (*Profile) IsSetRecur1 

func (v *Profile) IsSetRecur1() bool

IsSetRecur1 returns true if Recur1 is not nil.

func (*Profile) MarshalLogObject 

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

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

func (*Profile) String 

func (v *Profile) String() string

String returns a readable string representation of a Profile struct.

func (*Profile) ToWire 

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

ToWire translates a Profile 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 Recur1 

type Recur1 struct {
	Field1 map[UUID]*Recur2 `json:"field1,required"`
}

func (*Recur1) Equals 

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

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

This function performs a deep comparison.

func (*Recur1) FromWire 

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

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

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

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

func (*Recur1) GetField1 

func (v *Recur1) GetField1() (o map[UUID]*Recur2)

GetField1 returns the value of Field1 if it is set or its zero value if it is unset.

func (*Recur1) IsSetField1 

func (v *Recur1) IsSetField1() bool

IsSetField1 returns true if Field1 is not nil.

func (*Recur1) MarshalLogObject 

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

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

func (*Recur1) String 

func (v *Recur1) String() string

String returns a readable string representation of a Recur1 struct.

func (*Recur1) ToWire 

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

ToWire translates a Recur1 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 Recur2 

type Recur2 struct {
	Field21 *Recur3 `json:"field21,required"`
	Field22 *Recur3 `json:"field22,omitempty"`
}

func (*Recur2) Equals 

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

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

This function performs a deep comparison.

func (*Recur2) FromWire 

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

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

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

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

func (*Recur2) GetField21 

func (v *Recur2) GetField21() (o *Recur3)

GetField21 returns the value of Field21 if it is set or its zero value if it is unset.

func (*Recur2) GetField22 

func (v *Recur2) GetField22() (o *Recur3)

GetField22 returns the value of Field22 if it is set or its zero value if it is unset.

func (*Recur2) IsSetField21 

func (v *Recur2) IsSetField21() bool

IsSetField21 returns true if Field21 is not nil.

func (*Recur2) IsSetField22 

func (v *Recur2) IsSetField22() bool

IsSetField22 returns true if Field22 is not nil.

func (*Recur2) MarshalLogObject 

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

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

func (*Recur2) String 

func (v *Recur2) String() string

String returns a readable string representation of a Recur2 struct.

func (*Recur2) ToWire 

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

ToWire translates a Recur2 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 Recur3 

type Recur3 struct {
	Field31 UUID `json:"field31,required"`
}

func (*Recur3) Equals 

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

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

This function performs a deep comparison.

func (*Recur3) FromWire 

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

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

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

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

func (*Recur3) GetField31 

func (v *Recur3) GetField31() (o UUID)

GetField31 returns the value of Field31 if it is set or its zero value if it is unset.

func (*Recur3) MarshalLogObject 

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

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

func (*Recur3) String 

func (v *Recur3) String() string

String returns a readable string representation of a Recur3 struct.

func (*Recur3) ToWire 

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

ToWire translates a Recur3 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 SecondService_EchoBinary_Args 

type SecondService_EchoBinary_Args struct {
	Arg []byte `json:"arg,required"`
}

SecondService_EchoBinary_Args represents the arguments for the SecondService.echoBinary function.

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

func (*SecondService_EchoBinary_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SecondService_EchoBinary_Args) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoBinary_Args) FromWire 

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

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

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

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

func (*SecondService_EchoBinary_Args) GetArg 

func (v *SecondService_EchoBinary_Args) GetArg() (o []byte)

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

func (*SecondService_EchoBinary_Args) IsSetArg 

func (v *SecondService_EchoBinary_Args) IsSetArg() bool

IsSetArg returns true if Arg is not nil.

func (*SecondService_EchoBinary_Args) MarshalLogObject 

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

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

func (*SecondService_EchoBinary_Args) MethodName 

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

func (*SecondService_EchoBinary_Args) String 

func (v *SecondService_EchoBinary_Args) String() string

String returns a readable string representation of a SecondService_EchoBinary_Args struct.

func (*SecondService_EchoBinary_Args) ToWire 

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

ToWire translates a SecondService_EchoBinary_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 SecondService_EchoBinary_Result 

type SecondService_EchoBinary_Result struct {
	// Value returned by echoBinary after a successful execution.
	Success []byte `json:"success,omitempty"`
}

SecondService_EchoBinary_Result represents the result of a SecondService.echoBinary function call.

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

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

func (*SecondService_EchoBinary_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SecondService_EchoBinary_Result) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoBinary_Result) FromWire 

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

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

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

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

func (*SecondService_EchoBinary_Result) GetSuccess 

func (v *SecondService_EchoBinary_Result) GetSuccess() (o []byte)

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

func (*SecondService_EchoBinary_Result) IsSetSuccess 

func (v *SecondService_EchoBinary_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SecondService_EchoBinary_Result) MarshalLogObject 

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

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

func (*SecondService_EchoBinary_Result) MethodName 

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

func (*SecondService_EchoBinary_Result) String 

func (v *SecondService_EchoBinary_Result) String() string

String returns a readable string representation of a SecondService_EchoBinary_Result struct.

func (*SecondService_EchoBinary_Result) ToWire 

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

ToWire translates a SecondService_EchoBinary_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 SecondService_EchoBool_Args 

type SecondService_EchoBool_Args struct {
	Arg bool `json:"arg,required"`
}

SecondService_EchoBool_Args represents the arguments for the SecondService.echoBool function.

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

func (*SecondService_EchoBool_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SecondService_EchoBool_Args) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoBool_Args) FromWire 

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

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

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

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

func (*SecondService_EchoBool_Args) GetArg 

func (v *SecondService_EchoBool_Args) GetArg() (o bool)

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

func (*SecondService_EchoBool_Args) MarshalLogObject 

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

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

func (*SecondService_EchoBool_Args) MethodName 

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

func (*SecondService_EchoBool_Args) String 

func (v *SecondService_EchoBool_Args) String() string

String returns a readable string representation of a SecondService_EchoBool_Args struct.

func (*SecondService_EchoBool_Args) ToWire 

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

ToWire translates a SecondService_EchoBool_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 SecondService_EchoBool_Result 

type SecondService_EchoBool_Result struct {
	// Value returned by echoBool after a successful execution.
	Success *bool `json:"success,omitempty"`
}

SecondService_EchoBool_Result represents the result of a SecondService.echoBool function call.

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

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

func (*SecondService_EchoBool_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SecondService_EchoBool_Result) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoBool_Result) FromWire 

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

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

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

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

func (*SecondService_EchoBool_Result) GetSuccess 

func (v *SecondService_EchoBool_Result) GetSuccess() (o bool)

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

func (*SecondService_EchoBool_Result) IsSetSuccess 

func (v *SecondService_EchoBool_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SecondService_EchoBool_Result) MarshalLogObject 

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

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

func (*SecondService_EchoBool_Result) MethodName 

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

func (*SecondService_EchoBool_Result) String 

func (v *SecondService_EchoBool_Result) String() string

String returns a readable string representation of a SecondService_EchoBool_Result struct.

func (*SecondService_EchoBool_Result) ToWire 

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

ToWire translates a SecondService_EchoBool_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 SecondService_EchoDouble_Args 

type SecondService_EchoDouble_Args struct {
	Arg float64 `json:"arg,required"`
}

SecondService_EchoDouble_Args represents the arguments for the SecondService.echoDouble function.

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

func (*SecondService_EchoDouble_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SecondService_EchoDouble_Args) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoDouble_Args) FromWire 

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

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

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

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

func (*SecondService_EchoDouble_Args) GetArg 

func (v *SecondService_EchoDouble_Args) GetArg() (o float64)

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

func (*SecondService_EchoDouble_Args) MarshalLogObject 

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

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

func (*SecondService_EchoDouble_Args) MethodName 

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

func (*SecondService_EchoDouble_Args) String 

func (v *SecondService_EchoDouble_Args) String() string

String returns a readable string representation of a SecondService_EchoDouble_Args struct.

func (*SecondService_EchoDouble_Args) ToWire 

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

ToWire translates a SecondService_EchoDouble_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 SecondService_EchoDouble_Result 

type SecondService_EchoDouble_Result struct {
	// Value returned by echoDouble after a successful execution.
	Success *float64 `json:"success,omitempty"`
}

SecondService_EchoDouble_Result represents the result of a SecondService.echoDouble function call.

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

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

func (*SecondService_EchoDouble_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SecondService_EchoDouble_Result) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoDouble_Result) FromWire 

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

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

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

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

func (*SecondService_EchoDouble_Result) GetSuccess 

func (v *SecondService_EchoDouble_Result) GetSuccess() (o float64)

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

func (*SecondService_EchoDouble_Result) IsSetSuccess 

func (v *SecondService_EchoDouble_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SecondService_EchoDouble_Result) MarshalLogObject 

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

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

func (*SecondService_EchoDouble_Result) MethodName 

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

func (*SecondService_EchoDouble_Result) String 

func (v *SecondService_EchoDouble_Result) String() string

String returns a readable string representation of a SecondService_EchoDouble_Result struct.

func (*SecondService_EchoDouble_Result) ToWire 

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

ToWire translates a SecondService_EchoDouble_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 SecondService_EchoEnum_Args 

type SecondService_EchoEnum_Args struct {
	Arg *Fruit `json:"arg,omitempty"`
}

SecondService_EchoEnum_Args represents the arguments for the SecondService.echoEnum function.

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

func Default_SecondService_EchoEnum_Args added in v1.0.0 

func Default_SecondService_EchoEnum_Args() *SecondService_EchoEnum_Args

Default_SecondService_EchoEnum_Args constructs a new SecondService_EchoEnum_Args struct, pre-populating any fields with defined default values.

func (*SecondService_EchoEnum_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SecondService_EchoEnum_Args) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoEnum_Args) FromWire 

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

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

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

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

func (*SecondService_EchoEnum_Args) GetArg 

func (v *SecondService_EchoEnum_Args) GetArg() (o Fruit)

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

func (*SecondService_EchoEnum_Args) IsSetArg 

func (v *SecondService_EchoEnum_Args) IsSetArg() bool

IsSetArg returns true if Arg is not nil.

func (*SecondService_EchoEnum_Args) MarshalLogObject 

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

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

func (*SecondService_EchoEnum_Args) MethodName 

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

func (*SecondService_EchoEnum_Args) String 

func (v *SecondService_EchoEnum_Args) String() string

String returns a readable string representation of a SecondService_EchoEnum_Args struct.

func (*SecondService_EchoEnum_Args) ToWire 

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

ToWire translates a SecondService_EchoEnum_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 SecondService_EchoEnum_Result 

type SecondService_EchoEnum_Result struct {
	// Value returned by echoEnum after a successful execution.
	Success *Fruit `json:"success,omitempty"`
}

SecondService_EchoEnum_Result represents the result of a SecondService.echoEnum function call.

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

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

func (*SecondService_EchoEnum_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SecondService_EchoEnum_Result) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoEnum_Result) FromWire 

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

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

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

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

func (*SecondService_EchoEnum_Result) GetSuccess 

func (v *SecondService_EchoEnum_Result) GetSuccess() (o Fruit)

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

func (*SecondService_EchoEnum_Result) IsSetSuccess 

func (v *SecondService_EchoEnum_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SecondService_EchoEnum_Result) MarshalLogObject 

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

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

func (*SecondService_EchoEnum_Result) MethodName 

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

func (*SecondService_EchoEnum_Result) String 

func (v *SecondService_EchoEnum_Result) String() string

String returns a readable string representation of a SecondService_EchoEnum_Result struct.

func (*SecondService_EchoEnum_Result) ToWire 

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

ToWire translates a SecondService_EchoEnum_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 SecondService_EchoI16_Args 

type SecondService_EchoI16_Args struct {
	Arg int16 `json:"arg,required"`
}

SecondService_EchoI16_Args represents the arguments for the SecondService.echoI16 function.

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

func (*SecondService_EchoI16_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SecondService_EchoI16_Args) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoI16_Args) FromWire 

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

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

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

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

func (*SecondService_EchoI16_Args) GetArg 

func (v *SecondService_EchoI16_Args) GetArg() (o int16)

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

func (*SecondService_EchoI16_Args) MarshalLogObject 

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

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

func (*SecondService_EchoI16_Args) MethodName 

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

func (*SecondService_EchoI16_Args) String 

func (v *SecondService_EchoI16_Args) String() string

String returns a readable string representation of a SecondService_EchoI16_Args struct.

func (*SecondService_EchoI16_Args) ToWire 

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

ToWire translates a SecondService_EchoI16_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 SecondService_EchoI16_Result 

type SecondService_EchoI16_Result struct {
	// Value returned by echoI16 after a successful execution.
	Success *int16 `json:"success,omitempty"`
}

SecondService_EchoI16_Result represents the result of a SecondService.echoI16 function call.

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

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

func (*SecondService_EchoI16_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SecondService_EchoI16_Result) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoI16_Result) FromWire 

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

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

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

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

func (*SecondService_EchoI16_Result) GetSuccess 

func (v *SecondService_EchoI16_Result) GetSuccess() (o int16)

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

func (*SecondService_EchoI16_Result) IsSetSuccess 

func (v *SecondService_EchoI16_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SecondService_EchoI16_Result) MarshalLogObject 

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

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

func (*SecondService_EchoI16_Result) MethodName 

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

func (*SecondService_EchoI16_Result) String 

func (v *SecondService_EchoI16_Result) String() string

String returns a readable string representation of a SecondService_EchoI16_Result struct.

func (*SecondService_EchoI16_Result) ToWire 

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

ToWire translates a SecondService_EchoI16_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 SecondService_EchoI32_Args 

type SecondService_EchoI32_Args struct {
	Arg int32 `json:"arg,required"`
}

SecondService_EchoI32_Args represents the arguments for the SecondService.echoI32 function.

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

func (*SecondService_EchoI32_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SecondService_EchoI32_Args) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoI32_Args) FromWire 

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

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

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

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

func (*SecondService_EchoI32_Args) GetArg 

func (v *SecondService_EchoI32_Args) GetArg() (o int32)

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

func (*SecondService_EchoI32_Args) MarshalLogObject 

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

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

func (*SecondService_EchoI32_Args) MethodName 

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

func (*SecondService_EchoI32_Args) String 

func (v *SecondService_EchoI32_Args) String() string

String returns a readable string representation of a SecondService_EchoI32_Args struct.

func (*SecondService_EchoI32_Args) ToWire 

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

ToWire translates a SecondService_EchoI32_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 SecondService_EchoI32_Result 

type SecondService_EchoI32_Result struct {
	// Value returned by echoI32 after a successful execution.
	Success *int32 `json:"success,omitempty"`
}

SecondService_EchoI32_Result represents the result of a SecondService.echoI32 function call.

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

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

func (*SecondService_EchoI32_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SecondService_EchoI32_Result) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoI32_Result) FromWire 

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

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

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

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

func (*SecondService_EchoI32_Result) GetSuccess 

func (v *SecondService_EchoI32_Result) GetSuccess() (o int32)

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

func (*SecondService_EchoI32_Result) IsSetSuccess 

func (v *SecondService_EchoI32_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SecondService_EchoI32_Result) MarshalLogObject 

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

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

func (*SecondService_EchoI32_Result) MethodName 

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

func (*SecondService_EchoI32_Result) String 

func (v *SecondService_EchoI32_Result) String() string

String returns a readable string representation of a SecondService_EchoI32_Result struct.

func (*SecondService_EchoI32_Result) ToWire 

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

ToWire translates a SecondService_EchoI32_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 SecondService_EchoI64_Args 

type SecondService_EchoI64_Args struct {
	Arg int64 `json:"arg,required"`
}

SecondService_EchoI64_Args represents the arguments for the SecondService.echoI64 function.

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

func (*SecondService_EchoI64_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SecondService_EchoI64_Args) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoI64_Args) FromWire 

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

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

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

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

func (*SecondService_EchoI64_Args) GetArg 

func (v *SecondService_EchoI64_Args) GetArg() (o int64)

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

func (*SecondService_EchoI64_Args) MarshalLogObject 

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

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

func (*SecondService_EchoI64_Args) MethodName 

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

func (*SecondService_EchoI64_Args) String 

func (v *SecondService_EchoI64_Args) String() string

String returns a readable string representation of a SecondService_EchoI64_Args struct.

func (*SecondService_EchoI64_Args) ToWire 

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

ToWire translates a SecondService_EchoI64_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 SecondService_EchoI64_Result 

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

SecondService_EchoI64_Result represents the result of a SecondService.echoI64 function call.

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

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

func (*SecondService_EchoI64_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SecondService_EchoI64_Result) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoI64_Result) FromWire 

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

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

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

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

func (*SecondService_EchoI64_Result) GetSuccess 

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

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

func (*SecondService_EchoI64_Result) IsSetSuccess 

func (v *SecondService_EchoI64_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SecondService_EchoI64_Result) MarshalLogObject 

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

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

func (*SecondService_EchoI64_Result) MethodName 

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

func (*SecondService_EchoI64_Result) String 

func (v *SecondService_EchoI64_Result) String() string

String returns a readable string representation of a SecondService_EchoI64_Result struct.

func (*SecondService_EchoI64_Result) ToWire 

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

ToWire translates a SecondService_EchoI64_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 SecondService_EchoI8_Args 

type SecondService_EchoI8_Args struct {
	Arg int8 `json:"arg,required"`
}

SecondService_EchoI8_Args represents the arguments for the SecondService.echoI8 function.

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

func (*SecondService_EchoI8_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SecondService_EchoI8_Args) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoI8_Args) FromWire 

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

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

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

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

func (*SecondService_EchoI8_Args) GetArg 

func (v *SecondService_EchoI8_Args) GetArg() (o int8)

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

func (*SecondService_EchoI8_Args) MarshalLogObject 

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

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

func (*SecondService_EchoI8_Args) MethodName 

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

func (*SecondService_EchoI8_Args) String 

func (v *SecondService_EchoI8_Args) String() string

String returns a readable string representation of a SecondService_EchoI8_Args struct.

func (*SecondService_EchoI8_Args) ToWire 

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

ToWire translates a SecondService_EchoI8_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 SecondService_EchoI8_Result 

type SecondService_EchoI8_Result struct {
	// Value returned by echoI8 after a successful execution.
	Success *int8 `json:"success,omitempty"`
}

SecondService_EchoI8_Result represents the result of a SecondService.echoI8 function call.

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

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

func (*SecondService_EchoI8_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SecondService_EchoI8_Result) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoI8_Result) FromWire 

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

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

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

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

func (*SecondService_EchoI8_Result) GetSuccess 

func (v *SecondService_EchoI8_Result) GetSuccess() (o int8)

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

func (*SecondService_EchoI8_Result) IsSetSuccess 

func (v *SecondService_EchoI8_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SecondService_EchoI8_Result) MarshalLogObject 

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

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

func (*SecondService_EchoI8_Result) MethodName 

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

func (*SecondService_EchoI8_Result) String 

func (v *SecondService_EchoI8_Result) String() string

String returns a readable string representation of a SecondService_EchoI8_Result struct.

func (*SecondService_EchoI8_Result) ToWire 

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

ToWire translates a SecondService_EchoI8_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 SecondService_EchoStringList_Args 

type SecondService_EchoStringList_Args struct {
	Arg []string `json:"arg,required"`
}

SecondService_EchoStringList_Args represents the arguments for the SecondService.echoStringList function.

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

func (*SecondService_EchoStringList_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SecondService_EchoStringList_Args) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoStringList_Args) FromWire 

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

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

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

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

func (*SecondService_EchoStringList_Args) GetArg 

func (v *SecondService_EchoStringList_Args) GetArg() (o []string)

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

func (*SecondService_EchoStringList_Args) IsSetArg 

func (v *SecondService_EchoStringList_Args) IsSetArg() bool

IsSetArg returns true if Arg is not nil.

func (*SecondService_EchoStringList_Args) MarshalLogObject 

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

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

func (*SecondService_EchoStringList_Args) MethodName 

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

func (*SecondService_EchoStringList_Args) String 

func (v *SecondService_EchoStringList_Args) String() string

String returns a readable string representation of a SecondService_EchoStringList_Args struct.

func (*SecondService_EchoStringList_Args) ToWire 

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

ToWire translates a SecondService_EchoStringList_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 SecondService_EchoStringList_Result 

type SecondService_EchoStringList_Result struct {
	// Value returned by echoStringList after a successful execution.
	Success []string `json:"success,omitempty"`
}

SecondService_EchoStringList_Result represents the result of a SecondService.echoStringList function call.

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

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

func (*SecondService_EchoStringList_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SecondService_EchoStringList_Result) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoStringList_Result) FromWire 

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

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

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

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

func (*SecondService_EchoStringList_Result) GetSuccess 

func (v *SecondService_EchoStringList_Result) GetSuccess() (o []string)

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

func (*SecondService_EchoStringList_Result) IsSetSuccess 

func (v *SecondService_EchoStringList_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SecondService_EchoStringList_Result) MarshalLogObject 

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

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

func (*SecondService_EchoStringList_Result) MethodName 

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

func (*SecondService_EchoStringList_Result) String 

func (v *SecondService_EchoStringList_Result) String() string

String returns a readable string representation of a SecondService_EchoStringList_Result struct.

func (*SecondService_EchoStringList_Result) ToWire 

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

ToWire translates a SecondService_EchoStringList_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 SecondService_EchoStringMap_Args 

type SecondService_EchoStringMap_Args struct {
	Arg map[string]*base.BazResponse `json:"arg,required"`
}

SecondService_EchoStringMap_Args represents the arguments for the SecondService.echoStringMap function.

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

func (*SecondService_EchoStringMap_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SecondService_EchoStringMap_Args) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoStringMap_Args) FromWire 

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

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

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

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

func (*SecondService_EchoStringMap_Args) GetArg 

func (v *SecondService_EchoStringMap_Args) GetArg() (o map[string]*base.BazResponse)

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

func (*SecondService_EchoStringMap_Args) IsSetArg 

func (v *SecondService_EchoStringMap_Args) IsSetArg() bool

IsSetArg returns true if Arg is not nil.

func (*SecondService_EchoStringMap_Args) MarshalLogObject 

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

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

func (*SecondService_EchoStringMap_Args) MethodName 

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

func (*SecondService_EchoStringMap_Args) String 

func (v *SecondService_EchoStringMap_Args) String() string

String returns a readable string representation of a SecondService_EchoStringMap_Args struct.

func (*SecondService_EchoStringMap_Args) ToWire 

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

ToWire translates a SecondService_EchoStringMap_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 SecondService_EchoStringMap_Result 

type SecondService_EchoStringMap_Result struct {
	// Value returned by echoStringMap after a successful execution.
	Success map[string]*base.BazResponse `json:"success,omitempty"`
}

SecondService_EchoStringMap_Result represents the result of a SecondService.echoStringMap function call.

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

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

func (*SecondService_EchoStringMap_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SecondService_EchoStringMap_Result) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoStringMap_Result) FromWire 

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

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

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

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

func (*SecondService_EchoStringMap_Result) GetSuccess 

func (v *SecondService_EchoStringMap_Result) GetSuccess() (o map[string]*base.BazResponse)

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

func (*SecondService_EchoStringMap_Result) IsSetSuccess 

func (v *SecondService_EchoStringMap_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SecondService_EchoStringMap_Result) MarshalLogObject 

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

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

func (*SecondService_EchoStringMap_Result) MethodName 

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

func (*SecondService_EchoStringMap_Result) String 

func (v *SecondService_EchoStringMap_Result) String() string

String returns a readable string representation of a SecondService_EchoStringMap_Result struct.

func (*SecondService_EchoStringMap_Result) ToWire 

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

ToWire translates a SecondService_EchoStringMap_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 SecondService_EchoStringSet_Args 

type SecondService_EchoStringSet_Args struct {
	Arg map[string]struct{} `json:"arg,required"`
}

SecondService_EchoStringSet_Args represents the arguments for the SecondService.echoStringSet function.

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

func (*SecondService_EchoStringSet_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SecondService_EchoStringSet_Args) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoStringSet_Args) FromWire 

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

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

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

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

func (*SecondService_EchoStringSet_Args) GetArg 

func (v *SecondService_EchoStringSet_Args) GetArg() (o map[string]struct{})

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

func (*SecondService_EchoStringSet_Args) IsSetArg 

func (v *SecondService_EchoStringSet_Args) IsSetArg() bool

IsSetArg returns true if Arg is not nil.

func (*SecondService_EchoStringSet_Args) MarshalLogObject 

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

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

func (*SecondService_EchoStringSet_Args) MethodName 

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

func (*SecondService_EchoStringSet_Args) String 

func (v *SecondService_EchoStringSet_Args) String() string

String returns a readable string representation of a SecondService_EchoStringSet_Args struct.

func (*SecondService_EchoStringSet_Args) ToWire 

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

ToWire translates a SecondService_EchoStringSet_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 SecondService_EchoStringSet_Result 

type SecondService_EchoStringSet_Result struct {
	// Value returned by echoStringSet after a successful execution.
	Success map[string]struct{} `json:"success,omitempty"`
}

SecondService_EchoStringSet_Result represents the result of a SecondService.echoStringSet function call.

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

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

func (*SecondService_EchoStringSet_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SecondService_EchoStringSet_Result) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoStringSet_Result) FromWire 

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

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

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

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

func (*SecondService_EchoStringSet_Result) GetSuccess 

func (v *SecondService_EchoStringSet_Result) GetSuccess() (o map[string]struct{})

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

func (*SecondService_EchoStringSet_Result) IsSetSuccess 

func (v *SecondService_EchoStringSet_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SecondService_EchoStringSet_Result) MarshalLogObject 

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

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

func (*SecondService_EchoStringSet_Result) MethodName 

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

func (*SecondService_EchoStringSet_Result) String 

func (v *SecondService_EchoStringSet_Result) String() string

String returns a readable string representation of a SecondService_EchoStringSet_Result struct.

func (*SecondService_EchoStringSet_Result) ToWire 

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

ToWire translates a SecondService_EchoStringSet_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 SecondService_EchoString_Args 

type SecondService_EchoString_Args struct {
	Arg string `json:"arg,required"`
}

SecondService_EchoString_Args represents the arguments for the SecondService.echoString function.

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

func (*SecondService_EchoString_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SecondService_EchoString_Args) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoString_Args) FromWire 

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

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

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

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

func (*SecondService_EchoString_Args) GetArg 

func (v *SecondService_EchoString_Args) GetArg() (o string)

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

func (*SecondService_EchoString_Args) MarshalLogObject 

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

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

func (*SecondService_EchoString_Args) MethodName 

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

func (*SecondService_EchoString_Args) String 

func (v *SecondService_EchoString_Args) String() string

String returns a readable string representation of a SecondService_EchoString_Args struct.

func (*SecondService_EchoString_Args) ToWire 

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

ToWire translates a SecondService_EchoString_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 SecondService_EchoString_Result 

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

SecondService_EchoString_Result represents the result of a SecondService.echoString function call.

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

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

func (*SecondService_EchoString_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SecondService_EchoString_Result) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoString_Result) FromWire 

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

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

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

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

func (*SecondService_EchoString_Result) GetSuccess 

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

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

func (*SecondService_EchoString_Result) IsSetSuccess 

func (v *SecondService_EchoString_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SecondService_EchoString_Result) MarshalLogObject 

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

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

func (*SecondService_EchoString_Result) MethodName 

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

func (*SecondService_EchoString_Result) String 

func (v *SecondService_EchoString_Result) String() string

String returns a readable string representation of a SecondService_EchoString_Result struct.

func (*SecondService_EchoString_Result) ToWire 

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

ToWire translates a SecondService_EchoString_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 SecondService_EchoStructList_Args 

type SecondService_EchoStructList_Args struct {
	Arg []*base.BazResponse `json:"arg,required"`
}

SecondService_EchoStructList_Args represents the arguments for the SecondService.echoStructList function.

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

func (*SecondService_EchoStructList_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SecondService_EchoStructList_Args) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoStructList_Args) FromWire 

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

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

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

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

func (*SecondService_EchoStructList_Args) GetArg 

func (v *SecondService_EchoStructList_Args) GetArg() (o []*base.BazResponse)

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

func (*SecondService_EchoStructList_Args) IsSetArg 

func (v *SecondService_EchoStructList_Args) IsSetArg() bool

IsSetArg returns true if Arg is not nil.

func (*SecondService_EchoStructList_Args) MarshalLogObject 

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

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

func (*SecondService_EchoStructList_Args) MethodName 

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

func (*SecondService_EchoStructList_Args) String 

func (v *SecondService_EchoStructList_Args) String() string

String returns a readable string representation of a SecondService_EchoStructList_Args struct.

func (*SecondService_EchoStructList_Args) ToWire 

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

ToWire translates a SecondService_EchoStructList_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 SecondService_EchoStructList_Result 

type SecondService_EchoStructList_Result struct {
	// Value returned by echoStructList after a successful execution.
	Success []*base.BazResponse `json:"success,omitempty"`
}

SecondService_EchoStructList_Result represents the result of a SecondService.echoStructList function call.

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

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

func (*SecondService_EchoStructList_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SecondService_EchoStructList_Result) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoStructList_Result) FromWire 

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

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

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

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

func (*SecondService_EchoStructList_Result) GetSuccess 

func (v *SecondService_EchoStructList_Result) GetSuccess() (o []*base.BazResponse)

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

func (*SecondService_EchoStructList_Result) IsSetSuccess 

func (v *SecondService_EchoStructList_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SecondService_EchoStructList_Result) MarshalLogObject 

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

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

func (*SecondService_EchoStructList_Result) MethodName 

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

func (*SecondService_EchoStructList_Result) String 

func (v *SecondService_EchoStructList_Result) String() string

String returns a readable string representation of a SecondService_EchoStructList_Result struct.

func (*SecondService_EchoStructList_Result) ToWire 

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

ToWire translates a SecondService_EchoStructList_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 SecondService_EchoStructMap_Args 

type SecondService_EchoStructMap_Args struct {
	Arg []struct {
		Key   *base.BazResponse
		Value string
	} `json:"arg,required"`
}

SecondService_EchoStructMap_Args represents the arguments for the SecondService.echoStructMap function.

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

func (*SecondService_EchoStructMap_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SecondService_EchoStructMap_Args) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoStructMap_Args) FromWire 

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

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

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

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

func (*SecondService_EchoStructMap_Args) GetArg 

func (v *SecondService_EchoStructMap_Args) GetArg() (o []struct {
	Key   *base.BazResponse
	Value string
})

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

func (*SecondService_EchoStructMap_Args) IsSetArg 

func (v *SecondService_EchoStructMap_Args) IsSetArg() bool

IsSetArg returns true if Arg is not nil.

func (*SecondService_EchoStructMap_Args) MarshalLogObject 

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

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

func (*SecondService_EchoStructMap_Args) MethodName 

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

func (*SecondService_EchoStructMap_Args) String 

func (v *SecondService_EchoStructMap_Args) String() string

String returns a readable string representation of a SecondService_EchoStructMap_Args struct.

func (*SecondService_EchoStructMap_Args) ToWire 

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

ToWire translates a SecondService_EchoStructMap_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 SecondService_EchoStructMap_Result 

type SecondService_EchoStructMap_Result struct {
	// Value returned by echoStructMap after a successful execution.
	Success []struct {
		Key   *base.BazResponse
		Value string
	} `json:"success,omitempty"`
}

SecondService_EchoStructMap_Result represents the result of a SecondService.echoStructMap function call.

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

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

func (*SecondService_EchoStructMap_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SecondService_EchoStructMap_Result) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoStructMap_Result) FromWire 

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

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

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

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

func (*SecondService_EchoStructMap_Result) GetSuccess 

func (v *SecondService_EchoStructMap_Result) GetSuccess() (o []struct {
	Key   *base.BazResponse
	Value string
})

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

func (*SecondService_EchoStructMap_Result) IsSetSuccess 

func (v *SecondService_EchoStructMap_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SecondService_EchoStructMap_Result) MarshalLogObject 

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

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

func (*SecondService_EchoStructMap_Result) MethodName 

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

func (*SecondService_EchoStructMap_Result) String 

func (v *SecondService_EchoStructMap_Result) String() string

String returns a readable string representation of a SecondService_EchoStructMap_Result struct.

func (*SecondService_EchoStructMap_Result) ToWire 

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

ToWire translates a SecondService_EchoStructMap_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 SecondService_EchoStructSet_Args 

type SecondService_EchoStructSet_Args struct {
	Arg []*base.BazResponse `json:"arg,required"`
}

SecondService_EchoStructSet_Args represents the arguments for the SecondService.echoStructSet function.

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

func (*SecondService_EchoStructSet_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SecondService_EchoStructSet_Args) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoStructSet_Args) FromWire 

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

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

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

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

func (*SecondService_EchoStructSet_Args) GetArg 

func (v *SecondService_EchoStructSet_Args) GetArg() (o []*base.BazResponse)

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

func (*SecondService_EchoStructSet_Args) IsSetArg 

func (v *SecondService_EchoStructSet_Args) IsSetArg() bool

IsSetArg returns true if Arg is not nil.

func (*SecondService_EchoStructSet_Args) MarshalLogObject 

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

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

func (*SecondService_EchoStructSet_Args) MethodName 

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

func (*SecondService_EchoStructSet_Args) String 

func (v *SecondService_EchoStructSet_Args) String() string

String returns a readable string representation of a SecondService_EchoStructSet_Args struct.

func (*SecondService_EchoStructSet_Args) ToWire 

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

ToWire translates a SecondService_EchoStructSet_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 SecondService_EchoStructSet_Result 

type SecondService_EchoStructSet_Result struct {
	// Value returned by echoStructSet after a successful execution.
	Success []*base.BazResponse `json:"success,omitempty"`
}

SecondService_EchoStructSet_Result represents the result of a SecondService.echoStructSet function call.

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

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

func (*SecondService_EchoStructSet_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SecondService_EchoStructSet_Result) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoStructSet_Result) FromWire 

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

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

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

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

func (*SecondService_EchoStructSet_Result) GetSuccess 

func (v *SecondService_EchoStructSet_Result) GetSuccess() (o []*base.BazResponse)

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

func (*SecondService_EchoStructSet_Result) IsSetSuccess 

func (v *SecondService_EchoStructSet_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SecondService_EchoStructSet_Result) MarshalLogObject 

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

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

func (*SecondService_EchoStructSet_Result) MethodName 

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

func (*SecondService_EchoStructSet_Result) String 

func (v *SecondService_EchoStructSet_Result) String() string

String returns a readable string representation of a SecondService_EchoStructSet_Result struct.

func (*SecondService_EchoStructSet_Result) ToWire 

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

ToWire translates a SecondService_EchoStructSet_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 SecondService_EchoTypedef_Args 

type SecondService_EchoTypedef_Args struct {
	Arg base.UUID `json:"arg,required"`
}

SecondService_EchoTypedef_Args represents the arguments for the SecondService.echoTypedef function.

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

func (*SecondService_EchoTypedef_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SecondService_EchoTypedef_Args) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoTypedef_Args) FromWire 

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

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

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

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

func (*SecondService_EchoTypedef_Args) GetArg 

func (v *SecondService_EchoTypedef_Args) GetArg() (o base.UUID)

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

func (*SecondService_EchoTypedef_Args) MarshalLogObject 

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

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

func (*SecondService_EchoTypedef_Args) MethodName 

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

func (*SecondService_EchoTypedef_Args) String 

func (v *SecondService_EchoTypedef_Args) String() string

String returns a readable string representation of a SecondService_EchoTypedef_Args struct.

func (*SecondService_EchoTypedef_Args) ToWire 

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

ToWire translates a SecondService_EchoTypedef_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 SecondService_EchoTypedef_Result 

type SecondService_EchoTypedef_Result struct {
	// Value returned by echoTypedef after a successful execution.
	Success *base.UUID `json:"success,omitempty"`
}

SecondService_EchoTypedef_Result represents the result of a SecondService.echoTypedef function call.

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

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

func (*SecondService_EchoTypedef_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SecondService_EchoTypedef_Result) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_EchoTypedef_Result) FromWire 

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

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

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

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

func (*SecondService_EchoTypedef_Result) GetSuccess 

func (v *SecondService_EchoTypedef_Result) GetSuccess() (o base.UUID)

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

func (*SecondService_EchoTypedef_Result) IsSetSuccess 

func (v *SecondService_EchoTypedef_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SecondService_EchoTypedef_Result) MarshalLogObject 

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

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

func (*SecondService_EchoTypedef_Result) MethodName 

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

func (*SecondService_EchoTypedef_Result) String 

func (v *SecondService_EchoTypedef_Result) String() string

String returns a readable string representation of a SecondService_EchoTypedef_Result struct.

func (*SecondService_EchoTypedef_Result) ToWire 

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

ToWire translates a SecondService_EchoTypedef_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_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) 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) 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) 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) 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) 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      *base.BazResponse `json:"success,omitempty"`
	AuthErr      *AuthErr          `json:"authErr,omitempty"`
	OtherAuthErr *OtherAuthErr     `json:"otherAuthErr,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) 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) GetOtherAuthErr 

func (v *SimpleService_Compare_Result) GetOtherAuthErr() (o *OtherAuthErr)

GetOtherAuthErr returns the value of OtherAuthErr if it is set or its zero value if it is unset.

func (*SimpleService_Compare_Result) GetSuccess 

func (v *SimpleService_Compare_Result) GetSuccess() (o *base.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) IsSetOtherAuthErr 

func (v *SimpleService_Compare_Result) IsSetOtherAuthErr() bool

IsSetOtherAuthErr returns true if OtherAuthErr 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_GetProfile_Args 

type SimpleService_GetProfile_Args struct {
	Request *GetProfileRequest `json:"request,required"`
}

SimpleService_GetProfile_Args represents the arguments for the SimpleService.getProfile function.

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

func (*SimpleService_GetProfile_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SimpleService_GetProfile_Args) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_GetProfile_Args) FromWire 

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

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

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

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

func (*SimpleService_GetProfile_Args) GetRequest 

func (v *SimpleService_GetProfile_Args) GetRequest() (o *GetProfileRequest)

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

func (*SimpleService_GetProfile_Args) IsSetRequest 

func (v *SimpleService_GetProfile_Args) IsSetRequest() bool

IsSetRequest returns true if Request is not nil.

func (*SimpleService_GetProfile_Args) MarshalLogObject 

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

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

func (*SimpleService_GetProfile_Args) MethodName 

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

func (*SimpleService_GetProfile_Args) String 

func (v *SimpleService_GetProfile_Args) String() string

String returns a readable string representation of a SimpleService_GetProfile_Args struct.

func (*SimpleService_GetProfile_Args) ToWire 

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

ToWire translates a SimpleService_GetProfile_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_GetProfile_Result 

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

SimpleService_GetProfile_Result represents the result of a SimpleService.getProfile function call.

The result of a getProfile 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_GetProfile_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SimpleService_GetProfile_Result) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_GetProfile_Result) FromWire 

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

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

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

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

func (*SimpleService_GetProfile_Result) GetAuthErr 

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

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

func (*SimpleService_GetProfile_Result) GetSuccess 

func (v *SimpleService_GetProfile_Result) GetSuccess() (o *GetProfileResponse)

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

func (*SimpleService_GetProfile_Result) IsSetAuthErr 

func (v *SimpleService_GetProfile_Result) IsSetAuthErr() bool

IsSetAuthErr returns true if AuthErr is not nil.

func (*SimpleService_GetProfile_Result) IsSetSuccess 

func (v *SimpleService_GetProfile_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SimpleService_GetProfile_Result) MarshalLogObject 

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

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

func (*SimpleService_GetProfile_Result) MethodName 

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

func (*SimpleService_GetProfile_Result) String 

func (v *SimpleService_GetProfile_Result) String() string

String returns a readable string representation of a SimpleService_GetProfile_Result struct.

func (*SimpleService_GetProfile_Result) ToWire 

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

ToWire translates a SimpleService_GetProfile_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_HeaderSchema_Args 

type SimpleService_HeaderSchema_Args struct {
	Req *HeaderSchema `json:"req,required"`
}

SimpleService_HeaderSchema_Args represents the arguments for the SimpleService.headerSchema function.

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

func (*SimpleService_HeaderSchema_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SimpleService_HeaderSchema_Args) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_HeaderSchema_Args) FromWire 

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

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

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

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

func (*SimpleService_HeaderSchema_Args) GetReq 

func (v *SimpleService_HeaderSchema_Args) GetReq() (o *HeaderSchema)

GetReq returns the value of Req if it is set or its zero value if it is unset.

func (*SimpleService_HeaderSchema_Args) IsSetReq 

func (v *SimpleService_HeaderSchema_Args) IsSetReq() bool

IsSetReq returns true if Req is not nil.

func (*SimpleService_HeaderSchema_Args) MarshalLogObject 

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

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

func (*SimpleService_HeaderSchema_Args) MethodName 

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

func (*SimpleService_HeaderSchema_Args) String 

func (v *SimpleService_HeaderSchema_Args) String() string

String returns a readable string representation of a SimpleService_HeaderSchema_Args struct.

func (*SimpleService_HeaderSchema_Args) ToWire 

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

ToWire translates a SimpleService_HeaderSchema_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_HeaderSchema_Result 

type SimpleService_HeaderSchema_Result struct {
	// Value returned by headerSchema after a successful execution.
	Success      *HeaderSchema `json:"success,omitempty"`
	AuthErr      *AuthErr      `json:"authErr,omitempty"`
	OtherAuthErr *OtherAuthErr `json:"otherAuthErr,omitempty"`
}

SimpleService_HeaderSchema_Result represents the result of a SimpleService.headerSchema function call.

The result of a headerSchema 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_HeaderSchema_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SimpleService_HeaderSchema_Result) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_HeaderSchema_Result) FromWire 

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

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

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

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

func (*SimpleService_HeaderSchema_Result) GetAuthErr 

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

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

func (*SimpleService_HeaderSchema_Result) GetOtherAuthErr 

func (v *SimpleService_HeaderSchema_Result) GetOtherAuthErr() (o *OtherAuthErr)

GetOtherAuthErr returns the value of OtherAuthErr if it is set or its zero value if it is unset.

func (*SimpleService_HeaderSchema_Result) GetSuccess 

func (v *SimpleService_HeaderSchema_Result) GetSuccess() (o *HeaderSchema)

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

func (*SimpleService_HeaderSchema_Result) IsSetAuthErr 

func (v *SimpleService_HeaderSchema_Result) IsSetAuthErr() bool

IsSetAuthErr returns true if AuthErr is not nil.

func (*SimpleService_HeaderSchema_Result) IsSetOtherAuthErr 

func (v *SimpleService_HeaderSchema_Result) IsSetOtherAuthErr() bool

IsSetOtherAuthErr returns true if OtherAuthErr is not nil.

func (*SimpleService_HeaderSchema_Result) IsSetSuccess 

func (v *SimpleService_HeaderSchema_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SimpleService_HeaderSchema_Result) MarshalLogObject 

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

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

func (*SimpleService_HeaderSchema_Result) MethodName 

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

func (*SimpleService_HeaderSchema_Result) String 

func (v *SimpleService_HeaderSchema_Result) String() string

String returns a readable string representation of a SimpleService_HeaderSchema_Result struct.

func (*SimpleService_HeaderSchema_Result) ToWire 

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

ToWire translates a SimpleService_HeaderSchema_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) 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 *base.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) 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 *base.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) 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 *base.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) 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 *base.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 SimpleService_TestUuid_Args 

type SimpleService_TestUuid_Args struct {
}

SimpleService_TestUuid_Args represents the arguments for the SimpleService.testUuid function.

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

func (*SimpleService_TestUuid_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SimpleService_TestUuid_Args) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_TestUuid_Args) FromWire 

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

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

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

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

func (*SimpleService_TestUuid_Args) MarshalLogObject 

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

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

func (*SimpleService_TestUuid_Args) MethodName 

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

func (*SimpleService_TestUuid_Args) String 

func (v *SimpleService_TestUuid_Args) String() string

String returns a readable string representation of a SimpleService_TestUuid_Args struct.

func (*SimpleService_TestUuid_Args) ToWire 

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

ToWire translates a SimpleService_TestUuid_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_TestUuid_Result 

type SimpleService_TestUuid_Result struct {
}

SimpleService_TestUuid_Result represents the result of a SimpleService.testUuid function call.

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

func (*SimpleService_TestUuid_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SimpleService_TestUuid_Result) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_TestUuid_Result) FromWire 

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

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

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

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

func (*SimpleService_TestUuid_Result) MarshalLogObject 

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

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

func (*SimpleService_TestUuid_Result) MethodName 

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

func (*SimpleService_TestUuid_Result) String 

func (v *SimpleService_TestUuid_Result) String() string

String returns a readable string representation of a SimpleService_TestUuid_Result struct.

func (*SimpleService_TestUuid_Result) ToWire 

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

ToWire translates a SimpleService_TestUuid_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_TransHeadersNoReq_Args 

type SimpleService_TransHeadersNoReq_Args struct {
	Req *base.NestedStruct `json:"req,required"`
	S2  *string            `json:"s2,omitempty"`
	I3  int32              `json:"i3,required"`
	B4  *bool              `json:"b4,omitempty"`
}

SimpleService_TransHeadersNoReq_Args represents the arguments for the SimpleService.transHeadersNoReq function.

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

func (*SimpleService_TransHeadersNoReq_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SimpleService_TransHeadersNoReq_Args) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_TransHeadersNoReq_Args) FromWire 

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

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

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

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

func (*SimpleService_TransHeadersNoReq_Args) GetB4 

func (v *SimpleService_TransHeadersNoReq_Args) GetB4() (o bool)

GetB4 returns the value of B4 if it is set or its zero value if it is unset.

func (*SimpleService_TransHeadersNoReq_Args) GetI3 

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

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

func (*SimpleService_TransHeadersNoReq_Args) GetReq 

func (v *SimpleService_TransHeadersNoReq_Args) GetReq() (o *base.NestedStruct)

GetReq returns the value of Req if it is set or its zero value if it is unset.

func (*SimpleService_TransHeadersNoReq_Args) GetS2 

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

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

func (*SimpleService_TransHeadersNoReq_Args) IsSetB4 

func (v *SimpleService_TransHeadersNoReq_Args) IsSetB4() bool

IsSetB4 returns true if B4 is not nil.

func (*SimpleService_TransHeadersNoReq_Args) IsSetReq 

func (v *SimpleService_TransHeadersNoReq_Args) IsSetReq() bool

IsSetReq returns true if Req is not nil.

func (*SimpleService_TransHeadersNoReq_Args) IsSetS2 

func (v *SimpleService_TransHeadersNoReq_Args) IsSetS2() bool

IsSetS2 returns true if S2 is not nil.

func (*SimpleService_TransHeadersNoReq_Args) MarshalLogObject 

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

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

func (*SimpleService_TransHeadersNoReq_Args) MethodName 

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

func (*SimpleService_TransHeadersNoReq_Args) String 

func (v *SimpleService_TransHeadersNoReq_Args) String() string

String returns a readable string representation of a SimpleService_TransHeadersNoReq_Args struct.

func (*SimpleService_TransHeadersNoReq_Args) ToWire 

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

ToWire translates a SimpleService_TransHeadersNoReq_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_TransHeadersNoReq_Result 

type SimpleService_TransHeadersNoReq_Result struct {
	// Value returned by transHeadersNoReq after a successful execution.
	Success *base.TransHeaders `json:"success,omitempty"`
	AuthErr *AuthErr           `json:"authErr,omitempty"`
}

SimpleService_TransHeadersNoReq_Result represents the result of a SimpleService.transHeadersNoReq function call.

The result of a transHeadersNoReq 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_TransHeadersNoReq_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SimpleService_TransHeadersNoReq_Result) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_TransHeadersNoReq_Result) FromWire 

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

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

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

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

func (*SimpleService_TransHeadersNoReq_Result) GetAuthErr 

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

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

func (*SimpleService_TransHeadersNoReq_Result) GetSuccess 

func (v *SimpleService_TransHeadersNoReq_Result) GetSuccess() (o *base.TransHeaders)

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

func (*SimpleService_TransHeadersNoReq_Result) IsSetAuthErr 

func (v *SimpleService_TransHeadersNoReq_Result) IsSetAuthErr() bool

IsSetAuthErr returns true if AuthErr is not nil.

func (*SimpleService_TransHeadersNoReq_Result) IsSetSuccess 

func (v *SimpleService_TransHeadersNoReq_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SimpleService_TransHeadersNoReq_Result) MarshalLogObject 

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

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

func (*SimpleService_TransHeadersNoReq_Result) MethodName 

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

func (*SimpleService_TransHeadersNoReq_Result) String 

func (v *SimpleService_TransHeadersNoReq_Result) String() string

String returns a readable string representation of a SimpleService_TransHeadersNoReq_Result struct.

func (*SimpleService_TransHeadersNoReq_Result) ToWire 

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

ToWire translates a SimpleService_TransHeadersNoReq_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_TransHeadersType_Args 

type SimpleService_TransHeadersType_Args struct {
	Req *TransHeaderType `json:"req,required"`
}

SimpleService_TransHeadersType_Args represents the arguments for the SimpleService.transHeadersType function.

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

func (*SimpleService_TransHeadersType_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SimpleService_TransHeadersType_Args) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_TransHeadersType_Args) FromWire 

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

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

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

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

func (*SimpleService_TransHeadersType_Args) GetReq 

func (v *SimpleService_TransHeadersType_Args) GetReq() (o *TransHeaderType)

GetReq returns the value of Req if it is set or its zero value if it is unset.

func (*SimpleService_TransHeadersType_Args) IsSetReq 

func (v *SimpleService_TransHeadersType_Args) IsSetReq() bool

IsSetReq returns true if Req is not nil.

func (*SimpleService_TransHeadersType_Args) MarshalLogObject 

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

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

func (*SimpleService_TransHeadersType_Args) MethodName 

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

func (*SimpleService_TransHeadersType_Args) String 

func (v *SimpleService_TransHeadersType_Args) String() string

String returns a readable string representation of a SimpleService_TransHeadersType_Args struct.

func (*SimpleService_TransHeadersType_Args) ToWire 

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

ToWire translates a SimpleService_TransHeadersType_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_TransHeadersType_Result 

type SimpleService_TransHeadersType_Result struct {
	// Value returned by transHeadersType after a successful execution.
	Success      *TransHeaderType `json:"success,omitempty"`
	AuthErr      *AuthErr         `json:"authErr,omitempty"`
	OtherAuthErr *OtherAuthErr    `json:"otherAuthErr,omitempty"`
}

SimpleService_TransHeadersType_Result represents the result of a SimpleService.transHeadersType function call.

The result of a transHeadersType 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_TransHeadersType_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SimpleService_TransHeadersType_Result) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_TransHeadersType_Result) FromWire 

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

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

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

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

func (*SimpleService_TransHeadersType_Result) GetAuthErr 

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

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

func (*SimpleService_TransHeadersType_Result) GetOtherAuthErr 

func (v *SimpleService_TransHeadersType_Result) GetOtherAuthErr() (o *OtherAuthErr)

GetOtherAuthErr returns the value of OtherAuthErr if it is set or its zero value if it is unset.

func (*SimpleService_TransHeadersType_Result) GetSuccess 

func (v *SimpleService_TransHeadersType_Result) GetSuccess() (o *TransHeaderType)

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

func (*SimpleService_TransHeadersType_Result) IsSetAuthErr 

func (v *SimpleService_TransHeadersType_Result) IsSetAuthErr() bool

IsSetAuthErr returns true if AuthErr is not nil.

func (*SimpleService_TransHeadersType_Result) IsSetOtherAuthErr 

func (v *SimpleService_TransHeadersType_Result) IsSetOtherAuthErr() bool

IsSetOtherAuthErr returns true if OtherAuthErr is not nil.

func (*SimpleService_TransHeadersType_Result) IsSetSuccess 

func (v *SimpleService_TransHeadersType_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SimpleService_TransHeadersType_Result) MarshalLogObject 

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

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

func (*SimpleService_TransHeadersType_Result) MethodName 

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

func (*SimpleService_TransHeadersType_Result) String 

func (v *SimpleService_TransHeadersType_Result) String() string

String returns a readable string representation of a SimpleService_TransHeadersType_Result struct.

func (*SimpleService_TransHeadersType_Result) ToWire 

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

ToWire translates a SimpleService_TransHeadersType_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_TransHeaders_Args 

type SimpleService_TransHeaders_Args struct {
	Req *base.TransHeaders `json:"req,required"`
}

SimpleService_TransHeaders_Args represents the arguments for the SimpleService.transHeaders function.

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

func (*SimpleService_TransHeaders_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SimpleService_TransHeaders_Args) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_TransHeaders_Args) FromWire 

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

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

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

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

func (*SimpleService_TransHeaders_Args) GetReq 

func (v *SimpleService_TransHeaders_Args) GetReq() (o *base.TransHeaders)

GetReq returns the value of Req if it is set or its zero value if it is unset.

func (*SimpleService_TransHeaders_Args) IsSetReq 

func (v *SimpleService_TransHeaders_Args) IsSetReq() bool

IsSetReq returns true if Req is not nil.

func (*SimpleService_TransHeaders_Args) MarshalLogObject 

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

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

func (*SimpleService_TransHeaders_Args) MethodName 

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

func (*SimpleService_TransHeaders_Args) String 

func (v *SimpleService_TransHeaders_Args) String() string

String returns a readable string representation of a SimpleService_TransHeaders_Args struct.

func (*SimpleService_TransHeaders_Args) ToWire 

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

ToWire translates a SimpleService_TransHeaders_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_TransHeaders_Result 

type SimpleService_TransHeaders_Result struct {
	// Value returned by transHeaders after a successful execution.
	Success      *base.TransHeaders `json:"success,omitempty"`
	AuthErr      *AuthErr           `json:"authErr,omitempty"`
	OtherAuthErr *OtherAuthErr      `json:"otherAuthErr,omitempty"`
}

SimpleService_TransHeaders_Result represents the result of a SimpleService.transHeaders function call.

The result of a transHeaders 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_TransHeaders_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SimpleService_TransHeaders_Result) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_TransHeaders_Result) FromWire 

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

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

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

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

func (*SimpleService_TransHeaders_Result) GetAuthErr 

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

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

func (*SimpleService_TransHeaders_Result) GetOtherAuthErr 

func (v *SimpleService_TransHeaders_Result) GetOtherAuthErr() (o *OtherAuthErr)

GetOtherAuthErr returns the value of OtherAuthErr if it is set or its zero value if it is unset.

func (*SimpleService_TransHeaders_Result) GetSuccess 

func (v *SimpleService_TransHeaders_Result) GetSuccess() (o *base.TransHeaders)

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

func (*SimpleService_TransHeaders_Result) IsSetAuthErr 

func (v *SimpleService_TransHeaders_Result) IsSetAuthErr() bool

IsSetAuthErr returns true if AuthErr is not nil.

func (*SimpleService_TransHeaders_Result) IsSetOtherAuthErr 

func (v *SimpleService_TransHeaders_Result) IsSetOtherAuthErr() bool

IsSetOtherAuthErr returns true if OtherAuthErr is not nil.

func (*SimpleService_TransHeaders_Result) IsSetSuccess 

func (v *SimpleService_TransHeaders_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SimpleService_TransHeaders_Result) MarshalLogObject 

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

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

func (*SimpleService_TransHeaders_Result) MethodName 

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

func (*SimpleService_TransHeaders_Result) String 

func (v *SimpleService_TransHeaders_Result) String() string

String returns a readable string representation of a SimpleService_TransHeaders_Result struct.

func (*SimpleService_TransHeaders_Result) ToWire 

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

ToWire translates a SimpleService_TransHeaders_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_Trans_Args 

type SimpleService_Trans_Args struct {
	Arg1 *base.TransStruct `json:"arg1,required"`
	Arg2 *base.TransStruct `json:"arg2,omitempty"`
}

SimpleService_Trans_Args represents the arguments for the SimpleService.trans function.

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

func (*SimpleService_Trans_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SimpleService_Trans_Args) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_Trans_Args) FromWire 

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

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

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

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

func (*SimpleService_Trans_Args) GetArg1 

func (v *SimpleService_Trans_Args) GetArg1() (o *base.TransStruct)

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

func (*SimpleService_Trans_Args) GetArg2 

func (v *SimpleService_Trans_Args) GetArg2() (o *base.TransStruct)

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

func (*SimpleService_Trans_Args) IsSetArg1 

func (v *SimpleService_Trans_Args) IsSetArg1() bool

IsSetArg1 returns true if Arg1 is not nil.

func (*SimpleService_Trans_Args) IsSetArg2 

func (v *SimpleService_Trans_Args) IsSetArg2() bool

IsSetArg2 returns true if Arg2 is not nil.

func (*SimpleService_Trans_Args) MarshalLogObject 

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

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

func (*SimpleService_Trans_Args) MethodName 

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

func (*SimpleService_Trans_Args) String 

func (v *SimpleService_Trans_Args) String() string

String returns a readable string representation of a SimpleService_Trans_Args struct.

func (*SimpleService_Trans_Args) ToWire 

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

ToWire translates a SimpleService_Trans_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_Trans_Result 

type SimpleService_Trans_Result struct {
	// Value returned by trans after a successful execution.
	Success      *base.TransStruct `json:"success,omitempty"`
	AuthErr      *AuthErr          `json:"authErr,omitempty"`
	OtherAuthErr *OtherAuthErr     `json:"otherAuthErr,omitempty"`
}

SimpleService_Trans_Result represents the result of a SimpleService.trans function call.

The result of a trans 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_Trans_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SimpleService_Trans_Result) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_Trans_Result) FromWire 

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

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

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

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

func (*SimpleService_Trans_Result) GetAuthErr 

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

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

func (*SimpleService_Trans_Result) GetOtherAuthErr 

func (v *SimpleService_Trans_Result) GetOtherAuthErr() (o *OtherAuthErr)

GetOtherAuthErr returns the value of OtherAuthErr if it is set or its zero value if it is unset.

func (*SimpleService_Trans_Result) GetSuccess 

func (v *SimpleService_Trans_Result) GetSuccess() (o *base.TransStruct)

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

func (*SimpleService_Trans_Result) IsSetAuthErr 

func (v *SimpleService_Trans_Result) IsSetAuthErr() bool

IsSetAuthErr returns true if AuthErr is not nil.

func (*SimpleService_Trans_Result) IsSetOtherAuthErr 

func (v *SimpleService_Trans_Result) IsSetOtherAuthErr() bool

IsSetOtherAuthErr returns true if OtherAuthErr is not nil.

func (*SimpleService_Trans_Result) IsSetSuccess 

func (v *SimpleService_Trans_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SimpleService_Trans_Result) MarshalLogObject 

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

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

func (*SimpleService_Trans_Result) MethodName 

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

func (*SimpleService_Trans_Result) String 

func (v *SimpleService_Trans_Result) String() string

String returns a readable string representation of a SimpleService_Trans_Result struct.

func (*SimpleService_Trans_Result) ToWire 

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

ToWire translates a SimpleService_Trans_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_UrlTest_Args 

type SimpleService_UrlTest_Args struct {
}

SimpleService_UrlTest_Args represents the arguments for the SimpleService.urlTest function.

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

func (*SimpleService_UrlTest_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SimpleService_UrlTest_Args) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_UrlTest_Args) FromWire 

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

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

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

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

func (*SimpleService_UrlTest_Args) MarshalLogObject 

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

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

func (*SimpleService_UrlTest_Args) MethodName 

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

func (*SimpleService_UrlTest_Args) String 

func (v *SimpleService_UrlTest_Args) String() string

String returns a readable string representation of a SimpleService_UrlTest_Args struct.

func (*SimpleService_UrlTest_Args) ToWire 

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

ToWire translates a SimpleService_UrlTest_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_UrlTest_Result 

type SimpleService_UrlTest_Result struct {
}

SimpleService_UrlTest_Result represents the result of a SimpleService.urlTest function call.

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

func (*SimpleService_UrlTest_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SimpleService_UrlTest_Result) Equals 

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

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

This function performs a deep comparison.

func (*SimpleService_UrlTest_Result) FromWire 

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

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

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

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

func (*SimpleService_UrlTest_Result) MarshalLogObject 

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

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

func (*SimpleService_UrlTest_Result) MethodName 

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

func (*SimpleService_UrlTest_Result) String 

func (v *SimpleService_UrlTest_Result) String() string

String returns a readable string representation of a SimpleService_UrlTest_Result struct.

func (*SimpleService_UrlTest_Result) ToWire 

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

ToWire translates a SimpleService_UrlTest_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 TransHeaderType 

type TransHeaderType struct {
	B1 bool     `json:"b1,required"`
	I1 *int32   `json:"i1,omitempty"`
	I2 int64    `json:"i2,required"`
	F3 *float64 `json:"f3,omitempty"`
	U4 UUID     `json:"u4,required"`
	U5 *UUID    `json:"u5,omitempty"`
	S6 string   `json:"s6,required"`
}

func (*TransHeaderType) Equals 

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

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

This function performs a deep comparison.

func (*TransHeaderType) FromWire 

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

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

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

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

func (*TransHeaderType) GetB1 

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

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

func (*TransHeaderType) GetF3 

func (v *TransHeaderType) GetF3() (o float64)

GetF3 returns the value of F3 if it is set or its zero value if it is unset.

func (*TransHeaderType) GetI1 

func (v *TransHeaderType) GetI1() (o int32)

GetI1 returns the value of I1 if it is set or its zero value if it is unset.

func (*TransHeaderType) GetI2 

func (v *TransHeaderType) GetI2() (o int64)

GetI2 returns the value of I2 if it is set or its zero value if it is unset.

func (*TransHeaderType) GetS6 

func (v *TransHeaderType) GetS6() (o string)

GetS6 returns the value of S6 if it is set or its zero value if it is unset.

func (*TransHeaderType) GetU4 

func (v *TransHeaderType) GetU4() (o UUID)

GetU4 returns the value of U4 if it is set or its zero value if it is unset.

func (*TransHeaderType) GetU5 

func (v *TransHeaderType) GetU5() (o UUID)

GetU5 returns the value of U5 if it is set or its zero value if it is unset.

func (*TransHeaderType) IsSetF3 

func (v *TransHeaderType) IsSetF3() bool

IsSetF3 returns true if F3 is not nil.

func (*TransHeaderType) IsSetI1 

func (v *TransHeaderType) IsSetI1() bool

IsSetI1 returns true if I1 is not nil.

func (*TransHeaderType) IsSetU5 

func (v *TransHeaderType) IsSetU5() bool

IsSetU5 returns true if U5 is not nil.

func (*TransHeaderType) MarshalLogObject 

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

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

func (*TransHeaderType) String 

func (v *TransHeaderType) String() string

String returns a readable string representation of a TransHeaderType struct.

func (*TransHeaderType) ToWire 

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

ToWire translates a TransHeaderType 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) 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.