gauntlet

package
v0.0.0-...-c99e383 Latest Latest
Warning

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

 Go to latest Published: Dec 12, 2024 License: MIT Imports: 15 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

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

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

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

SecondService_BlahBlah_Helper provides functions that aid in handling the parameters and return values of the SecondService.blahBlah function.

View Source 
var SecondService_SecondtestString_Helper = struct {
	// Args accepts the parameters of secondtestString in-order and returns
	// the arguments struct for the function.
	Args func(
		thing *string,
	) *SecondService_SecondtestString_Args

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

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

SecondService_SecondtestString_Helper provides functions that aid in handling the parameters and return values of the SecondService.secondtestString function.

View Source 
var ThriftModule = &thriftreflect.ThriftModule{
	Name:     "gauntlet",
	Package:  "go.uber.org/yarpc/internal/crossdock/thrift/gauntlet",
	FilePath: "gauntlet.thrift",
	SHA1:     "f308242071d9c9c31fb8faa1e1a79eeefa46316d",
	Raw:      rawIDL,
}

ThriftModule represents the IDL file used to generate this package.

View Source 
var ThriftTest_TestBinary_Helper = struct {
	// Args accepts the parameters of testBinary in-order and returns
	// the arguments struct for the function.
	Args func(
		thing []byte,
	) *ThriftTest_TestBinary_Args

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

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

ThriftTest_TestBinary_Helper provides functions that aid in handling the parameters and return values of the ThriftTest.testBinary function.

View Source 
var ThriftTest_TestByte_Helper = struct {
	// Args accepts the parameters of testByte in-order and returns
	// the arguments struct for the function.
	Args func(
		thing *int8,
	) *ThriftTest_TestByte_Args

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

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

ThriftTest_TestByte_Helper provides functions that aid in handling the parameters and return values of the ThriftTest.testByte function.

View Source 
var ThriftTest_TestDouble_Helper = struct {
	// Args accepts the parameters of testDouble in-order and returns
	// the arguments struct for the function.
	Args func(
		thing *float64,
	) *ThriftTest_TestDouble_Args

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

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

ThriftTest_TestDouble_Helper provides functions that aid in handling the parameters and return values of the ThriftTest.testDouble function.

View Source 
var ThriftTest_TestEnum_Helper = struct {
	// Args accepts the parameters of testEnum in-order and returns
	// the arguments struct for the function.
	Args func(
		thing *Numberz,
	) *ThriftTest_TestEnum_Args

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

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

ThriftTest_TestEnum_Helper provides functions that aid in handling the parameters and return values of the ThriftTest.testEnum function.

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

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

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

ThriftTest_TestException_Helper provides functions that aid in handling the parameters and return values of the ThriftTest.testException function.

View Source 
var ThriftTest_TestI32_Helper = struct {
	// Args accepts the parameters of testI32 in-order and returns
	// the arguments struct for the function.
	Args func(
		thing *int32,
	) *ThriftTest_TestI32_Args

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

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

ThriftTest_TestI32_Helper provides functions that aid in handling the parameters and return values of the ThriftTest.testI32 function.

View Source 
var ThriftTest_TestI64_Helper = struct {
	// Args accepts the parameters of testI64 in-order and returns
	// the arguments struct for the function.
	Args func(
		thing *int64,
	) *ThriftTest_TestI64_Args

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

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

ThriftTest_TestI64_Helper provides functions that aid in handling the parameters and return values of the ThriftTest.testI64 function.

View Source 
var ThriftTest_TestInsanity_Helper = struct {
	// Args accepts the parameters of testInsanity in-order and returns
	// the arguments struct for the function.
	Args func(
		argument *Insanity,
	) *ThriftTest_TestInsanity_Args

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

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

ThriftTest_TestInsanity_Helper provides functions that aid in handling the parameters and return values of the ThriftTest.testInsanity function.

View Source 
var ThriftTest_TestList_Helper = struct {
	// Args accepts the parameters of testList in-order and returns
	// the arguments struct for the function.
	Args func(
		thing []int32,
	) *ThriftTest_TestList_Args

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

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

ThriftTest_TestList_Helper provides functions that aid in handling the parameters and return values of the ThriftTest.testList function.

View Source 
var ThriftTest_TestMapMap_Helper = struct {
	// Args accepts the parameters of testMapMap in-order and returns
	// the arguments struct for the function.
	Args func(
		hello *int32,
	) *ThriftTest_TestMapMap_Args

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

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

ThriftTest_TestMapMap_Helper provides functions that aid in handling the parameters and return values of the ThriftTest.testMapMap function.

View Source 
var ThriftTest_TestMap_Helper = struct {
	// Args accepts the parameters of testMap in-order and returns
	// the arguments struct for the function.
	Args func(
		thing map[int32]int32,
	) *ThriftTest_TestMap_Args

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

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

ThriftTest_TestMap_Helper provides functions that aid in handling the parameters and return values of the ThriftTest.testMap function.

View Source 
var ThriftTest_TestMultiException_Helper = struct {
	// Args accepts the parameters of testMultiException in-order and returns
	// the arguments struct for the function.
	Args func(
		arg0 *string,
		arg1 *string,
	) *ThriftTest_TestMultiException_Args

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

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

ThriftTest_TestMultiException_Helper provides functions that aid in handling the parameters and return values of the ThriftTest.testMultiException function.

View Source 
var ThriftTest_TestMulti_Helper = struct {
	// Args accepts the parameters of testMulti in-order and returns
	// the arguments struct for the function.
	Args func(
		arg0 *int8,
		arg1 *int32,
		arg2 *int64,
		arg3 map[int16]string,
		arg4 *Numberz,
		arg5 *UserId,
	) *ThriftTest_TestMulti_Args

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

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

ThriftTest_TestMulti_Helper provides functions that aid in handling the parameters and return values of the ThriftTest.testMulti function.

View Source 
var ThriftTest_TestNest_Helper = struct {
	// Args accepts the parameters of testNest in-order and returns
	// the arguments struct for the function.
	Args func(
		thing *Xtruct2,
	) *ThriftTest_TestNest_Args

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

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

ThriftTest_TestNest_Helper provides functions that aid in handling the parameters and return values of the ThriftTest.testNest function.

View Source 
var ThriftTest_TestOneway_Helper = struct {
	// Args accepts the parameters of testOneway in-order and returns
	// the arguments struct for the function.
	Args func(
		secondsToSleep *int32,
	) *ThriftTest_TestOneway_Args
}{}

ThriftTest_TestOneway_Helper provides functions that aid in handling the parameters and return values of the ThriftTest.testOneway function.

View Source 
var ThriftTest_TestSet_Helper = struct {
	// Args accepts the parameters of testSet in-order and returns
	// the arguments struct for the function.
	Args func(
		thing map[int32]struct{},
	) *ThriftTest_TestSet_Args

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

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

ThriftTest_TestSet_Helper provides functions that aid in handling the parameters and return values of the ThriftTest.testSet function.

View Source 
var ThriftTest_TestStringMap_Helper = struct {
	// Args accepts the parameters of testStringMap in-order and returns
	// the arguments struct for the function.
	Args func(
		thing map[string]string,
	) *ThriftTest_TestStringMap_Args

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

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

ThriftTest_TestStringMap_Helper provides functions that aid in handling the parameters and return values of the ThriftTest.testStringMap function.

View Source 
var ThriftTest_TestString_Helper = struct {
	// Args accepts the parameters of testString in-order and returns
	// the arguments struct for the function.
	Args func(
		thing *string,
	) *ThriftTest_TestString_Args

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

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

ThriftTest_TestString_Helper provides functions that aid in handling the parameters and return values of the ThriftTest.testString function.

View Source 
var ThriftTest_TestStruct_Helper = struct {
	// Args accepts the parameters of testStruct in-order and returns
	// the arguments struct for the function.
	Args func(
		thing *Xtruct,
	) *ThriftTest_TestStruct_Args

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

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

ThriftTest_TestStruct_Helper provides functions that aid in handling the parameters and return values of the ThriftTest.testStruct function.

View Source 
var ThriftTest_TestTypedef_Helper = struct {
	// Args accepts the parameters of testTypedef in-order and returns
	// the arguments struct for the function.
	Args func(
		thing *UserId,
	) *ThriftTest_TestTypedef_Args

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

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

ThriftTest_TestTypedef_Helper provides functions that aid in handling the parameters and return values of the ThriftTest.testTypedef function.

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

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

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

ThriftTest_TestVoid_Helper provides functions that aid in handling the parameters and return values of the ThriftTest.testVoid function.

Functions

This section is empty.

Types

type Bonk 

type Bonk struct {
	Message *string `json:"message,omitempty"`
	Type    *int32  `json:"type,omitempty"`
}

func (*Bonk) Decode 

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

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

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

func (*Bonk) Encode 

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

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

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

func (*Bonk) Equals 

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

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

This function performs a deep comparison.

func (*Bonk) FromWire 

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

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

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

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

func (*Bonk) GetMessage 

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

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

func (*Bonk) GetType 

func (v *Bonk) GetType() (o int32)

GetType returns the value of Type if it is set or its zero value if it is unset.

func (*Bonk) IsSetMessage 

func (v *Bonk) IsSetMessage() bool

IsSetMessage returns true if Message is not nil.

func (*Bonk) IsSetType 

func (v *Bonk) IsSetType() bool

IsSetType returns true if Type is not nil.

func (*Bonk) MarshalLogObject 

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

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

func (*Bonk) String 

func (v *Bonk) String() string

String returns a readable string representation of a Bonk struct.

func (*Bonk) ToWire 

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

ToWire translates a Bonk 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 BoolTest 

type BoolTest struct {
	B *bool   `json:"b,omitempty"`
	S *string `json:"s,omitempty"`
}

func Default_BoolTest 

func Default_BoolTest() *BoolTest

Default_BoolTest constructs a new BoolTest struct, pre-populating any fields with defined default values.

func (*BoolTest) Decode 

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

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

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

func (*BoolTest) Encode 

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

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

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

func (*BoolTest) Equals 

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

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

This function performs a deep comparison.

func (*BoolTest) FromWire 

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

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

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

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

func (*BoolTest) GetB 

func (v *BoolTest) GetB() (o bool)

GetB returns the value of B if it is set or its default value if it is unset.

func (*BoolTest) GetS 

func (v *BoolTest) GetS() (o string)

GetS returns the value of S if it is set or its default value if it is unset.

func (*BoolTest) IsSetB 

func (v *BoolTest) IsSetB() bool

IsSetB returns true if B is not nil.

func (*BoolTest) IsSetS 

func (v *BoolTest) IsSetS() bool

IsSetS returns true if S is not nil.

func (*BoolTest) MarshalLogObject 

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

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

func (*BoolTest) String 

func (v *BoolTest) String() string

String returns a readable string representation of a BoolTest struct.

func (*BoolTest) ToWire 

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

ToWire translates a BoolTest 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 Bools 

type Bools struct {
	ImTrue  *bool `json:"im_true,omitempty"`
	ImFalse *bool `json:"im_false,omitempty"`
}

func (*Bools) Decode 

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

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

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

func (*Bools) Encode 

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

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

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

func (*Bools) Equals 

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

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

This function performs a deep comparison.

func (*Bools) FromWire 

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

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

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

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

func (*Bools) GetImFalse 

func (v *Bools) GetImFalse() (o bool)

GetImFalse returns the value of ImFalse if it is set or its zero value if it is unset.

func (*Bools) GetImTrue 

func (v *Bools) GetImTrue() (o bool)

GetImTrue returns the value of ImTrue if it is set or its zero value if it is unset.

func (*Bools) IsSetImFalse 

func (v *Bools) IsSetImFalse() bool

IsSetImFalse returns true if ImFalse is not nil.

func (*Bools) IsSetImTrue 

func (v *Bools) IsSetImTrue() bool

IsSetImTrue returns true if ImTrue is not nil.

func (*Bools) MarshalLogObject 

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

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

func (*Bools) String 

func (v *Bools) String() string

String returns a readable string representation of a Bools struct.

func (*Bools) ToWire 

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

ToWire translates a Bools 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 CrazyNesting 

type CrazyNesting struct {
	StringField *string     `json:"string_field,omitempty"`
	SetField    []*Insanity `json:"set_field,omitempty"`
	ListField   [][]struct {
		Key   map[int32]struct{}
		Value map[int32][][][]struct {
			Key   *Insanity
			Value string
		}
	} `json:"list_field,required"`
	BinaryField []byte `json:"binary_field,omitempty"`
}

func (*CrazyNesting) Decode 

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

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

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

func (*CrazyNesting) Encode 

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

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

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

func (*CrazyNesting) Equals 

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

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

This function performs a deep comparison.

func (*CrazyNesting) FromWire 

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

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

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

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

func (*CrazyNesting) GetBinaryField 

func (v *CrazyNesting) GetBinaryField() (o []byte)

GetBinaryField returns the value of BinaryField if it is set or its zero value if it is unset.

func (*CrazyNesting) GetListField 

func (v *CrazyNesting) GetListField() (o [][]struct {
	Key   map[int32]struct{}
	Value map[int32][][][]struct {
		Key   *Insanity
		Value string
	}
})

GetListField returns the value of ListField if it is set or its zero value if it is unset.

func (*CrazyNesting) GetSetField 

func (v *CrazyNesting) GetSetField() (o []*Insanity)

GetSetField returns the value of SetField if it is set or its zero value if it is unset.

func (*CrazyNesting) GetStringField 

func (v *CrazyNesting) GetStringField() (o string)

GetStringField returns the value of StringField if it is set or its zero value if it is unset.

func (*CrazyNesting) IsSetBinaryField 

func (v *CrazyNesting) IsSetBinaryField() bool

IsSetBinaryField returns true if BinaryField is not nil.

func (*CrazyNesting) IsSetListField 

func (v *CrazyNesting) IsSetListField() bool

IsSetListField returns true if ListField is not nil.

func (*CrazyNesting) IsSetSetField 

func (v *CrazyNesting) IsSetSetField() bool

IsSetSetField returns true if SetField is not nil.

func (*CrazyNesting) IsSetStringField 

func (v *CrazyNesting) IsSetStringField() bool

IsSetStringField returns true if StringField is not nil.

func (*CrazyNesting) MarshalLogObject 

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

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

func (*CrazyNesting) String 

func (v *CrazyNesting) String() string

String returns a readable string representation of a CrazyNesting struct.

func (*CrazyNesting) ToWire 

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

ToWire translates a CrazyNesting 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 EmptyStruct 

type EmptyStruct struct {
}

func (*EmptyStruct) Decode 

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

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

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

func (*EmptyStruct) Encode 

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

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

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

func (*EmptyStruct) Equals 

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

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

This function performs a deep comparison.

func (*EmptyStruct) FromWire 

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

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

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

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

func (*EmptyStruct) MarshalLogObject 

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

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

func (*EmptyStruct) String 

func (v *EmptyStruct) String() string

String returns a readable string representation of a EmptyStruct struct.

func (*EmptyStruct) ToWire 

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

ToWire translates a EmptyStruct 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 GuessProtocolStruct 

type GuessProtocolStruct struct {
	MapField map[string]string `json:"map_field,omitempty"`
}

func (*GuessProtocolStruct) Decode 

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

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

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

func (*GuessProtocolStruct) Encode 

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

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

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

func (*GuessProtocolStruct) Equals 

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

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

This function performs a deep comparison.

func (*GuessProtocolStruct) FromWire 

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

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

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

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

func (*GuessProtocolStruct) GetMapField 

func (v *GuessProtocolStruct) GetMapField() (o map[string]string)

GetMapField returns the value of MapField if it is set or its zero value if it is unset.

func (*GuessProtocolStruct) IsSetMapField 

func (v *GuessProtocolStruct) IsSetMapField() bool

IsSetMapField returns true if MapField is not nil.

func (*GuessProtocolStruct) MarshalLogObject 

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

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

func (*GuessProtocolStruct) String 

func (v *GuessProtocolStruct) String() string

String returns a readable string representation of a GuessProtocolStruct struct.

func (*GuessProtocolStruct) ToWire 

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

ToWire translates a GuessProtocolStruct 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 Insanity 

type Insanity struct {
	UserMap map[Numberz]UserId `json:"userMap,omitempty"`
	Xtructs []*Xtruct          `json:"xtructs,omitempty"`
}

func (*Insanity) Decode 

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

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

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

func (*Insanity) Encode 

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

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

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

func (*Insanity) Equals 

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

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

This function performs a deep comparison.

func (*Insanity) FromWire 

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

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

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

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

func (*Insanity) GetUserMap 

func (v *Insanity) GetUserMap() (o map[Numberz]UserId)

GetUserMap returns the value of UserMap if it is set or its zero value if it is unset.

func (*Insanity) GetXtructs 

func (v *Insanity) GetXtructs() (o []*Xtruct)

GetXtructs returns the value of Xtructs if it is set or its zero value if it is unset.

func (*Insanity) IsSetUserMap 

func (v *Insanity) IsSetUserMap() bool

IsSetUserMap returns true if UserMap is not nil.

func (*Insanity) IsSetXtructs 

func (v *Insanity) IsSetXtructs() bool

IsSetXtructs returns true if Xtructs is not nil.

func (*Insanity) MarshalLogObject 

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

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

func (*Insanity) String 

func (v *Insanity) String() string

String returns a readable string representation of a Insanity struct.

func (*Insanity) ToWire 

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

ToWire translates a Insanity 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 LargeDeltas 

type LargeDeltas struct {
	B1         *Bools              `json:"b1,omitempty"`
	B10        *Bools              `json:"b10,omitempty"`
	B100       *Bools              `json:"b100,omitempty"`
	CheckTrue  *bool               `json:"check_true,omitempty"`
	B1000      *Bools              `json:"b1000,omitempty"`
	CheckFalse *bool               `json:"check_false,omitempty"`
	Vertwo2000 *VersioningTestV2   `json:"vertwo2000,omitempty"`
	ASet2500   map[string]struct{} `json:"a_set2500,omitempty"`
	Vertwo3000 *VersioningTestV2   `json:"vertwo3000,omitempty"`
	BigNumbers []int32             `json:"big_numbers,omitempty"`
}

func (*LargeDeltas) Decode 

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

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

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

func (*LargeDeltas) Encode 

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

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

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

func (*LargeDeltas) Equals 

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

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

This function performs a deep comparison.

func (*LargeDeltas) FromWire 

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

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

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

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

func (*LargeDeltas) GetASet2500 

func (v *LargeDeltas) GetASet2500() (o map[string]struct{})

GetASet2500 returns the value of ASet2500 if it is set or its zero value if it is unset.

func (*LargeDeltas) GetB1 

func (v *LargeDeltas) GetB1() (o *Bools)

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

func (*LargeDeltas) GetB10 

func (v *LargeDeltas) GetB10() (o *Bools)

GetB10 returns the value of B10 if it is set or its zero value if it is unset.

func (*LargeDeltas) GetB100 

func (v *LargeDeltas) GetB100() (o *Bools)

GetB100 returns the value of B100 if it is set or its zero value if it is unset.

func (*LargeDeltas) GetB1000 

func (v *LargeDeltas) GetB1000() (o *Bools)

GetB1000 returns the value of B1000 if it is set or its zero value if it is unset.

func (*LargeDeltas) GetBigNumbers 

func (v *LargeDeltas) GetBigNumbers() (o []int32)

GetBigNumbers returns the value of BigNumbers if it is set or its zero value if it is unset.

func (*LargeDeltas) GetCheckFalse 

func (v *LargeDeltas) GetCheckFalse() (o bool)

GetCheckFalse returns the value of CheckFalse if it is set or its zero value if it is unset.

func (*LargeDeltas) GetCheckTrue 

func (v *LargeDeltas) GetCheckTrue() (o bool)

GetCheckTrue returns the value of CheckTrue if it is set or its zero value if it is unset.

func (*LargeDeltas) GetVertwo2000 

func (v *LargeDeltas) GetVertwo2000() (o *VersioningTestV2)

GetVertwo2000 returns the value of Vertwo2000 if it is set or its zero value if it is unset.

func (*LargeDeltas) GetVertwo3000 

func (v *LargeDeltas) GetVertwo3000() (o *VersioningTestV2)

GetVertwo3000 returns the value of Vertwo3000 if it is set or its zero value if it is unset.

func (*LargeDeltas) IsSetASet2500 

func (v *LargeDeltas) IsSetASet2500() bool

IsSetASet2500 returns true if ASet2500 is not nil.

func (*LargeDeltas) IsSetB1 

func (v *LargeDeltas) IsSetB1() bool

IsSetB1 returns true if B1 is not nil.

func (*LargeDeltas) IsSetB10 

func (v *LargeDeltas) IsSetB10() bool

IsSetB10 returns true if B10 is not nil.

func (*LargeDeltas) IsSetB100 

func (v *LargeDeltas) IsSetB100() bool

IsSetB100 returns true if B100 is not nil.

func (*LargeDeltas) IsSetB1000 

func (v *LargeDeltas) IsSetB1000() bool

IsSetB1000 returns true if B1000 is not nil.

func (*LargeDeltas) IsSetBigNumbers 

func (v *LargeDeltas) IsSetBigNumbers() bool

IsSetBigNumbers returns true if BigNumbers is not nil.

func (*LargeDeltas) IsSetCheckFalse 

func (v *LargeDeltas) IsSetCheckFalse() bool

IsSetCheckFalse returns true if CheckFalse is not nil.

func (*LargeDeltas) IsSetCheckTrue 

func (v *LargeDeltas) IsSetCheckTrue() bool

IsSetCheckTrue returns true if CheckTrue is not nil.

func (*LargeDeltas) IsSetVertwo2000 

func (v *LargeDeltas) IsSetVertwo2000() bool

IsSetVertwo2000 returns true if Vertwo2000 is not nil.

func (*LargeDeltas) IsSetVertwo3000 

func (v *LargeDeltas) IsSetVertwo3000() bool

IsSetVertwo3000 returns true if Vertwo3000 is not nil.

func (*LargeDeltas) MarshalLogObject 

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

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

func (*LargeDeltas) String 

func (v *LargeDeltas) String() string

String returns a readable string representation of a LargeDeltas struct.

func (*LargeDeltas) ToWire 

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

ToWire translates a LargeDeltas 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 ListBonks 

type ListBonks struct {
	Bonk []*Bonk `json:"bonk,omitempty"`
}

func (*ListBonks) Decode 

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

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

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

func (*ListBonks) Encode 

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

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

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

func (*ListBonks) Equals 

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

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

This function performs a deep comparison.

func (*ListBonks) FromWire 

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

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

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

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

func (*ListBonks) GetBonk 

func (v *ListBonks) GetBonk() (o []*Bonk)

GetBonk returns the value of Bonk if it is set or its zero value if it is unset.

func (*ListBonks) IsSetBonk 

func (v *ListBonks) IsSetBonk() bool

IsSetBonk returns true if Bonk is not nil.

func (*ListBonks) MarshalLogObject 

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

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

func (*ListBonks) String 

func (v *ListBonks) String() string

String returns a readable string representation of a ListBonks struct.

func (*ListBonks) ToWire 

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

ToWire translates a ListBonks 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 ListTypeVersioningV1 

type ListTypeVersioningV1 struct {
	Myints []int32 `json:"myints,omitempty"`
	Hello  *string `json:"hello,omitempty"`
}

func (*ListTypeVersioningV1) Decode 

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

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

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

func (*ListTypeVersioningV1) Encode 

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

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

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

func (*ListTypeVersioningV1) Equals 

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

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

This function performs a deep comparison.

func (*ListTypeVersioningV1) FromWire 

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

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

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

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

func (*ListTypeVersioningV1) GetHello 

func (v *ListTypeVersioningV1) GetHello() (o string)

GetHello returns the value of Hello if it is set or its zero value if it is unset.

func (*ListTypeVersioningV1) GetMyints 

func (v *ListTypeVersioningV1) GetMyints() (o []int32)

GetMyints returns the value of Myints if it is set or its zero value if it is unset.

func (*ListTypeVersioningV1) IsSetHello 

func (v *ListTypeVersioningV1) IsSetHello() bool

IsSetHello returns true if Hello is not nil.

func (*ListTypeVersioningV1) IsSetMyints 

func (v *ListTypeVersioningV1) IsSetMyints() bool

IsSetMyints returns true if Myints is not nil.

func (*ListTypeVersioningV1) MarshalLogObject 

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

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

func (*ListTypeVersioningV1) String 

func (v *ListTypeVersioningV1) String() string

String returns a readable string representation of a ListTypeVersioningV1 struct.

func (*ListTypeVersioningV1) ToWire 

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

ToWire translates a ListTypeVersioningV1 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 ListTypeVersioningV2 

type ListTypeVersioningV2 struct {
	Strings []string `json:"strings,omitempty"`
	Hello   *string  `json:"hello,omitempty"`
}

func (*ListTypeVersioningV2) Decode 

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

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

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

func (*ListTypeVersioningV2) Encode 

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

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

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

func (*ListTypeVersioningV2) Equals 

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

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

This function performs a deep comparison.

func (*ListTypeVersioningV2) FromWire 

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

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

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

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

func (*ListTypeVersioningV2) GetHello 

func (v *ListTypeVersioningV2) GetHello() (o string)

GetHello returns the value of Hello if it is set or its zero value if it is unset.

func (*ListTypeVersioningV2) GetStrings 

func (v *ListTypeVersioningV2) GetStrings() (o []string)

GetStrings returns the value of Strings if it is set or its zero value if it is unset.

func (*ListTypeVersioningV2) IsSetHello 

func (v *ListTypeVersioningV2) IsSetHello() bool

IsSetHello returns true if Hello is not nil.

func (*ListTypeVersioningV2) IsSetStrings 

func (v *ListTypeVersioningV2) IsSetStrings() bool

IsSetStrings returns true if Strings is not nil.

func (*ListTypeVersioningV2) MarshalLogObject 

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

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

func (*ListTypeVersioningV2) String 

func (v *ListTypeVersioningV2) String() string

String returns a readable string representation of a ListTypeVersioningV2 struct.

func (*ListTypeVersioningV2) ToWire 

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

ToWire translates a ListTypeVersioningV2 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 MapType 

type MapType map[string]*Bonk

func (*MapType) Decode 

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

Decode deserializes MapType directly off the wire.

func (MapType) Encode 

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

func (MapType) Equals 

func (lhs MapType) Equals(rhs MapType) bool

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

func (*MapType) FromWire 

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

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

func (MapType) MarshalLogObject 

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

func (MapType) String 

func (v MapType) String() string

String returns a readable string representation of MapType.

func (MapType) ToWire 

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

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

type NestedListsBonk 

type NestedListsBonk struct {
	Bonk [][][]*Bonk `json:"bonk,omitempty"`
}

func (*NestedListsBonk) Decode 

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

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

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

func (*NestedListsBonk) Encode 

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

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

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

func (*NestedListsBonk) Equals 

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

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

This function performs a deep comparison.

func (*NestedListsBonk) FromWire 

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

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

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

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

func (*NestedListsBonk) GetBonk 

func (v *NestedListsBonk) GetBonk() (o [][][]*Bonk)

GetBonk returns the value of Bonk if it is set or its zero value if it is unset.

func (*NestedListsBonk) IsSetBonk 

func (v *NestedListsBonk) IsSetBonk() bool

IsSetBonk returns true if Bonk is not nil.

func (*NestedListsBonk) MarshalLogObject 

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

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

func (*NestedListsBonk) String 

func (v *NestedListsBonk) String() string

String returns a readable string representation of a NestedListsBonk struct.

func (*NestedListsBonk) ToWire 

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

ToWire translates a NestedListsBonk 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 NestedListsI32x2 

type NestedListsI32x2 struct {
	Integerlist [][]int32 `json:"integerlist,omitempty"`
}

func (*NestedListsI32x2) Decode 

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

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

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

func (*NestedListsI32x2) Encode 

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

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

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

func (*NestedListsI32x2) Equals 

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

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

This function performs a deep comparison.

func (*NestedListsI32x2) FromWire 

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

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

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

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

func (*NestedListsI32x2) GetIntegerlist 

func (v *NestedListsI32x2) GetIntegerlist() (o [][]int32)

GetIntegerlist returns the value of Integerlist if it is set or its zero value if it is unset.

func (*NestedListsI32x2) IsSetIntegerlist 

func (v *NestedListsI32x2) IsSetIntegerlist() bool

IsSetIntegerlist returns true if Integerlist is not nil.

func (*NestedListsI32x2) MarshalLogObject 

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

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

func (*NestedListsI32x2) String 

func (v *NestedListsI32x2) String() string

String returns a readable string representation of a NestedListsI32x2 struct.

func (*NestedListsI32x2) ToWire 

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

ToWire translates a NestedListsI32x2 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 NestedListsI32x3 

type NestedListsI32x3 struct {
	Integerlist [][][]int32 `json:"integerlist,omitempty"`
}

func (*NestedListsI32x3) Decode 

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

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

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

func (*NestedListsI32x3) Encode 

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

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

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

func (*NestedListsI32x3) Equals 

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

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

This function performs a deep comparison.

func (*NestedListsI32x3) FromWire 

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

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

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

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

func (*NestedListsI32x3) GetIntegerlist 

func (v *NestedListsI32x3) GetIntegerlist() (o [][][]int32)

GetIntegerlist returns the value of Integerlist if it is set or its zero value if it is unset.

func (*NestedListsI32x3) IsSetIntegerlist 

func (v *NestedListsI32x3) IsSetIntegerlist() bool

IsSetIntegerlist returns true if Integerlist is not nil.

func (*NestedListsI32x3) MarshalLogObject 

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

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

func (*NestedListsI32x3) String 

func (v *NestedListsI32x3) String() string

String returns a readable string representation of a NestedListsI32x3 struct.

func (*NestedListsI32x3) ToWire 

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

ToWire translates a NestedListsI32x3 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 NestedMixedx2 

type NestedMixedx2 struct {
	IntSetList       []map[int32]struct{}            `json:"int_set_list,omitempty"`
	MapIntStrset     map[int32]map[string]struct{}   `json:"map_int_strset,omitempty"`
	MapIntStrsetList []map[int32]map[string]struct{} `json:"map_int_strset_list,omitempty"`
}

func (*NestedMixedx2) Decode 

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

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

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

func (*NestedMixedx2) Encode 

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

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

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

func (*NestedMixedx2) Equals 

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

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

This function performs a deep comparison.

func (*NestedMixedx2) FromWire 

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

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

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

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

func (*NestedMixedx2) GetIntSetList 

func (v *NestedMixedx2) GetIntSetList() (o []map[int32]struct{})

GetIntSetList returns the value of IntSetList if it is set or its zero value if it is unset.

func (*NestedMixedx2) GetMapIntStrset 

func (v *NestedMixedx2) GetMapIntStrset() (o map[int32]map[string]struct{})

GetMapIntStrset returns the value of MapIntStrset if it is set or its zero value if it is unset.

func (*NestedMixedx2) GetMapIntStrsetList 

func (v *NestedMixedx2) GetMapIntStrsetList() (o []map[int32]map[string]struct{})

GetMapIntStrsetList returns the value of MapIntStrsetList if it is set or its zero value if it is unset.

func (*NestedMixedx2) IsSetIntSetList 

func (v *NestedMixedx2) IsSetIntSetList() bool

IsSetIntSetList returns true if IntSetList is not nil.

func (*NestedMixedx2) IsSetMapIntStrset 

func (v *NestedMixedx2) IsSetMapIntStrset() bool

IsSetMapIntStrset returns true if MapIntStrset is not nil.

func (*NestedMixedx2) IsSetMapIntStrsetList 

func (v *NestedMixedx2) IsSetMapIntStrsetList() bool

IsSetMapIntStrsetList returns true if MapIntStrsetList is not nil.

func (*NestedMixedx2) MarshalLogObject 

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

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

func (*NestedMixedx2) String 

func (v *NestedMixedx2) String() string

String returns a readable string representation of a NestedMixedx2 struct.

func (*NestedMixedx2) ToWire 

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

ToWire translates a NestedMixedx2 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 Numberz 

type Numberz int32

Docstring! 

const (
	NumberzOne   Numberz = 1
	NumberzTwo   Numberz = 2
	NumberzThree Numberz = 3
	NumberzFive  Numberz = 5
	NumberzSix   Numberz = 6
	NumberzEight Numberz = 8
)
const MyNumberz Numberz = NumberzOne

func Numberz_Values 

func Numberz_Values() []Numberz

Numberz_Values returns all recognized values of Numberz.

func (*Numberz) Decode 

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

Decode reads off the encoded Numberz directly off of the wire. 

sReader := BinaryStreamer.Reader(reader)

var v Numberz
if err := v.Decode(sReader); err != nil {
    return Numberz(0), err
}
return v, nil

func (Numberz) Encode 

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

Encode encodes Numberz directly to bytes. 

sWriter := BinaryStreamer.Writer(writer)

var v Numberz
return v.Encode(sWriter)

func (Numberz) Equals 

func (v Numberz) Equals(rhs Numberz) bool

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

func (*Numberz) FromWire 

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

FromWire deserializes Numberz from its Thrift-level representation. 

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

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

func (Numberz) MarshalJSON 

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

MarshalJSON serializes Numberz into JSON.

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

This implements json.Marshaler.

func (Numberz) MarshalLogObject 

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

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of Numberz. 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 (Numberz) MarshalText 

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

MarshalText encodes Numberz to text.

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

This implements the TextMarshaler interface.

func (Numberz) Ptr 

func (v Numberz) Ptr() *Numberz

Ptr returns a pointer to this enum value.

func (Numberz) String 

func (v Numberz) String() string

String returns a readable string representation of Numberz.

func (Numberz) ToWire 

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

ToWire translates Numberz 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 (*Numberz) UnmarshalJSON 

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

UnmarshalJSON attempts to decode Numberz 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 (*Numberz) UnmarshalText 

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

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

var v Numberz
err := v.UnmarshalText([]byte("ONE"))

type OneField 

type OneField struct {
	Field *EmptyStruct `json:"field,omitempty"`
}

func (*OneField) Decode 

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

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

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

func (*OneField) Encode 

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

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

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

func (*OneField) Equals 

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

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

This function performs a deep comparison.

func (*OneField) FromWire 

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

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

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

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

func (*OneField) GetField 

func (v *OneField) GetField() (o *EmptyStruct)

GetField returns the value of Field if it is set or its zero value if it is unset.

func (*OneField) IsSetField 

func (v *OneField) IsSetField() bool

IsSetField returns true if Field is not nil.

func (*OneField) MarshalLogObject 

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

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

func (*OneField) String 

func (v *OneField) String() string

String returns a readable string representation of a OneField struct.

func (*OneField) ToWire 

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

ToWire translates a OneField 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_BlahBlah_Args 

type SecondService_BlahBlah_Args struct {
}

SecondService_BlahBlah_Args represents the arguments for the SecondService.blahBlah function.

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

func (*SecondService_BlahBlah_Args) Decode 

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

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

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

func (*SecondService_BlahBlah_Args) Encode 

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

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

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

func (*SecondService_BlahBlah_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SecondService_BlahBlah_Args) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_BlahBlah_Args) FromWire 

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

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

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

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

func (*SecondService_BlahBlah_Args) MarshalLogObject 

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

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

func (*SecondService_BlahBlah_Args) MethodName 

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

func (*SecondService_BlahBlah_Args) String 

func (v *SecondService_BlahBlah_Args) String() string

String returns a readable string representation of a SecondService_BlahBlah_Args struct.

func (*SecondService_BlahBlah_Args) ToWire 

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

ToWire translates a SecondService_BlahBlah_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_BlahBlah_Result 

type SecondService_BlahBlah_Result struct {
}

SecondService_BlahBlah_Result represents the result of a SecondService.blahBlah function call.

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

func (*SecondService_BlahBlah_Result) Decode 

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

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

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

func (*SecondService_BlahBlah_Result) Encode 

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

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

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

func (*SecondService_BlahBlah_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SecondService_BlahBlah_Result) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_BlahBlah_Result) FromWire 

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

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

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

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

func (*SecondService_BlahBlah_Result) MarshalLogObject 

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

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

func (*SecondService_BlahBlah_Result) MethodName 

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

func (*SecondService_BlahBlah_Result) String 

func (v *SecondService_BlahBlah_Result) String() string

String returns a readable string representation of a SecondService_BlahBlah_Result struct.

func (*SecondService_BlahBlah_Result) ToWire 

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

ToWire translates a SecondService_BlahBlah_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_SecondtestString_Args 

type SecondService_SecondtestString_Args struct {
	Thing *string `json:"thing,omitempty"`
}

SecondService_SecondtestString_Args represents the arguments for the SecondService.secondtestString function.

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

func (*SecondService_SecondtestString_Args) Decode 

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

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

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

func (*SecondService_SecondtestString_Args) Encode 

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

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

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

func (*SecondService_SecondtestString_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*SecondService_SecondtestString_Args) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_SecondtestString_Args) FromWire 

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

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

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

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

func (*SecondService_SecondtestString_Args) GetThing 

func (v *SecondService_SecondtestString_Args) GetThing() (o string)

GetThing returns the value of Thing if it is set or its zero value if it is unset.

func (*SecondService_SecondtestString_Args) IsSetThing 

func (v *SecondService_SecondtestString_Args) IsSetThing() bool

IsSetThing returns true if Thing is not nil.

func (*SecondService_SecondtestString_Args) MarshalLogObject 

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

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

func (*SecondService_SecondtestString_Args) MethodName 

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

func (*SecondService_SecondtestString_Args) String 

func (v *SecondService_SecondtestString_Args) String() string

String returns a readable string representation of a SecondService_SecondtestString_Args struct.

func (*SecondService_SecondtestString_Args) ToWire 

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

ToWire translates a SecondService_SecondtestString_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_SecondtestString_Result 

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

SecondService_SecondtestString_Result represents the result of a SecondService.secondtestString function call.

The result of a secondtestString 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_SecondtestString_Result) Decode 

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

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

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

func (*SecondService_SecondtestString_Result) Encode 

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

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

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

func (*SecondService_SecondtestString_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*SecondService_SecondtestString_Result) Equals 

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

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

This function performs a deep comparison.

func (*SecondService_SecondtestString_Result) FromWire 

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

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

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

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

func (*SecondService_SecondtestString_Result) GetSuccess 

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

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

func (*SecondService_SecondtestString_Result) IsSetSuccess 

func (v *SecondService_SecondtestString_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*SecondService_SecondtestString_Result) MarshalLogObject 

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

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

func (*SecondService_SecondtestString_Result) MethodName 

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

func (*SecondService_SecondtestString_Result) String 

func (v *SecondService_SecondtestString_Result) String() string

String returns a readable string representation of a SecondService_SecondtestString_Result struct.

func (*SecondService_SecondtestString_Result) ToWire 

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

ToWire translates a SecondService_SecondtestString_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 StructA 

type StructA struct {
	S string `json:"s,required"`
}

func (*StructA) Decode 

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

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

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

func (*StructA) Encode 

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

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

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

func (*StructA) Equals 

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

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

This function performs a deep comparison.

func (*StructA) FromWire 

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

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

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

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

func (*StructA) GetS 

func (v *StructA) GetS() (o string)

GetS returns the value of S if it is set or its zero value if it is unset.

func (*StructA) MarshalLogObject 

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

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

func (*StructA) String 

func (v *StructA) String() string

String returns a readable string representation of a StructA struct.

func (*StructA) ToWire 

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

ToWire translates a StructA 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 StructB 

type StructB struct {
	Aa *StructA `json:"aa,omitempty"`
	Ab *StructA `json:"ab,required"`
}

func (*StructB) Decode 

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

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

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

func (*StructB) Encode 

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

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

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

func (*StructB) Equals 

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

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

This function performs a deep comparison.

func (*StructB) FromWire 

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

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

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

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

func (*StructB) GetAa 

func (v *StructB) GetAa() (o *StructA)

GetAa returns the value of Aa if it is set or its zero value if it is unset.

func (*StructB) GetAb 

func (v *StructB) GetAb() (o *StructA)

GetAb returns the value of Ab if it is set or its zero value if it is unset.

func (*StructB) IsSetAa 

func (v *StructB) IsSetAa() bool

IsSetAa returns true if Aa is not nil.

func (*StructB) IsSetAb 

func (v *StructB) IsSetAb() bool

IsSetAb returns true if Ab is not nil.

func (*StructB) MarshalLogObject 

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

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

func (*StructB) String 

func (v *StructB) String() string

String returns a readable string representation of a StructB struct.

func (*StructB) ToWire 

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

ToWire translates a StructB 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 ThriftTest_TestBinary_Args 

type ThriftTest_TestBinary_Args struct {
	Thing []byte `json:"thing,omitempty"`
}

ThriftTest_TestBinary_Args represents the arguments for the ThriftTest.testBinary function.

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

func (*ThriftTest_TestBinary_Args) Decode 

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

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

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

func (*ThriftTest_TestBinary_Args) Encode 

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

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

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

func (*ThriftTest_TestBinary_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*ThriftTest_TestBinary_Args) Equals 

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

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

This function performs a deep comparison.

func (*ThriftTest_TestBinary_Args) FromWire 

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

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

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

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

func (*ThriftTest_TestBinary_Args) GetThing 

func (v *ThriftTest_TestBinary_Args) GetThing() (o []byte)

GetThing returns the value of Thing if it is set or its zero value if it is unset.

func (*ThriftTest_TestBinary_Args) IsSetThing 

func (v *ThriftTest_TestBinary_Args) IsSetThing() bool

IsSetThing returns true if Thing is not nil.

func (*ThriftTest_TestBinary_Args) MarshalLogObject 

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

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

func (*ThriftTest_TestBinary_Args) MethodName 

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

func (*ThriftTest_TestBinary_Args) String 

func (v *ThriftTest_TestBinary_Args) String() string

String returns a readable string representation of a ThriftTest_TestBinary_Args struct.

func (*ThriftTest_TestBinary_Args) ToWire 

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

ToWire translates a ThriftTest_TestBinary_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 ThriftTest_TestBinary_Result 

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

ThriftTest_TestBinary_Result represents the result of a ThriftTest.testBinary function call.

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

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

func (*ThriftTest_TestBinary_Result) Decode 

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

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

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

func (*ThriftTest_TestBinary_Result) Encode 

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

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

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

func (*ThriftTest_TestBinary_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*ThriftTest_TestBinary_Result) Equals 

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

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

This function performs a deep comparison.

func (*ThriftTest_TestBinary_Result) FromWire 

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

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

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

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

func (*ThriftTest_TestBinary_Result) GetSuccess 

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

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

func (*ThriftTest_TestBinary_Result) IsSetSuccess 

func (v *ThriftTest_TestBinary_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*ThriftTest_TestBinary_Result) MarshalLogObject 

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

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

func (*ThriftTest_TestBinary_Result) MethodName 

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

func (*ThriftTest_TestBinary_Result) String 

func (v *ThriftTest_TestBinary_Result) String() string

String returns a readable string representation of a ThriftTest_TestBinary_Result struct.

func (*ThriftTest_TestBinary_Result) ToWire 

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

ToWire translates a ThriftTest_TestBinary_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 ThriftTest_TestByte_Args 

type ThriftTest_TestByte_Args struct {
	Thing *int8 `json:"thing,omitempty"`
}

ThriftTest_TestByte_Args represents the arguments for the ThriftTest.testByte function.

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

func (*ThriftTest_TestByte_Args) Decode 

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

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

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

func (*ThriftTest_TestByte_Args) Encode 

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

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

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

func (*ThriftTest_TestByte_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*ThriftTest_TestByte_Args) Equals 

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

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

This function performs a deep comparison.

func (*ThriftTest_TestByte_Args) FromWire 

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

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

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

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

func (*ThriftTest_TestByte_Args) GetThing 

func (v *ThriftTest_TestByte_Args) GetThing() (o int8)

GetThing returns the value of Thing if it is set or its zero value if it is unset.

func (*ThriftTest_TestByte_Args) IsSetThing 

func (v *ThriftTest_TestByte_Args) IsSetThing() bool

IsSetThing returns true if Thing is not nil.

func (*ThriftTest_TestByte_Args) MarshalLogObject 

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

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

func (*ThriftTest_TestByte_Args) MethodName 

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

func (*ThriftTest_TestByte_Args) String 

func (v *ThriftTest_TestByte_Args) String() string

String returns a readable string representation of a ThriftTest_TestByte_Args struct.

func (*ThriftTest_TestByte_Args) ToWire 

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

ToWire translates a ThriftTest_TestByte_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 ThriftTest_TestByte_Result 

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

ThriftTest_TestByte_Result represents the result of a ThriftTest.testByte function call.

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

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

func (*ThriftTest_TestByte_Result) Decode 

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

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

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

func (*ThriftTest_TestByte_Result) Encode 

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

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

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

func (*ThriftTest_TestByte_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*ThriftTest_TestByte_Result) Equals 

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

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

This function performs a deep comparison.

func (*ThriftTest_TestByte_Result) FromWire 

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

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

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

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

func (*ThriftTest_TestByte_Result) GetSuccess 

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

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

func (*ThriftTest_TestByte_Result) IsSetSuccess 

func (v *ThriftTest_TestByte_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*ThriftTest_TestByte_Result) MarshalLogObject 

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

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

func (*ThriftTest_TestByte_Result) MethodName 

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

func (*ThriftTest_TestByte_Result) String 

func (v *ThriftTest_TestByte_Result) String() string

String returns a readable string representation of a ThriftTest_TestByte_Result struct.

func (*ThriftTest_TestByte_Result) ToWire 

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

ToWire translates a ThriftTest_TestByte_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 ThriftTest_TestDouble_Args 

type ThriftTest_TestDouble_Args struct {
	Thing *float64 `json:"thing,omitempty"`
}

ThriftTest_TestDouble_Args represents the arguments for the ThriftTest.testDouble function.

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

func (*ThriftTest_TestDouble_Args) Decode 

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

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

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

func (*ThriftTest_TestDouble_Args) Encode 

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

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

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

func (*ThriftTest_TestDouble_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*ThriftTest_TestDouble_Args) Equals 

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

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

This function performs a deep comparison.

func (*ThriftTest_TestDouble_Args) FromWire 

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

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

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

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

func (*ThriftTest_TestDouble_Args) GetThing 

func (v *ThriftTest_TestDouble_Args) GetThing() (o float64)

GetThing returns the value of Thing if it is set or its zero value if it is unset.

func (*ThriftTest_TestDouble_Args) IsSetThing 

func (v *ThriftTest_TestDouble_Args) IsSetThing() bool

IsSetThing returns true if Thing is not nil.

func (*ThriftTest_TestDouble_Args) MarshalLogObject 

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

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

func (*ThriftTest_TestDouble_Args) MethodName 

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

func (*ThriftTest_TestDouble_Args) String 

func (v *ThriftTest_TestDouble_Args) String() string

String returns a readable string representation of a ThriftTest_TestDouble_Args struct.

func (*ThriftTest_TestDouble_Args) ToWire 

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

ToWire translates a ThriftTest_TestDouble_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 ThriftTest_TestDouble_Result 

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

ThriftTest_TestDouble_Result represents the result of a ThriftTest.testDouble function call.

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

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

func (*ThriftTest_TestDouble_Result) Decode 

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

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

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

func (*ThriftTest_TestDouble_Result) Encode 

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

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

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

func (*ThriftTest_TestDouble_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*ThriftTest_TestDouble_Result) Equals 

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

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

This function performs a deep comparison.

func (*ThriftTest_TestDouble_Result) FromWire 

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

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

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

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

func (*ThriftTest_TestDouble_Result) GetSuccess 

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

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

func (*ThriftTest_TestDouble_Result) IsSetSuccess 

func (v *ThriftTest_TestDouble_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*ThriftTest_TestDouble_Result) MarshalLogObject 

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

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

func (*ThriftTest_TestDouble_Result) MethodName 

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

func (*ThriftTest_TestDouble_Result) String 

func (v *ThriftTest_TestDouble_Result) String() string

String returns a readable string representation of a ThriftTest_TestDouble_Result struct.

func (*ThriftTest_TestDouble_Result) ToWire 

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

ToWire translates a ThriftTest_TestDouble_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 ThriftTest_TestEnum_Args 

type ThriftTest_TestEnum_Args struct {
	Thing *Numberz `json:"thing,omitempty"`
}

ThriftTest_TestEnum_Args represents the arguments for the ThriftTest.testEnum function.

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

func (*ThriftTest_TestEnum_Args) Decode 

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

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

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

func (*ThriftTest_TestEnum_Args) Encode 

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

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

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

func (*ThriftTest_TestEnum_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*ThriftTest_TestEnum_Args) Equals 

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

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

This function performs a deep comparison.

func (*ThriftTest_TestEnum_Args) FromWire 

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

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

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

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

func (*ThriftTest_TestEnum_Args) GetThing 

func (v *ThriftTest_TestEnum_Args) GetThing() (o Numberz)

GetThing returns the value of Thing if it is set or its zero value if it is unset.

func (*ThriftTest_TestEnum_Args) IsSetThing 

func (v *ThriftTest_TestEnum_Args) IsSetThing() bool

IsSetThing returns true if Thing is not nil.

func (*ThriftTest_TestEnum_Args) MarshalLogObject 

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

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

func (*ThriftTest_TestEnum_Args) MethodName 

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

func (*ThriftTest_TestEnum_Args) String 

func (v *ThriftTest_TestEnum_Args) String() string

String returns a readable string representation of a ThriftTest_TestEnum_Args struct.

func (*ThriftTest_TestEnum_Args) ToWire 

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

ToWire translates a ThriftTest_TestEnum_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 ThriftTest_TestEnum_Result 

type ThriftTest_TestEnum_Result struct {
	// Value returned by testEnum after a successful execution.
	Success *Numberz `json:"success,omitempty"`
}

ThriftTest_TestEnum_Result represents the result of a ThriftTest.testEnum function call.

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

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

func (*ThriftTest_TestEnum_Result) Decode 

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

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

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

func (*ThriftTest_TestEnum_Result) Encode 

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

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

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

func (*ThriftTest_TestEnum_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*ThriftTest_TestEnum_Result) Equals 

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

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

This function performs a deep comparison.

func (*ThriftTest_TestEnum_Result) FromWire 

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

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

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

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

func (*ThriftTest_TestEnum_Result) GetSuccess 

func (v *ThriftTest_TestEnum_Result) GetSuccess() (o Numberz)

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

func (*ThriftTest_TestEnum_Result) IsSetSuccess 

func (v *ThriftTest_TestEnum_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*ThriftTest_TestEnum_Result) MarshalLogObject 

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

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

func (*ThriftTest_TestEnum_Result) MethodName 

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

func (*ThriftTest_TestEnum_Result) String 

func (v *ThriftTest_TestEnum_Result) String() string

String returns a readable string representation of a ThriftTest_TestEnum_Result struct.

func (*ThriftTest_TestEnum_Result) ToWire 

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

ToWire translates a ThriftTest_TestEnum_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 ThriftTest_TestException_Args 

type ThriftTest_TestException_Args struct {
	Arg *string `json:"arg,omitempty"`
}

ThriftTest_TestException_Args represents the arguments for the ThriftTest.testException function.

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

func (*ThriftTest_TestException_Args) Decode 

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

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

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

func (*ThriftTest_TestException_Args) Encode 

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

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

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

func (*ThriftTest_TestException_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*ThriftTest_TestException_Args) Equals 

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

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

This function performs a deep comparison.

func (*ThriftTest_TestException_Args) FromWire 

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

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

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

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

func (*ThriftTest_TestException_Args) GetArg 

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

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

func (*ThriftTest_TestException_Args) IsSetArg 

func (v *ThriftTest_TestException_Args) IsSetArg() bool

IsSetArg returns true if Arg is not nil.

func (*ThriftTest_TestException_Args) MarshalLogObject 

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

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

func (*ThriftTest_TestException_Args) MethodName 

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

func (*ThriftTest_TestException_Args) String 

func (v *ThriftTest_TestException_Args) String() string

String returns a readable string representation of a ThriftTest_TestException_Args struct.

func (*ThriftTest_TestException_Args) ToWire 

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

ToWire translates a ThriftTest_TestException_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 ThriftTest_TestException_Result 

type ThriftTest_TestException_Result struct {
	Err1 *Xception `json:"err1,omitempty"`
}

ThriftTest_TestException_Result represents the result of a ThriftTest.testException function call.

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

func (*ThriftTest_TestException_Result) Decode 

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

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

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

func (*ThriftTest_TestException_Result) Encode 

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

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

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

func (*ThriftTest_TestException_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*ThriftTest_TestException_Result) Equals 

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

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

This function performs a deep comparison.

func (*ThriftTest_TestException_Result) FromWire 

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

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

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

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

func (*ThriftTest_TestException_Result) GetErr1 

func (v *ThriftTest_TestException_Result) GetErr1() (o *Xception)

GetErr1 returns the value of Err1 if it is set or its zero value if it is unset.

func (*ThriftTest_TestException_Result) IsSetErr1 

func (v *ThriftTest_TestException_Result) IsSetErr1() bool

IsSetErr1 returns true if Err1 is not nil.

func (*ThriftTest_TestException_Result) MarshalLogObject 

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

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

func (*ThriftTest_TestException_Result) MethodName 

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

func (*ThriftTest_TestException_Result) String 

func (v *ThriftTest_TestException_Result) String() string

String returns a readable string representation of a ThriftTest_TestException_Result struct.

func (*ThriftTest_TestException_Result) ToWire 

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

ToWire translates a ThriftTest_TestException_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 ThriftTest_TestI32_Args 

type ThriftTest_TestI32_Args struct {
	Thing *int32 `json:"thing,omitempty"`
}

ThriftTest_TestI32_Args represents the arguments for the ThriftTest.testI32 function.

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

func (*ThriftTest_TestI32_Args) Decode 

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

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

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

func (*ThriftTest_TestI32_Args) Encode 

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

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

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

func (*ThriftTest_TestI32_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*ThriftTest_TestI32_Args) Equals 

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

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

This function performs a deep comparison.

func (*ThriftTest_TestI32_Args) FromWire 

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

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

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

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

func (*ThriftTest_TestI32_Args) GetThing 

func (v *ThriftTest_TestI32_Args) GetThing() (o int32)

GetThing returns the value of Thing if it is set or its zero value if it is unset.

func (*ThriftTest_TestI32_Args) IsSetThing 

func (v *ThriftTest_TestI32_Args) IsSetThing() bool

IsSetThing returns true if Thing is not nil.

func (*ThriftTest_TestI32_Args) MarshalLogObject 

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

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

func (*ThriftTest_TestI32_Args) MethodName 

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

func (*ThriftTest_TestI32_Args) String 

func (v *ThriftTest_TestI32_Args) String() string

String returns a readable string representation of a ThriftTest_TestI32_Args struct.

func (*ThriftTest_TestI32_Args) ToWire 

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

ToWire translates a ThriftTest_TestI32_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 ThriftTest_TestI32_Result 

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

ThriftTest_TestI32_Result represents the result of a ThriftTest.testI32 function call.

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

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

func (*ThriftTest_TestI32_Result) Decode 

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

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

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

func (*ThriftTest_TestI32_Result) Encode 

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

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

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

func (*ThriftTest_TestI32_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*ThriftTest_TestI32_Result) Equals 

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

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

This function performs a deep comparison.

func (*ThriftTest_TestI32_Result) FromWire 

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

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

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

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

func (*ThriftTest_TestI32_Result) GetSuccess 

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

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

func (*ThriftTest_TestI32_Result) IsSetSuccess 

func (v *ThriftTest_TestI32_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*ThriftTest_TestI32_Result) MarshalLogObject 

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

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

func (*ThriftTest_TestI32_Result) MethodName 

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

func (*ThriftTest_TestI32_Result) String 

func (v *ThriftTest_TestI32_Result) String() string

String returns a readable string representation of a ThriftTest_TestI32_Result struct.

func (*ThriftTest_TestI32_Result) ToWire 

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

ToWire translates a ThriftTest_TestI32_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 ThriftTest_TestI64_Args 

type ThriftTest_TestI64_Args struct {
	Thing *int64 `json:"thing,omitempty"`
}

ThriftTest_TestI64_Args represents the arguments for the ThriftTest.testI64 function.

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

func (*ThriftTest_TestI64_Args) Decode 

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

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

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

func (*ThriftTest_TestI64_Args) Encode 

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

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

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

func (*ThriftTest_TestI64_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*ThriftTest_TestI64_Args) Equals 

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

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

This function performs a deep comparison.

func (*ThriftTest_TestI64_Args) FromWire 

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

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

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

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

func (*ThriftTest_TestI64_Args) GetThing 

func (v *ThriftTest_TestI64_Args) GetThing() (o int64)

GetThing returns the value of Thing if it is set or its zero value if it is unset.

func (*ThriftTest_TestI64_Args) IsSetThing 

func (v *ThriftTest_TestI64_Args) IsSetThing() bool

IsSetThing returns true if Thing is not nil.

func (*ThriftTest_TestI64_Args) MarshalLogObject 

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

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

func (*ThriftTest_TestI64_Args) MethodName 

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

func (*ThriftTest_TestI64_Args) String 

func (v *ThriftTest_TestI64_Args) String() string

String returns a readable string representation of a ThriftTest_TestI64_Args struct.

func (*ThriftTest_TestI64_Args) ToWire 

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

ToWire translates a ThriftTest_TestI64_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 ThriftTest_TestI64_Result 

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

ThriftTest_TestI64_Result represents the result of a ThriftTest.testI64 function call.

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

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

func (*ThriftTest_TestI64_Result) Decode 

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

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

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

func (*ThriftTest_TestI64_Result) Encode 

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

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

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

func (*ThriftTest_TestI64_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*ThriftTest_TestI64_Result) Equals 

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

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

This function performs a deep comparison.

func (*ThriftTest_TestI64_Result) FromWire 

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

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

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

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

func (*ThriftTest_TestI64_Result) GetSuccess 

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

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

func (*ThriftTest_TestI64_Result) IsSetSuccess 

func (v *ThriftTest_TestI64_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*ThriftTest_TestI64_Result) MarshalLogObject 

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

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

func (*ThriftTest_TestI64_Result) MethodName 

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

func (*ThriftTest_TestI64_Result) String 

func (v *ThriftTest_TestI64_Result) String() string

String returns a readable string representation of a ThriftTest_TestI64_Result struct.

func (*ThriftTest_TestI64_Result) ToWire 

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

ToWire translates a ThriftTest_TestI64_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 ThriftTest_TestInsanity_Args 

type ThriftTest_TestInsanity_Args struct {
	Argument *Insanity `json:"argument,omitempty"`
}

ThriftTest_TestInsanity_Args represents the arguments for the ThriftTest.testInsanity function.

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

func (*ThriftTest_TestInsanity_Args) Decode 

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

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

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

func (*ThriftTest_TestInsanity_Args) Encode 

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

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

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

func (*ThriftTest_TestInsanity_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*ThriftTest_TestInsanity_Args) Equals 

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

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

This function performs a deep comparison.

func (*ThriftTest_TestInsanity_Args) FromWire 

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

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

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

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

func (*ThriftTest_TestInsanity_Args) GetArgument 

func (v *ThriftTest_TestInsanity_Args) GetArgument() (o *Insanity)

GetArgument returns the value of Argument if it is set or its zero value if it is unset.

func (*ThriftTest_TestInsanity_Args) IsSetArgument 

func (v *ThriftTest_TestInsanity_Args) IsSetArgument() bool

IsSetArgument returns true if Argument is not nil.

func (*ThriftTest_TestInsanity_Args) MarshalLogObject 

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

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

func (*ThriftTest_TestInsanity_Args) MethodName 

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

func (*ThriftTest_TestInsanity_Args) String 

func (v *ThriftTest_TestInsanity_Args) String() string

String returns a readable string representation of a ThriftTest_TestInsanity_Args struct.

func (*ThriftTest_TestInsanity_Args) ToWire 

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

ToWire translates a ThriftTest_TestInsanity_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 ThriftTest_TestInsanity_Result 

type ThriftTest_TestInsanity_Result struct {
	// Value returned by testInsanity after a successful execution.
	Success map[UserId]map[Numberz]*Insanity `json:"success,omitempty"`
}

ThriftTest_TestInsanity_Result represents the result of a ThriftTest.testInsanity function call.

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

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

func (*ThriftTest_TestInsanity_Result) Decode 

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

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

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

func (*ThriftTest_TestInsanity_Result) Encode 

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

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

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

func (*ThriftTest_TestInsanity_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*ThriftTest_TestInsanity_Result) Equals 

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

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

This function performs a deep comparison.

func (*ThriftTest_TestInsanity_Result) FromWire 

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

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

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

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

func (*ThriftTest_TestInsanity_Result) GetSuccess 

func (v *ThriftTest_TestInsanity_Result) GetSuccess() (o map[UserId]map[Numberz]*Insanity)

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

func (*ThriftTest_TestInsanity_Result) IsSetSuccess 

func (v *ThriftTest_TestInsanity_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*ThriftTest_TestInsanity_Result) MarshalLogObject 

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

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

func (*ThriftTest_TestInsanity_Result) MethodName 

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

func (*ThriftTest_TestInsanity_Result) String 

func (v *ThriftTest_TestInsanity_Result) String() string

String returns a readable string representation of a ThriftTest_TestInsanity_Result struct.

func (*ThriftTest_TestInsanity_Result) ToWire 

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

ToWire translates a ThriftTest_TestInsanity_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 ThriftTest_TestList_Args 

type ThriftTest_TestList_Args struct {
	Thing []int32 `json:"thing,omitempty"`
}

ThriftTest_TestList_Args represents the arguments for the ThriftTest.testList function.

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

func (*ThriftTest_TestList_Args) Decode 

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

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

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

func (*ThriftTest_TestList_Args) Encode 

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

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

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

func (*ThriftTest_TestList_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*ThriftTest_TestList_Args) Equals 

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

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

This function performs a deep comparison.

func (*ThriftTest_TestList_Args) FromWire 

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

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

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

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

func (*ThriftTest_TestList_Args) GetThing 

func (v *ThriftTest_TestList_Args) GetThing() (o []int32)

GetThing returns the value of Thing if it is set or its zero value if it is unset.

func (*ThriftTest_TestList_Args) IsSetThing 

func (v *ThriftTest_TestList_Args) IsSetThing() bool

IsSetThing returns true if Thing is not nil.

func (*ThriftTest_TestList_Args) MarshalLogObject 

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

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

func (*ThriftTest_TestList_Args) MethodName 

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

func (*ThriftTest_TestList_Args) String 

func (v *ThriftTest_TestList_Args) String() string

String returns a readable string representation of a ThriftTest_TestList_Args struct.

func (*ThriftTest_TestList_Args) ToWire 

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

ToWire translates a ThriftTest_TestList_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 ThriftTest_TestList_Result 

type ThriftTest_TestList_Result struct {
	// Value returned by testList after a successful execution.
	Success []int32 `json:"success,omitempty"`
}

ThriftTest_TestList_Result represents the result of a ThriftTest.testList function call.

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

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

func (*ThriftTest_TestList_Result) Decode 

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

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

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

func (*ThriftTest_TestList_Result) Encode 

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

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

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

func (*ThriftTest_TestList_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*ThriftTest_TestList_Result) Equals 

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

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

This function performs a deep comparison.

func (*ThriftTest_TestList_Result) FromWire 

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

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

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

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

func (*ThriftTest_TestList_Result) GetSuccess 

func (v *ThriftTest_TestList_Result) GetSuccess() (o []int32)

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

func (*ThriftTest_TestList_Result) IsSetSuccess 

func (v *ThriftTest_TestList_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*ThriftTest_TestList_Result) MarshalLogObject 

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

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

func (*ThriftTest_TestList_Result) MethodName 

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

func (*ThriftTest_TestList_Result) String 

func (v *ThriftTest_TestList_Result) String() string

String returns a readable string representation of a ThriftTest_TestList_Result struct.

func (*ThriftTest_TestList_Result) ToWire 

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

ToWire translates a ThriftTest_TestList_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 ThriftTest_TestMapMap_Args 

type ThriftTest_TestMapMap_Args struct {
	Hello *int32 `json:"hello,omitempty"`
}

ThriftTest_TestMapMap_Args represents the arguments for the ThriftTest.testMapMap function.

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

func (*ThriftTest_TestMapMap_Args) Decode 

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

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

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

func (*ThriftTest_TestMapMap_Args) Encode 

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

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

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

func (*ThriftTest_TestMapMap_Args) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*ThriftTest_TestMapMap_Args) Equals 

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

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

This function performs a deep comparison.

func (*ThriftTest_TestMapMap_Args) FromWire 

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

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

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

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

func (*ThriftTest_TestMapMap_Args) GetHello 

func (v *ThriftTest_TestMapMap_Args) GetHello() (o int32)

GetHello returns the value of Hello if it is set or its zero value if it is unset.

func (*ThriftTest_TestMapMap_Args) IsSetHello 

func (v *ThriftTest_TestMapMap_Args) IsSetHello() bool

IsSetHello returns true if Hello is not nil.

func (*ThriftTest_TestMapMap_Args) MarshalLogObject 

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

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

func (*ThriftTest_TestMapMap_Args) MethodName 

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

func (*ThriftTest_TestMapMap_Args) String 

func (v *ThriftTest_TestMapMap_Args) String() string

String returns a readable string representation of a ThriftTest_TestMapMap_Args struct.

func (*ThriftTest_TestMapMap_Args) ToWire 

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

ToWire translates a ThriftTest_TestMapMap_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 ThriftTest_TestMapMap_Result 

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

ThriftTest_TestMapMap_Result represents the result of a ThriftTest.testMapMap function call.

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

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

func (*ThriftTest_TestMapMap_Result) Decode 

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

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

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

func (*ThriftTest_TestMapMap_Result) Encode 

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

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

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

func (*ThriftTest_TestMapMap_Result) EnvelopeType 

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

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*ThriftTest_TestMapMap_Result) Equals 

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

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

This function performs a deep comparison.

func (*ThriftTest_TestMapMap_Result) FromWire 

func (v *ThriftTest_TestMapMap_Result) FromWire(w wire.Value) error

FromWire deserializes a ThriftTest_TestMapMap_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 ThriftTest_TestMapMap_Result struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v ThriftTest_TestMapMap_Result
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*ThriftTest_TestMapMap_Result) GetSuccess 

func (v *ThriftTest_TestMapMap_Result) GetSuccess() (o map[int32]map[int32]int32)

GetSuccess returns the value of Success if it is set or its zero value if it is unset.

func (*ThriftTest_TestMapMap_Result) IsSetSuccess 

func (v *ThriftTest_TestMapMap_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*ThriftTest_TestMapMap_Result) MarshalLogObject 

func (v *ThriftTest_TestMapMap_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ThriftTest_TestMapMap_Result.

func (*ThriftTest_TestMapMap_Result) MethodName 

func (v *ThriftTest_TestMapMap_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 "testMapMap" for this struct.

func (*ThriftTest_TestMapMap_Result) String 

func (v *ThriftTest_TestMapMap_Result) String() string

String returns a readable string representation of a ThriftTest_TestMapMap_Result struct.

func (*ThriftTest_TestMapMap_Result) ToWire 

func (v *ThriftTest_TestMapMap_Result) ToWire() (wire.Value, error)

ToWire translates a ThriftTest_TestMapMap_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 ThriftTest_TestMap_Args 

type ThriftTest_TestMap_Args struct {
	Thing map[int32]int32 `json:"thing,omitempty"`
}

ThriftTest_TestMap_Args represents the arguments for the ThriftTest.testMap function.

The arguments for testMap are sent and received over the wire as this struct.

func (*ThriftTest_TestMap_Args) Decode 

func (v *ThriftTest_TestMap_Args) Decode(sr stream.Reader) error

Decode deserializes a ThriftTest_TestMap_Args struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ThriftTest_TestMap_Args struct could not be generated from the wire representation.

func (*ThriftTest_TestMap_Args) Encode 

func (v *ThriftTest_TestMap_Args) Encode(sw stream.Writer) error

Encode serializes a ThriftTest_TestMap_Args struct directly into bytes, without going through an intermediary type.

An error is returned if a ThriftTest_TestMap_Args struct could not be encoded.

func (*ThriftTest_TestMap_Args) EnvelopeType 

func (v *ThriftTest_TestMap_Args) EnvelopeType() wire.EnvelopeType

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*ThriftTest_TestMap_Args) Equals 

func (v *ThriftTest_TestMap_Args) Equals(rhs *ThriftTest_TestMap_Args) bool

Equals returns true if all the fields of this ThriftTest_TestMap_Args match the provided ThriftTest_TestMap_Args.

This function performs a deep comparison.

func (*ThriftTest_TestMap_Args) FromWire 

func (v *ThriftTest_TestMap_Args) FromWire(w wire.Value) error

FromWire deserializes a ThriftTest_TestMap_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 ThriftTest_TestMap_Args struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v ThriftTest_TestMap_Args
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*ThriftTest_TestMap_Args) GetThing 

func (v *ThriftTest_TestMap_Args) GetThing() (o map[int32]int32)

GetThing returns the value of Thing if it is set or its zero value if it is unset.

func (*ThriftTest_TestMap_Args) IsSetThing 

func (v *ThriftTest_TestMap_Args) IsSetThing() bool

IsSetThing returns true if Thing is not nil.

func (*ThriftTest_TestMap_Args) MarshalLogObject 

func (v *ThriftTest_TestMap_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ThriftTest_TestMap_Args.

func (*ThriftTest_TestMap_Args) MethodName 

func (v *ThriftTest_TestMap_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 "testMap" for this struct.

func (*ThriftTest_TestMap_Args) String 

func (v *ThriftTest_TestMap_Args) String() string

String returns a readable string representation of a ThriftTest_TestMap_Args struct.

func (*ThriftTest_TestMap_Args) ToWire 

func (v *ThriftTest_TestMap_Args) ToWire() (wire.Value, error)

ToWire translates a ThriftTest_TestMap_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 ThriftTest_TestMap_Result 

type ThriftTest_TestMap_Result struct {
	// Value returned by testMap after a successful execution.
	Success map[int32]int32 `json:"success,omitempty"`
}

ThriftTest_TestMap_Result represents the result of a ThriftTest.testMap function call.

The result of a testMap execution is sent and received over the wire as this struct.

Success is set only if the function did not throw an exception.

func (*ThriftTest_TestMap_Result) Decode 

func (v *ThriftTest_TestMap_Result) Decode(sr stream.Reader) error

Decode deserializes a ThriftTest_TestMap_Result struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ThriftTest_TestMap_Result struct could not be generated from the wire representation.

func (*ThriftTest_TestMap_Result) Encode 

func (v *ThriftTest_TestMap_Result) Encode(sw stream.Writer) error

Encode serializes a ThriftTest_TestMap_Result struct directly into bytes, without going through an intermediary type.

An error is returned if a ThriftTest_TestMap_Result struct could not be encoded.

func (*ThriftTest_TestMap_Result) EnvelopeType 

func (v *ThriftTest_TestMap_Result) EnvelopeType() wire.EnvelopeType

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*ThriftTest_TestMap_Result) Equals 

func (v *ThriftTest_TestMap_Result) Equals(rhs *ThriftTest_TestMap_Result) bool

Equals returns true if all the fields of this ThriftTest_TestMap_Result match the provided ThriftTest_TestMap_Result.

This function performs a deep comparison.

func (*ThriftTest_TestMap_Result) FromWire 

func (v *ThriftTest_TestMap_Result) FromWire(w wire.Value) error

FromWire deserializes a ThriftTest_TestMap_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 ThriftTest_TestMap_Result struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v ThriftTest_TestMap_Result
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*ThriftTest_TestMap_Result) GetSuccess 

func (v *ThriftTest_TestMap_Result) GetSuccess() (o map[int32]int32)

GetSuccess returns the value of Success if it is set or its zero value if it is unset.

func (*ThriftTest_TestMap_Result) IsSetSuccess 

func (v *ThriftTest_TestMap_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*ThriftTest_TestMap_Result) MarshalLogObject 

func (v *ThriftTest_TestMap_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ThriftTest_TestMap_Result.

func (*ThriftTest_TestMap_Result) MethodName 

func (v *ThriftTest_TestMap_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 "testMap" for this struct.

func (*ThriftTest_TestMap_Result) String 

func (v *ThriftTest_TestMap_Result) String() string

String returns a readable string representation of a ThriftTest_TestMap_Result struct.

func (*ThriftTest_TestMap_Result) ToWire 

func (v *ThriftTest_TestMap_Result) ToWire() (wire.Value, error)

ToWire translates a ThriftTest_TestMap_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 ThriftTest_TestMultiException_Args 

type ThriftTest_TestMultiException_Args struct {
	Arg0 *string `json:"arg0,omitempty"`
	Arg1 *string `json:"arg1,omitempty"`
}

ThriftTest_TestMultiException_Args represents the arguments for the ThriftTest.testMultiException function.

The arguments for testMultiException are sent and received over the wire as this struct.

func (*ThriftTest_TestMultiException_Args) Decode 

func (v *ThriftTest_TestMultiException_Args) Decode(sr stream.Reader) error

Decode deserializes a ThriftTest_TestMultiException_Args struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ThriftTest_TestMultiException_Args struct could not be generated from the wire representation.

func (*ThriftTest_TestMultiException_Args) Encode 

func (v *ThriftTest_TestMultiException_Args) Encode(sw stream.Writer) error

Encode serializes a ThriftTest_TestMultiException_Args struct directly into bytes, without going through an intermediary type.

An error is returned if a ThriftTest_TestMultiException_Args struct could not be encoded.

func (*ThriftTest_TestMultiException_Args) EnvelopeType 

func (v *ThriftTest_TestMultiException_Args) EnvelopeType() wire.EnvelopeType

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*ThriftTest_TestMultiException_Args) Equals 

func (v *ThriftTest_TestMultiException_Args) Equals(rhs *ThriftTest_TestMultiException_Args) bool

Equals returns true if all the fields of this ThriftTest_TestMultiException_Args match the provided ThriftTest_TestMultiException_Args.

This function performs a deep comparison.

func (*ThriftTest_TestMultiException_Args) FromWire 

func (v *ThriftTest_TestMultiException_Args) FromWire(w wire.Value) error

FromWire deserializes a ThriftTest_TestMultiException_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 ThriftTest_TestMultiException_Args struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v ThriftTest_TestMultiException_Args
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*ThriftTest_TestMultiException_Args) GetArg0 

func (v *ThriftTest_TestMultiException_Args) GetArg0() (o string)

GetArg0 returns the value of Arg0 if it is set or its zero value if it is unset.

func (*ThriftTest_TestMultiException_Args) GetArg1 

func (v *ThriftTest_TestMultiException_Args) GetArg1() (o string)

GetArg1 returns the value of Arg1 if it is set or its zero value if it is unset.

func (*ThriftTest_TestMultiException_Args) IsSetArg0 

func (v *ThriftTest_TestMultiException_Args) IsSetArg0() bool

IsSetArg0 returns true if Arg0 is not nil.

func (*ThriftTest_TestMultiException_Args) IsSetArg1 

func (v *ThriftTest_TestMultiException_Args) IsSetArg1() bool

IsSetArg1 returns true if Arg1 is not nil.

func (*ThriftTest_TestMultiException_Args) MarshalLogObject 

func (v *ThriftTest_TestMultiException_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ThriftTest_TestMultiException_Args.

func (*ThriftTest_TestMultiException_Args) MethodName 

func (v *ThriftTest_TestMultiException_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 "testMultiException" for this struct.

func (*ThriftTest_TestMultiException_Args) String 

func (v *ThriftTest_TestMultiException_Args) String() string

String returns a readable string representation of a ThriftTest_TestMultiException_Args struct.

func (*ThriftTest_TestMultiException_Args) ToWire 

func (v *ThriftTest_TestMultiException_Args) ToWire() (wire.Value, error)

ToWire translates a ThriftTest_TestMultiException_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 ThriftTest_TestMultiException_Result 

type ThriftTest_TestMultiException_Result struct {
	// Value returned by testMultiException after a successful execution.
	Success *Xtruct    `json:"success,omitempty"`
	Err1    *Xception  `json:"err1,omitempty"`
	Err2    *Xception2 `json:"err2,omitempty"`
}

ThriftTest_TestMultiException_Result represents the result of a ThriftTest.testMultiException function call.

The result of a testMultiException execution is sent and received over the wire as this struct.

Success is set only if the function did not throw an exception.

func (*ThriftTest_TestMultiException_Result) Decode 

func (v *ThriftTest_TestMultiException_Result) Decode(sr stream.Reader) error

Decode deserializes a ThriftTest_TestMultiException_Result struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ThriftTest_TestMultiException_Result struct could not be generated from the wire representation.

func (*ThriftTest_TestMultiException_Result) Encode 

func (v *ThriftTest_TestMultiException_Result) Encode(sw stream.Writer) error

Encode serializes a ThriftTest_TestMultiException_Result struct directly into bytes, without going through an intermediary type.

An error is returned if a ThriftTest_TestMultiException_Result struct could not be encoded.

func (*ThriftTest_TestMultiException_Result) EnvelopeType 

func (v *ThriftTest_TestMultiException_Result) EnvelopeType() wire.EnvelopeType

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*ThriftTest_TestMultiException_Result) Equals 

func (v *ThriftTest_TestMultiException_Result) Equals(rhs *ThriftTest_TestMultiException_Result) bool

Equals returns true if all the fields of this ThriftTest_TestMultiException_Result match the provided ThriftTest_TestMultiException_Result.

This function performs a deep comparison.

func (*ThriftTest_TestMultiException_Result) FromWire 

func (v *ThriftTest_TestMultiException_Result) FromWire(w wire.Value) error

FromWire deserializes a ThriftTest_TestMultiException_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 ThriftTest_TestMultiException_Result struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v ThriftTest_TestMultiException_Result
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*ThriftTest_TestMultiException_Result) GetErr1 

func (v *ThriftTest_TestMultiException_Result) GetErr1() (o *Xception)

GetErr1 returns the value of Err1 if it is set or its zero value if it is unset.

func (*ThriftTest_TestMultiException_Result) GetErr2 

func (v *ThriftTest_TestMultiException_Result) GetErr2() (o *Xception2)

GetErr2 returns the value of Err2 if it is set or its zero value if it is unset.

func (*ThriftTest_TestMultiException_Result) GetSuccess 

func (v *ThriftTest_TestMultiException_Result) GetSuccess() (o *Xtruct)

GetSuccess returns the value of Success if it is set or its zero value if it is unset.

func (*ThriftTest_TestMultiException_Result) IsSetErr1 

func (v *ThriftTest_TestMultiException_Result) IsSetErr1() bool

IsSetErr1 returns true if Err1 is not nil.

func (*ThriftTest_TestMultiException_Result) IsSetErr2 

func (v *ThriftTest_TestMultiException_Result) IsSetErr2() bool

IsSetErr2 returns true if Err2 is not nil.

func (*ThriftTest_TestMultiException_Result) IsSetSuccess 

func (v *ThriftTest_TestMultiException_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*ThriftTest_TestMultiException_Result) MarshalLogObject 

func (v *ThriftTest_TestMultiException_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ThriftTest_TestMultiException_Result.

func (*ThriftTest_TestMultiException_Result) MethodName 

func (v *ThriftTest_TestMultiException_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 "testMultiException" for this struct.

func (*ThriftTest_TestMultiException_Result) String 

func (v *ThriftTest_TestMultiException_Result) String() string

String returns a readable string representation of a ThriftTest_TestMultiException_Result struct.

func (*ThriftTest_TestMultiException_Result) ToWire 

func (v *ThriftTest_TestMultiException_Result) ToWire() (wire.Value, error)

ToWire translates a ThriftTest_TestMultiException_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 ThriftTest_TestMulti_Args 

type ThriftTest_TestMulti_Args struct {
	Arg0 *int8            `json:"arg0,omitempty"`
	Arg1 *int32           `json:"arg1,omitempty"`
	Arg2 *int64           `json:"arg2,omitempty"`
	Arg3 map[int16]string `json:"arg3,omitempty"`
	Arg4 *Numberz         `json:"arg4,omitempty"`
	Arg5 *UserId          `json:"arg5,omitempty"`
}

ThriftTest_TestMulti_Args represents the arguments for the ThriftTest.testMulti function.

The arguments for testMulti are sent and received over the wire as this struct.

func (*ThriftTest_TestMulti_Args) Decode 

func (v *ThriftTest_TestMulti_Args) Decode(sr stream.Reader) error

Decode deserializes a ThriftTest_TestMulti_Args struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ThriftTest_TestMulti_Args struct could not be generated from the wire representation.

func (*ThriftTest_TestMulti_Args) Encode 

func (v *ThriftTest_TestMulti_Args) Encode(sw stream.Writer) error

Encode serializes a ThriftTest_TestMulti_Args struct directly into bytes, without going through an intermediary type.

An error is returned if a ThriftTest_TestMulti_Args struct could not be encoded.

func (*ThriftTest_TestMulti_Args) EnvelopeType 

func (v *ThriftTest_TestMulti_Args) EnvelopeType() wire.EnvelopeType

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*ThriftTest_TestMulti_Args) Equals 

func (v *ThriftTest_TestMulti_Args) Equals(rhs *ThriftTest_TestMulti_Args) bool

Equals returns true if all the fields of this ThriftTest_TestMulti_Args match the provided ThriftTest_TestMulti_Args.

This function performs a deep comparison.

func (*ThriftTest_TestMulti_Args) FromWire 

func (v *ThriftTest_TestMulti_Args) FromWire(w wire.Value) error

FromWire deserializes a ThriftTest_TestMulti_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 ThriftTest_TestMulti_Args struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v ThriftTest_TestMulti_Args
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*ThriftTest_TestMulti_Args) GetArg0 

func (v *ThriftTest_TestMulti_Args) GetArg0() (o int8)

GetArg0 returns the value of Arg0 if it is set or its zero value if it is unset.

func (*ThriftTest_TestMulti_Args) GetArg1 

func (v *ThriftTest_TestMulti_Args) GetArg1() (o int32)

GetArg1 returns the value of Arg1 if it is set or its zero value if it is unset.

func (*ThriftTest_TestMulti_Args) GetArg2 

func (v *ThriftTest_TestMulti_Args) GetArg2() (o int64)

GetArg2 returns the value of Arg2 if it is set or its zero value if it is unset.

func (*ThriftTest_TestMulti_Args) GetArg3 

func (v *ThriftTest_TestMulti_Args) GetArg3() (o map[int16]string)

GetArg3 returns the value of Arg3 if it is set or its zero value if it is unset.

func (*ThriftTest_TestMulti_Args) GetArg4 

func (v *ThriftTest_TestMulti_Args) GetArg4() (o Numberz)

GetArg4 returns the value of Arg4 if it is set or its zero value if it is unset.

func (*ThriftTest_TestMulti_Args) GetArg5 

func (v *ThriftTest_TestMulti_Args) GetArg5() (o UserId)

GetArg5 returns the value of Arg5 if it is set or its zero value if it is unset.

func (*ThriftTest_TestMulti_Args) IsSetArg0 

func (v *ThriftTest_TestMulti_Args) IsSetArg0() bool

IsSetArg0 returns true if Arg0 is not nil.

func (*ThriftTest_TestMulti_Args) IsSetArg1 

func (v *ThriftTest_TestMulti_Args) IsSetArg1() bool

IsSetArg1 returns true if Arg1 is not nil.

func (*ThriftTest_TestMulti_Args) IsSetArg2 

func (v *ThriftTest_TestMulti_Args) IsSetArg2() bool

IsSetArg2 returns true if Arg2 is not nil.

func (*ThriftTest_TestMulti_Args) IsSetArg3 

func (v *ThriftTest_TestMulti_Args) IsSetArg3() bool

IsSetArg3 returns true if Arg3 is not nil.

func (*ThriftTest_TestMulti_Args) IsSetArg4 

func (v *ThriftTest_TestMulti_Args) IsSetArg4() bool

IsSetArg4 returns true if Arg4 is not nil.

func (*ThriftTest_TestMulti_Args) IsSetArg5 

func (v *ThriftTest_TestMulti_Args) IsSetArg5() bool

IsSetArg5 returns true if Arg5 is not nil.

func (*ThriftTest_TestMulti_Args) MarshalLogObject 

func (v *ThriftTest_TestMulti_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ThriftTest_TestMulti_Args.

func (*ThriftTest_TestMulti_Args) MethodName 

func (v *ThriftTest_TestMulti_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 "testMulti" for this struct.

func (*ThriftTest_TestMulti_Args) String 

func (v *ThriftTest_TestMulti_Args) String() string

String returns a readable string representation of a ThriftTest_TestMulti_Args struct.

func (*ThriftTest_TestMulti_Args) ToWire 

func (v *ThriftTest_TestMulti_Args) ToWire() (wire.Value, error)

ToWire translates a ThriftTest_TestMulti_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 ThriftTest_TestMulti_Result 

type ThriftTest_TestMulti_Result struct {
	// Value returned by testMulti after a successful execution.
	Success *Xtruct `json:"success,omitempty"`
}

ThriftTest_TestMulti_Result represents the result of a ThriftTest.testMulti function call.

The result of a testMulti execution is sent and received over the wire as this struct.

Success is set only if the function did not throw an exception.

func (*ThriftTest_TestMulti_Result) Decode 

func (v *ThriftTest_TestMulti_Result) Decode(sr stream.Reader) error

Decode deserializes a ThriftTest_TestMulti_Result struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ThriftTest_TestMulti_Result struct could not be generated from the wire representation.

func (*ThriftTest_TestMulti_Result) Encode 

func (v *ThriftTest_TestMulti_Result) Encode(sw stream.Writer) error

Encode serializes a ThriftTest_TestMulti_Result struct directly into bytes, without going through an intermediary type.

An error is returned if a ThriftTest_TestMulti_Result struct could not be encoded.

func (*ThriftTest_TestMulti_Result) EnvelopeType 

func (v *ThriftTest_TestMulti_Result) EnvelopeType() wire.EnvelopeType

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*ThriftTest_TestMulti_Result) Equals 

func (v *ThriftTest_TestMulti_Result) Equals(rhs *ThriftTest_TestMulti_Result) bool

Equals returns true if all the fields of this ThriftTest_TestMulti_Result match the provided ThriftTest_TestMulti_Result.

This function performs a deep comparison.

func (*ThriftTest_TestMulti_Result) FromWire 

func (v *ThriftTest_TestMulti_Result) FromWire(w wire.Value) error

FromWire deserializes a ThriftTest_TestMulti_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 ThriftTest_TestMulti_Result struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v ThriftTest_TestMulti_Result
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*ThriftTest_TestMulti_Result) GetSuccess 

func (v *ThriftTest_TestMulti_Result) GetSuccess() (o *Xtruct)

GetSuccess returns the value of Success if it is set or its zero value if it is unset.

func (*ThriftTest_TestMulti_Result) IsSetSuccess 

func (v *ThriftTest_TestMulti_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*ThriftTest_TestMulti_Result) MarshalLogObject 

func (v *ThriftTest_TestMulti_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ThriftTest_TestMulti_Result.

func (*ThriftTest_TestMulti_Result) MethodName 

func (v *ThriftTest_TestMulti_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 "testMulti" for this struct.

func (*ThriftTest_TestMulti_Result) String 

func (v *ThriftTest_TestMulti_Result) String() string

String returns a readable string representation of a ThriftTest_TestMulti_Result struct.

func (*ThriftTest_TestMulti_Result) ToWire 

func (v *ThriftTest_TestMulti_Result) ToWire() (wire.Value, error)

ToWire translates a ThriftTest_TestMulti_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 ThriftTest_TestNest_Args 

type ThriftTest_TestNest_Args struct {
	Thing *Xtruct2 `json:"thing,omitempty"`
}

ThriftTest_TestNest_Args represents the arguments for the ThriftTest.testNest function.

The arguments for testNest are sent and received over the wire as this struct.

func (*ThriftTest_TestNest_Args) Decode 

func (v *ThriftTest_TestNest_Args) Decode(sr stream.Reader) error

Decode deserializes a ThriftTest_TestNest_Args struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ThriftTest_TestNest_Args struct could not be generated from the wire representation.

func (*ThriftTest_TestNest_Args) Encode 

func (v *ThriftTest_TestNest_Args) Encode(sw stream.Writer) error

Encode serializes a ThriftTest_TestNest_Args struct directly into bytes, without going through an intermediary type.

An error is returned if a ThriftTest_TestNest_Args struct could not be encoded.

func (*ThriftTest_TestNest_Args) EnvelopeType 

func (v *ThriftTest_TestNest_Args) EnvelopeType() wire.EnvelopeType

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*ThriftTest_TestNest_Args) Equals 

func (v *ThriftTest_TestNest_Args) Equals(rhs *ThriftTest_TestNest_Args) bool

Equals returns true if all the fields of this ThriftTest_TestNest_Args match the provided ThriftTest_TestNest_Args.

This function performs a deep comparison.

func (*ThriftTest_TestNest_Args) FromWire 

func (v *ThriftTest_TestNest_Args) FromWire(w wire.Value) error

FromWire deserializes a ThriftTest_TestNest_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 ThriftTest_TestNest_Args struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v ThriftTest_TestNest_Args
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*ThriftTest_TestNest_Args) GetThing 

func (v *ThriftTest_TestNest_Args) GetThing() (o *Xtruct2)

GetThing returns the value of Thing if it is set or its zero value if it is unset.

func (*ThriftTest_TestNest_Args) IsSetThing 

func (v *ThriftTest_TestNest_Args) IsSetThing() bool

IsSetThing returns true if Thing is not nil.

func (*ThriftTest_TestNest_Args) MarshalLogObject 

func (v *ThriftTest_TestNest_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ThriftTest_TestNest_Args.

func (*ThriftTest_TestNest_Args) MethodName 

func (v *ThriftTest_TestNest_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 "testNest" for this struct.

func (*ThriftTest_TestNest_Args) String 

func (v *ThriftTest_TestNest_Args) String() string

String returns a readable string representation of a ThriftTest_TestNest_Args struct.

func (*ThriftTest_TestNest_Args) ToWire 

func (v *ThriftTest_TestNest_Args) ToWire() (wire.Value, error)

ToWire translates a ThriftTest_TestNest_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 ThriftTest_TestNest_Result 

type ThriftTest_TestNest_Result struct {
	// Value returned by testNest after a successful execution.
	Success *Xtruct2 `json:"success,omitempty"`
}

ThriftTest_TestNest_Result represents the result of a ThriftTest.testNest function call.

The result of a testNest execution is sent and received over the wire as this struct.

Success is set only if the function did not throw an exception.

func (*ThriftTest_TestNest_Result) Decode 

func (v *ThriftTest_TestNest_Result) Decode(sr stream.Reader) error

Decode deserializes a ThriftTest_TestNest_Result struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ThriftTest_TestNest_Result struct could not be generated from the wire representation.

func (*ThriftTest_TestNest_Result) Encode 

func (v *ThriftTest_TestNest_Result) Encode(sw stream.Writer) error

Encode serializes a ThriftTest_TestNest_Result struct directly into bytes, without going through an intermediary type.

An error is returned if a ThriftTest_TestNest_Result struct could not be encoded.

func (*ThriftTest_TestNest_Result) EnvelopeType 

func (v *ThriftTest_TestNest_Result) EnvelopeType() wire.EnvelopeType

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*ThriftTest_TestNest_Result) Equals 

func (v *ThriftTest_TestNest_Result) Equals(rhs *ThriftTest_TestNest_Result) bool

Equals returns true if all the fields of this ThriftTest_TestNest_Result match the provided ThriftTest_TestNest_Result.

This function performs a deep comparison.

func (*ThriftTest_TestNest_Result) FromWire 

func (v *ThriftTest_TestNest_Result) FromWire(w wire.Value) error

FromWire deserializes a ThriftTest_TestNest_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 ThriftTest_TestNest_Result struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v ThriftTest_TestNest_Result
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*ThriftTest_TestNest_Result) GetSuccess 

func (v *ThriftTest_TestNest_Result) GetSuccess() (o *Xtruct2)

GetSuccess returns the value of Success if it is set or its zero value if it is unset.

func (*ThriftTest_TestNest_Result) IsSetSuccess 

func (v *ThriftTest_TestNest_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*ThriftTest_TestNest_Result) MarshalLogObject 

func (v *ThriftTest_TestNest_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ThriftTest_TestNest_Result.

func (*ThriftTest_TestNest_Result) MethodName 

func (v *ThriftTest_TestNest_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 "testNest" for this struct.

func (*ThriftTest_TestNest_Result) String 

func (v *ThriftTest_TestNest_Result) String() string

String returns a readable string representation of a ThriftTest_TestNest_Result struct.

func (*ThriftTest_TestNest_Result) ToWire 

func (v *ThriftTest_TestNest_Result) ToWire() (wire.Value, error)

ToWire translates a ThriftTest_TestNest_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 ThriftTest_TestOneway_Args 

type ThriftTest_TestOneway_Args struct {
	SecondsToSleep *int32 `json:"secondsToSleep,omitempty"`
}

ThriftTest_TestOneway_Args represents the arguments for the ThriftTest.testOneway function.

The arguments for testOneway are sent and received over the wire as this struct.

func (*ThriftTest_TestOneway_Args) Decode 

func (v *ThriftTest_TestOneway_Args) Decode(sr stream.Reader) error

Decode deserializes a ThriftTest_TestOneway_Args struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ThriftTest_TestOneway_Args struct could not be generated from the wire representation.

func (*ThriftTest_TestOneway_Args) Encode 

func (v *ThriftTest_TestOneway_Args) Encode(sw stream.Writer) error

Encode serializes a ThriftTest_TestOneway_Args struct directly into bytes, without going through an intermediary type.

An error is returned if a ThriftTest_TestOneway_Args struct could not be encoded.

func (*ThriftTest_TestOneway_Args) EnvelopeType 

func (v *ThriftTest_TestOneway_Args) EnvelopeType() wire.EnvelopeType

EnvelopeType returns the kind of value inside this struct.

This will always be OneWay for this struct.

func (*ThriftTest_TestOneway_Args) Equals 

func (v *ThriftTest_TestOneway_Args) Equals(rhs *ThriftTest_TestOneway_Args) bool

Equals returns true if all the fields of this ThriftTest_TestOneway_Args match the provided ThriftTest_TestOneway_Args.

This function performs a deep comparison.

func (*ThriftTest_TestOneway_Args) FromWire 

func (v *ThriftTest_TestOneway_Args) FromWire(w wire.Value) error

FromWire deserializes a ThriftTest_TestOneway_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 ThriftTest_TestOneway_Args struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v ThriftTest_TestOneway_Args
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*ThriftTest_TestOneway_Args) GetSecondsToSleep 

func (v *ThriftTest_TestOneway_Args) GetSecondsToSleep() (o int32)

GetSecondsToSleep returns the value of SecondsToSleep if it is set or its zero value if it is unset.

func (*ThriftTest_TestOneway_Args) IsSetSecondsToSleep 

func (v *ThriftTest_TestOneway_Args) IsSetSecondsToSleep() bool

IsSetSecondsToSleep returns true if SecondsToSleep is not nil.

func (*ThriftTest_TestOneway_Args) MarshalLogObject 

func (v *ThriftTest_TestOneway_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ThriftTest_TestOneway_Args.

func (*ThriftTest_TestOneway_Args) MethodName 

func (v *ThriftTest_TestOneway_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 "testOneway" for this struct.

func (*ThriftTest_TestOneway_Args) String 

func (v *ThriftTest_TestOneway_Args) String() string

String returns a readable string representation of a ThriftTest_TestOneway_Args struct.

func (*ThriftTest_TestOneway_Args) ToWire 

func (v *ThriftTest_TestOneway_Args) ToWire() (wire.Value, error)

ToWire translates a ThriftTest_TestOneway_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 ThriftTest_TestSet_Args 

type ThriftTest_TestSet_Args struct {
	Thing map[int32]struct{} `json:"thing,omitempty"`
}

ThriftTest_TestSet_Args represents the arguments for the ThriftTest.testSet function.

The arguments for testSet are sent and received over the wire as this struct.

func (*ThriftTest_TestSet_Args) Decode 

func (v *ThriftTest_TestSet_Args) Decode(sr stream.Reader) error

Decode deserializes a ThriftTest_TestSet_Args struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ThriftTest_TestSet_Args struct could not be generated from the wire representation.

func (*ThriftTest_TestSet_Args) Encode 

func (v *ThriftTest_TestSet_Args) Encode(sw stream.Writer) error

Encode serializes a ThriftTest_TestSet_Args struct directly into bytes, without going through an intermediary type.

An error is returned if a ThriftTest_TestSet_Args struct could not be encoded.

func (*ThriftTest_TestSet_Args) EnvelopeType 

func (v *ThriftTest_TestSet_Args) EnvelopeType() wire.EnvelopeType

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*ThriftTest_TestSet_Args) Equals 

func (v *ThriftTest_TestSet_Args) Equals(rhs *ThriftTest_TestSet_Args) bool

Equals returns true if all the fields of this ThriftTest_TestSet_Args match the provided ThriftTest_TestSet_Args.

This function performs a deep comparison.

func (*ThriftTest_TestSet_Args) FromWire 

func (v *ThriftTest_TestSet_Args) FromWire(w wire.Value) error

FromWire deserializes a ThriftTest_TestSet_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 ThriftTest_TestSet_Args struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v ThriftTest_TestSet_Args
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*ThriftTest_TestSet_Args) GetThing 

func (v *ThriftTest_TestSet_Args) GetThing() (o map[int32]struct{})

GetThing returns the value of Thing if it is set or its zero value if it is unset.

func (*ThriftTest_TestSet_Args) IsSetThing 

func (v *ThriftTest_TestSet_Args) IsSetThing() bool

IsSetThing returns true if Thing is not nil.

func (*ThriftTest_TestSet_Args) MarshalLogObject 

func (v *ThriftTest_TestSet_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ThriftTest_TestSet_Args.

func (*ThriftTest_TestSet_Args) MethodName 

func (v *ThriftTest_TestSet_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 "testSet" for this struct.

func (*ThriftTest_TestSet_Args) String 

func (v *ThriftTest_TestSet_Args) String() string

String returns a readable string representation of a ThriftTest_TestSet_Args struct.

func (*ThriftTest_TestSet_Args) ToWire 

func (v *ThriftTest_TestSet_Args) ToWire() (wire.Value, error)

ToWire translates a ThriftTest_TestSet_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 ThriftTest_TestSet_Result 

type ThriftTest_TestSet_Result struct {
	// Value returned by testSet after a successful execution.
	Success map[int32]struct{} `json:"success,omitempty"`
}

ThriftTest_TestSet_Result represents the result of a ThriftTest.testSet function call.

The result of a testSet execution is sent and received over the wire as this struct.

Success is set only if the function did not throw an exception.

func (*ThriftTest_TestSet_Result) Decode 

func (v *ThriftTest_TestSet_Result) Decode(sr stream.Reader) error

Decode deserializes a ThriftTest_TestSet_Result struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ThriftTest_TestSet_Result struct could not be generated from the wire representation.

func (*ThriftTest_TestSet_Result) Encode 

func (v *ThriftTest_TestSet_Result) Encode(sw stream.Writer) error

Encode serializes a ThriftTest_TestSet_Result struct directly into bytes, without going through an intermediary type.

An error is returned if a ThriftTest_TestSet_Result struct could not be encoded.

func (*ThriftTest_TestSet_Result) EnvelopeType 

func (v *ThriftTest_TestSet_Result) EnvelopeType() wire.EnvelopeType

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*ThriftTest_TestSet_Result) Equals 

func (v *ThriftTest_TestSet_Result) Equals(rhs *ThriftTest_TestSet_Result) bool

Equals returns true if all the fields of this ThriftTest_TestSet_Result match the provided ThriftTest_TestSet_Result.

This function performs a deep comparison.

func (*ThriftTest_TestSet_Result) FromWire 

func (v *ThriftTest_TestSet_Result) FromWire(w wire.Value) error

FromWire deserializes a ThriftTest_TestSet_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 ThriftTest_TestSet_Result struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v ThriftTest_TestSet_Result
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*ThriftTest_TestSet_Result) GetSuccess 

func (v *ThriftTest_TestSet_Result) GetSuccess() (o map[int32]struct{})

GetSuccess returns the value of Success if it is set or its zero value if it is unset.

func (*ThriftTest_TestSet_Result) IsSetSuccess 

func (v *ThriftTest_TestSet_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*ThriftTest_TestSet_Result) MarshalLogObject 

func (v *ThriftTest_TestSet_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ThriftTest_TestSet_Result.

func (*ThriftTest_TestSet_Result) MethodName 

func (v *ThriftTest_TestSet_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 "testSet" for this struct.

func (*ThriftTest_TestSet_Result) String 

func (v *ThriftTest_TestSet_Result) String() string

String returns a readable string representation of a ThriftTest_TestSet_Result struct.

func (*ThriftTest_TestSet_Result) ToWire 

func (v *ThriftTest_TestSet_Result) ToWire() (wire.Value, error)

ToWire translates a ThriftTest_TestSet_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 ThriftTest_TestStringMap_Args 

type ThriftTest_TestStringMap_Args struct {
	Thing map[string]string `json:"thing,omitempty"`
}

ThriftTest_TestStringMap_Args represents the arguments for the ThriftTest.testStringMap function.

The arguments for testStringMap are sent and received over the wire as this struct.

func (*ThriftTest_TestStringMap_Args) Decode 

func (v *ThriftTest_TestStringMap_Args) Decode(sr stream.Reader) error

Decode deserializes a ThriftTest_TestStringMap_Args struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ThriftTest_TestStringMap_Args struct could not be generated from the wire representation.

func (*ThriftTest_TestStringMap_Args) Encode 

func (v *ThriftTest_TestStringMap_Args) Encode(sw stream.Writer) error

Encode serializes a ThriftTest_TestStringMap_Args struct directly into bytes, without going through an intermediary type.

An error is returned if a ThriftTest_TestStringMap_Args struct could not be encoded.

func (*ThriftTest_TestStringMap_Args) EnvelopeType 

func (v *ThriftTest_TestStringMap_Args) EnvelopeType() wire.EnvelopeType

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*ThriftTest_TestStringMap_Args) Equals 

func (v *ThriftTest_TestStringMap_Args) Equals(rhs *ThriftTest_TestStringMap_Args) bool

Equals returns true if all the fields of this ThriftTest_TestStringMap_Args match the provided ThriftTest_TestStringMap_Args.

This function performs a deep comparison.

func (*ThriftTest_TestStringMap_Args) FromWire 

func (v *ThriftTest_TestStringMap_Args) FromWire(w wire.Value) error

FromWire deserializes a ThriftTest_TestStringMap_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 ThriftTest_TestStringMap_Args struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v ThriftTest_TestStringMap_Args
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*ThriftTest_TestStringMap_Args) GetThing 

func (v *ThriftTest_TestStringMap_Args) GetThing() (o map[string]string)

GetThing returns the value of Thing if it is set or its zero value if it is unset.

func (*ThriftTest_TestStringMap_Args) IsSetThing 

func (v *ThriftTest_TestStringMap_Args) IsSetThing() bool

IsSetThing returns true if Thing is not nil.

func (*ThriftTest_TestStringMap_Args) MarshalLogObject 

func (v *ThriftTest_TestStringMap_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ThriftTest_TestStringMap_Args.

func (*ThriftTest_TestStringMap_Args) MethodName 

func (v *ThriftTest_TestStringMap_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 "testStringMap" for this struct.

func (*ThriftTest_TestStringMap_Args) String 

func (v *ThriftTest_TestStringMap_Args) String() string

String returns a readable string representation of a ThriftTest_TestStringMap_Args struct.

func (*ThriftTest_TestStringMap_Args) ToWire 

func (v *ThriftTest_TestStringMap_Args) ToWire() (wire.Value, error)

ToWire translates a ThriftTest_TestStringMap_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 ThriftTest_TestStringMap_Result 

type ThriftTest_TestStringMap_Result struct {
	// Value returned by testStringMap after a successful execution.
	Success map[string]string `json:"success,omitempty"`
}

ThriftTest_TestStringMap_Result represents the result of a ThriftTest.testStringMap function call.

The result of a testStringMap execution is sent and received over the wire as this struct.

Success is set only if the function did not throw an exception.

func (*ThriftTest_TestStringMap_Result) Decode 

func (v *ThriftTest_TestStringMap_Result) Decode(sr stream.Reader) error

Decode deserializes a ThriftTest_TestStringMap_Result struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ThriftTest_TestStringMap_Result struct could not be generated from the wire representation.

func (*ThriftTest_TestStringMap_Result) Encode 

func (v *ThriftTest_TestStringMap_Result) Encode(sw stream.Writer) error

Encode serializes a ThriftTest_TestStringMap_Result struct directly into bytes, without going through an intermediary type.

An error is returned if a ThriftTest_TestStringMap_Result struct could not be encoded.

func (*ThriftTest_TestStringMap_Result) EnvelopeType 

func (v *ThriftTest_TestStringMap_Result) EnvelopeType() wire.EnvelopeType

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*ThriftTest_TestStringMap_Result) Equals 

func (v *ThriftTest_TestStringMap_Result) Equals(rhs *ThriftTest_TestStringMap_Result) bool

Equals returns true if all the fields of this ThriftTest_TestStringMap_Result match the provided ThriftTest_TestStringMap_Result.

This function performs a deep comparison.

func (*ThriftTest_TestStringMap_Result) FromWire 

func (v *ThriftTest_TestStringMap_Result) FromWire(w wire.Value) error

FromWire deserializes a ThriftTest_TestStringMap_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 ThriftTest_TestStringMap_Result struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v ThriftTest_TestStringMap_Result
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*ThriftTest_TestStringMap_Result) GetSuccess 

func (v *ThriftTest_TestStringMap_Result) GetSuccess() (o map[string]string)

GetSuccess returns the value of Success if it is set or its zero value if it is unset.

func (*ThriftTest_TestStringMap_Result) IsSetSuccess 

func (v *ThriftTest_TestStringMap_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*ThriftTest_TestStringMap_Result) MarshalLogObject 

func (v *ThriftTest_TestStringMap_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ThriftTest_TestStringMap_Result.

func (*ThriftTest_TestStringMap_Result) MethodName 

func (v *ThriftTest_TestStringMap_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 "testStringMap" for this struct.

func (*ThriftTest_TestStringMap_Result) String 

func (v *ThriftTest_TestStringMap_Result) String() string

String returns a readable string representation of a ThriftTest_TestStringMap_Result struct.

func (*ThriftTest_TestStringMap_Result) ToWire 

func (v *ThriftTest_TestStringMap_Result) ToWire() (wire.Value, error)

ToWire translates a ThriftTest_TestStringMap_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 ThriftTest_TestString_Args 

type ThriftTest_TestString_Args struct {
	Thing *string `json:"thing,omitempty"`
}

ThriftTest_TestString_Args represents the arguments for the ThriftTest.testString function.

The arguments for testString are sent and received over the wire as this struct.

func (*ThriftTest_TestString_Args) Decode 

func (v *ThriftTest_TestString_Args) Decode(sr stream.Reader) error

Decode deserializes a ThriftTest_TestString_Args struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ThriftTest_TestString_Args struct could not be generated from the wire representation.

func (*ThriftTest_TestString_Args) Encode 

func (v *ThriftTest_TestString_Args) Encode(sw stream.Writer) error

Encode serializes a ThriftTest_TestString_Args struct directly into bytes, without going through an intermediary type.

An error is returned if a ThriftTest_TestString_Args struct could not be encoded.

func (*ThriftTest_TestString_Args) EnvelopeType 

func (v *ThriftTest_TestString_Args) EnvelopeType() wire.EnvelopeType

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*ThriftTest_TestString_Args) Equals 

func (v *ThriftTest_TestString_Args) Equals(rhs *ThriftTest_TestString_Args) bool

Equals returns true if all the fields of this ThriftTest_TestString_Args match the provided ThriftTest_TestString_Args.

This function performs a deep comparison.

func (*ThriftTest_TestString_Args) FromWire 

func (v *ThriftTest_TestString_Args) FromWire(w wire.Value) error

FromWire deserializes a ThriftTest_TestString_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 ThriftTest_TestString_Args struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v ThriftTest_TestString_Args
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*ThriftTest_TestString_Args) GetThing 

func (v *ThriftTest_TestString_Args) GetThing() (o string)

GetThing returns the value of Thing if it is set or its zero value if it is unset.

func (*ThriftTest_TestString_Args) IsSetThing 

func (v *ThriftTest_TestString_Args) IsSetThing() bool

IsSetThing returns true if Thing is not nil.

func (*ThriftTest_TestString_Args) MarshalLogObject 

func (v *ThriftTest_TestString_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ThriftTest_TestString_Args.

func (*ThriftTest_TestString_Args) MethodName 

func (v *ThriftTest_TestString_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 "testString" for this struct.

func (*ThriftTest_TestString_Args) String 

func (v *ThriftTest_TestString_Args) String() string

String returns a readable string representation of a ThriftTest_TestString_Args struct.

func (*ThriftTest_TestString_Args) ToWire 

func (v *ThriftTest_TestString_Args) ToWire() (wire.Value, error)

ToWire translates a ThriftTest_TestString_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 ThriftTest_TestString_Result 

type ThriftTest_TestString_Result struct {
	// Value returned by testString after a successful execution.
	Success *string `json:"success,omitempty"`
}

ThriftTest_TestString_Result represents the result of a ThriftTest.testString function call.

The result of a testString execution is sent and received over the wire as this struct.

Success is set only if the function did not throw an exception.

func (*ThriftTest_TestString_Result) Decode 

func (v *ThriftTest_TestString_Result) Decode(sr stream.Reader) error

Decode deserializes a ThriftTest_TestString_Result struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ThriftTest_TestString_Result struct could not be generated from the wire representation.

func (*ThriftTest_TestString_Result) Encode 

func (v *ThriftTest_TestString_Result) Encode(sw stream.Writer) error

Encode serializes a ThriftTest_TestString_Result struct directly into bytes, without going through an intermediary type.

An error is returned if a ThriftTest_TestString_Result struct could not be encoded.

func (*ThriftTest_TestString_Result) EnvelopeType 

func (v *ThriftTest_TestString_Result) EnvelopeType() wire.EnvelopeType

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*ThriftTest_TestString_Result) Equals 

func (v *ThriftTest_TestString_Result) Equals(rhs *ThriftTest_TestString_Result) bool

Equals returns true if all the fields of this ThriftTest_TestString_Result match the provided ThriftTest_TestString_Result.

This function performs a deep comparison.

func (*ThriftTest_TestString_Result) FromWire 

func (v *ThriftTest_TestString_Result) FromWire(w wire.Value) error

FromWire deserializes a ThriftTest_TestString_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 ThriftTest_TestString_Result struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v ThriftTest_TestString_Result
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*ThriftTest_TestString_Result) GetSuccess 

func (v *ThriftTest_TestString_Result) GetSuccess() (o string)

GetSuccess returns the value of Success if it is set or its zero value if it is unset.

func (*ThriftTest_TestString_Result) IsSetSuccess 

func (v *ThriftTest_TestString_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*ThriftTest_TestString_Result) MarshalLogObject 

func (v *ThriftTest_TestString_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ThriftTest_TestString_Result.

func (*ThriftTest_TestString_Result) MethodName 

func (v *ThriftTest_TestString_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 "testString" for this struct.

func (*ThriftTest_TestString_Result) String 

func (v *ThriftTest_TestString_Result) String() string

String returns a readable string representation of a ThriftTest_TestString_Result struct.

func (*ThriftTest_TestString_Result) ToWire 

func (v *ThriftTest_TestString_Result) ToWire() (wire.Value, error)

ToWire translates a ThriftTest_TestString_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 ThriftTest_TestStruct_Args 

type ThriftTest_TestStruct_Args struct {
	Thing *Xtruct `json:"thing,omitempty"`
}

ThriftTest_TestStruct_Args represents the arguments for the ThriftTest.testStruct function.

The arguments for testStruct are sent and received over the wire as this struct.

func (*ThriftTest_TestStruct_Args) Decode 

func (v *ThriftTest_TestStruct_Args) Decode(sr stream.Reader) error

Decode deserializes a ThriftTest_TestStruct_Args struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ThriftTest_TestStruct_Args struct could not be generated from the wire representation.

func (*ThriftTest_TestStruct_Args) Encode 

func (v *ThriftTest_TestStruct_Args) Encode(sw stream.Writer) error

Encode serializes a ThriftTest_TestStruct_Args struct directly into bytes, without going through an intermediary type.

An error is returned if a ThriftTest_TestStruct_Args struct could not be encoded.

func (*ThriftTest_TestStruct_Args) EnvelopeType 

func (v *ThriftTest_TestStruct_Args) EnvelopeType() wire.EnvelopeType

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*ThriftTest_TestStruct_Args) Equals 

func (v *ThriftTest_TestStruct_Args) Equals(rhs *ThriftTest_TestStruct_Args) bool

Equals returns true if all the fields of this ThriftTest_TestStruct_Args match the provided ThriftTest_TestStruct_Args.

This function performs a deep comparison.

func (*ThriftTest_TestStruct_Args) FromWire 

func (v *ThriftTest_TestStruct_Args) FromWire(w wire.Value) error

FromWire deserializes a ThriftTest_TestStruct_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 ThriftTest_TestStruct_Args struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v ThriftTest_TestStruct_Args
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*ThriftTest_TestStruct_Args) GetThing 

func (v *ThriftTest_TestStruct_Args) GetThing() (o *Xtruct)

GetThing returns the value of Thing if it is set or its zero value if it is unset.

func (*ThriftTest_TestStruct_Args) IsSetThing 

func (v *ThriftTest_TestStruct_Args) IsSetThing() bool

IsSetThing returns true if Thing is not nil.

func (*ThriftTest_TestStruct_Args) MarshalLogObject 

func (v *ThriftTest_TestStruct_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ThriftTest_TestStruct_Args.

func (*ThriftTest_TestStruct_Args) MethodName 

func (v *ThriftTest_TestStruct_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 "testStruct" for this struct.

func (*ThriftTest_TestStruct_Args) String 

func (v *ThriftTest_TestStruct_Args) String() string

String returns a readable string representation of a ThriftTest_TestStruct_Args struct.

func (*ThriftTest_TestStruct_Args) ToWire 

func (v *ThriftTest_TestStruct_Args) ToWire() (wire.Value, error)

ToWire translates a ThriftTest_TestStruct_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 ThriftTest_TestStruct_Result 

type ThriftTest_TestStruct_Result struct {
	// Value returned by testStruct after a successful execution.
	Success *Xtruct `json:"success,omitempty"`
}

ThriftTest_TestStruct_Result represents the result of a ThriftTest.testStruct function call.

The result of a testStruct execution is sent and received over the wire as this struct.

Success is set only if the function did not throw an exception.

func (*ThriftTest_TestStruct_Result) Decode 

func (v *ThriftTest_TestStruct_Result) Decode(sr stream.Reader) error

Decode deserializes a ThriftTest_TestStruct_Result struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ThriftTest_TestStruct_Result struct could not be generated from the wire representation.

func (*ThriftTest_TestStruct_Result) Encode 

func (v *ThriftTest_TestStruct_Result) Encode(sw stream.Writer) error

Encode serializes a ThriftTest_TestStruct_Result struct directly into bytes, without going through an intermediary type.

An error is returned if a ThriftTest_TestStruct_Result struct could not be encoded.

func (*ThriftTest_TestStruct_Result) EnvelopeType 

func (v *ThriftTest_TestStruct_Result) EnvelopeType() wire.EnvelopeType

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*ThriftTest_TestStruct_Result) Equals 

func (v *ThriftTest_TestStruct_Result) Equals(rhs *ThriftTest_TestStruct_Result) bool

Equals returns true if all the fields of this ThriftTest_TestStruct_Result match the provided ThriftTest_TestStruct_Result.

This function performs a deep comparison.

func (*ThriftTest_TestStruct_Result) FromWire 

func (v *ThriftTest_TestStruct_Result) FromWire(w wire.Value) error

FromWire deserializes a ThriftTest_TestStruct_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 ThriftTest_TestStruct_Result struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v ThriftTest_TestStruct_Result
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*ThriftTest_TestStruct_Result) GetSuccess 

func (v *ThriftTest_TestStruct_Result) GetSuccess() (o *Xtruct)

GetSuccess returns the value of Success if it is set or its zero value if it is unset.

func (*ThriftTest_TestStruct_Result) IsSetSuccess 

func (v *ThriftTest_TestStruct_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*ThriftTest_TestStruct_Result) MarshalLogObject 

func (v *ThriftTest_TestStruct_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ThriftTest_TestStruct_Result.

func (*ThriftTest_TestStruct_Result) MethodName 

func (v *ThriftTest_TestStruct_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 "testStruct" for this struct.

func (*ThriftTest_TestStruct_Result) String 

func (v *ThriftTest_TestStruct_Result) String() string

String returns a readable string representation of a ThriftTest_TestStruct_Result struct.

func (*ThriftTest_TestStruct_Result) ToWire 

func (v *ThriftTest_TestStruct_Result) ToWire() (wire.Value, error)

ToWire translates a ThriftTest_TestStruct_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 ThriftTest_TestTypedef_Args 

type ThriftTest_TestTypedef_Args struct {
	Thing *UserId `json:"thing,omitempty"`
}

ThriftTest_TestTypedef_Args represents the arguments for the ThriftTest.testTypedef function.

The arguments for testTypedef are sent and received over the wire as this struct.

func (*ThriftTest_TestTypedef_Args) Decode 

func (v *ThriftTest_TestTypedef_Args) Decode(sr stream.Reader) error

Decode deserializes a ThriftTest_TestTypedef_Args struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ThriftTest_TestTypedef_Args struct could not be generated from the wire representation.

func (*ThriftTest_TestTypedef_Args) Encode 

func (v *ThriftTest_TestTypedef_Args) Encode(sw stream.Writer) error

Encode serializes a ThriftTest_TestTypedef_Args struct directly into bytes, without going through an intermediary type.

An error is returned if a ThriftTest_TestTypedef_Args struct could not be encoded.

func (*ThriftTest_TestTypedef_Args) EnvelopeType 

func (v *ThriftTest_TestTypedef_Args) EnvelopeType() wire.EnvelopeType

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*ThriftTest_TestTypedef_Args) Equals 

func (v *ThriftTest_TestTypedef_Args) Equals(rhs *ThriftTest_TestTypedef_Args) bool

Equals returns true if all the fields of this ThriftTest_TestTypedef_Args match the provided ThriftTest_TestTypedef_Args.

This function performs a deep comparison.

func (*ThriftTest_TestTypedef_Args) FromWire 

func (v *ThriftTest_TestTypedef_Args) FromWire(w wire.Value) error

FromWire deserializes a ThriftTest_TestTypedef_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 ThriftTest_TestTypedef_Args struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v ThriftTest_TestTypedef_Args
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*ThriftTest_TestTypedef_Args) GetThing 

func (v *ThriftTest_TestTypedef_Args) GetThing() (o UserId)

GetThing returns the value of Thing if it is set or its zero value if it is unset.

func (*ThriftTest_TestTypedef_Args) IsSetThing 

func (v *ThriftTest_TestTypedef_Args) IsSetThing() bool

IsSetThing returns true if Thing is not nil.

func (*ThriftTest_TestTypedef_Args) MarshalLogObject 

func (v *ThriftTest_TestTypedef_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ThriftTest_TestTypedef_Args.

func (*ThriftTest_TestTypedef_Args) MethodName 

func (v *ThriftTest_TestTypedef_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 "testTypedef" for this struct.

func (*ThriftTest_TestTypedef_Args) String 

func (v *ThriftTest_TestTypedef_Args) String() string

String returns a readable string representation of a ThriftTest_TestTypedef_Args struct.

func (*ThriftTest_TestTypedef_Args) ToWire 

func (v *ThriftTest_TestTypedef_Args) ToWire() (wire.Value, error)

ToWire translates a ThriftTest_TestTypedef_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 ThriftTest_TestTypedef_Result 

type ThriftTest_TestTypedef_Result struct {
	// Value returned by testTypedef after a successful execution.
	Success *UserId `json:"success,omitempty"`
}

ThriftTest_TestTypedef_Result represents the result of a ThriftTest.testTypedef function call.

The result of a testTypedef execution is sent and received over the wire as this struct.

Success is set only if the function did not throw an exception.

func (*ThriftTest_TestTypedef_Result) Decode 

func (v *ThriftTest_TestTypedef_Result) Decode(sr stream.Reader) error

Decode deserializes a ThriftTest_TestTypedef_Result struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ThriftTest_TestTypedef_Result struct could not be generated from the wire representation.

func (*ThriftTest_TestTypedef_Result) Encode 

func (v *ThriftTest_TestTypedef_Result) Encode(sw stream.Writer) error

Encode serializes a ThriftTest_TestTypedef_Result struct directly into bytes, without going through an intermediary type.

An error is returned if a ThriftTest_TestTypedef_Result struct could not be encoded.

func (*ThriftTest_TestTypedef_Result) EnvelopeType 

func (v *ThriftTest_TestTypedef_Result) EnvelopeType() wire.EnvelopeType

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*ThriftTest_TestTypedef_Result) Equals 

func (v *ThriftTest_TestTypedef_Result) Equals(rhs *ThriftTest_TestTypedef_Result) bool

Equals returns true if all the fields of this ThriftTest_TestTypedef_Result match the provided ThriftTest_TestTypedef_Result.

This function performs a deep comparison.

func (*ThriftTest_TestTypedef_Result) FromWire 

func (v *ThriftTest_TestTypedef_Result) FromWire(w wire.Value) error

FromWire deserializes a ThriftTest_TestTypedef_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 ThriftTest_TestTypedef_Result struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v ThriftTest_TestTypedef_Result
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*ThriftTest_TestTypedef_Result) GetSuccess 

func (v *ThriftTest_TestTypedef_Result) GetSuccess() (o UserId)

GetSuccess returns the value of Success if it is set or its zero value if it is unset.

func (*ThriftTest_TestTypedef_Result) IsSetSuccess 

func (v *ThriftTest_TestTypedef_Result) IsSetSuccess() bool

IsSetSuccess returns true if Success is not nil.

func (*ThriftTest_TestTypedef_Result) MarshalLogObject 

func (v *ThriftTest_TestTypedef_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ThriftTest_TestTypedef_Result.

func (*ThriftTest_TestTypedef_Result) MethodName 

func (v *ThriftTest_TestTypedef_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 "testTypedef" for this struct.

func (*ThriftTest_TestTypedef_Result) String 

func (v *ThriftTest_TestTypedef_Result) String() string

String returns a readable string representation of a ThriftTest_TestTypedef_Result struct.

func (*ThriftTest_TestTypedef_Result) ToWire 

func (v *ThriftTest_TestTypedef_Result) ToWire() (wire.Value, error)

ToWire translates a ThriftTest_TestTypedef_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 ThriftTest_TestVoid_Args 

type ThriftTest_TestVoid_Args struct {
}

ThriftTest_TestVoid_Args represents the arguments for the ThriftTest.testVoid function.

The arguments for testVoid are sent and received over the wire as this struct.

func (*ThriftTest_TestVoid_Args) Decode 

func (v *ThriftTest_TestVoid_Args) Decode(sr stream.Reader) error

Decode deserializes a ThriftTest_TestVoid_Args struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ThriftTest_TestVoid_Args struct could not be generated from the wire representation.

func (*ThriftTest_TestVoid_Args) Encode 

func (v *ThriftTest_TestVoid_Args) Encode(sw stream.Writer) error

Encode serializes a ThriftTest_TestVoid_Args struct directly into bytes, without going through an intermediary type.

An error is returned if a ThriftTest_TestVoid_Args struct could not be encoded.

func (*ThriftTest_TestVoid_Args) EnvelopeType 

func (v *ThriftTest_TestVoid_Args) EnvelopeType() wire.EnvelopeType

EnvelopeType returns the kind of value inside this struct.

This will always be Call for this struct.

func (*ThriftTest_TestVoid_Args) Equals 

func (v *ThriftTest_TestVoid_Args) Equals(rhs *ThriftTest_TestVoid_Args) bool

Equals returns true if all the fields of this ThriftTest_TestVoid_Args match the provided ThriftTest_TestVoid_Args.

This function performs a deep comparison.

func (*ThriftTest_TestVoid_Args) FromWire 

func (v *ThriftTest_TestVoid_Args) FromWire(w wire.Value) error

FromWire deserializes a ThriftTest_TestVoid_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 ThriftTest_TestVoid_Args struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v ThriftTest_TestVoid_Args
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*ThriftTest_TestVoid_Args) MarshalLogObject 

func (v *ThriftTest_TestVoid_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ThriftTest_TestVoid_Args.

func (*ThriftTest_TestVoid_Args) MethodName 

func (v *ThriftTest_TestVoid_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 "testVoid" for this struct.

func (*ThriftTest_TestVoid_Args) String 

func (v *ThriftTest_TestVoid_Args) String() string

String returns a readable string representation of a ThriftTest_TestVoid_Args struct.

func (*ThriftTest_TestVoid_Args) ToWire 

func (v *ThriftTest_TestVoid_Args) ToWire() (wire.Value, error)

ToWire translates a ThriftTest_TestVoid_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 ThriftTest_TestVoid_Result 

type ThriftTest_TestVoid_Result struct {
}

ThriftTest_TestVoid_Result represents the result of a ThriftTest.testVoid function call.

The result of a testVoid execution is sent and received over the wire as this struct.

func (*ThriftTest_TestVoid_Result) Decode 

func (v *ThriftTest_TestVoid_Result) Decode(sr stream.Reader) error

Decode deserializes a ThriftTest_TestVoid_Result struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a ThriftTest_TestVoid_Result struct could not be generated from the wire representation.

func (*ThriftTest_TestVoid_Result) Encode 

func (v *ThriftTest_TestVoid_Result) Encode(sw stream.Writer) error

Encode serializes a ThriftTest_TestVoid_Result struct directly into bytes, without going through an intermediary type.

An error is returned if a ThriftTest_TestVoid_Result struct could not be encoded.

func (*ThriftTest_TestVoid_Result) EnvelopeType 

func (v *ThriftTest_TestVoid_Result) EnvelopeType() wire.EnvelopeType

EnvelopeType returns the kind of value inside this struct.

This will always be Reply for this struct.

func (*ThriftTest_TestVoid_Result) Equals 

func (v *ThriftTest_TestVoid_Result) Equals(rhs *ThriftTest_TestVoid_Result) bool

Equals returns true if all the fields of this ThriftTest_TestVoid_Result match the provided ThriftTest_TestVoid_Result.

This function performs a deep comparison.

func (*ThriftTest_TestVoid_Result) FromWire 

func (v *ThriftTest_TestVoid_Result) FromWire(w wire.Value) error

FromWire deserializes a ThriftTest_TestVoid_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 ThriftTest_TestVoid_Result struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v ThriftTest_TestVoid_Result
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*ThriftTest_TestVoid_Result) MarshalLogObject 

func (v *ThriftTest_TestVoid_Result) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of ThriftTest_TestVoid_Result.

func (*ThriftTest_TestVoid_Result) MethodName 

func (v *ThriftTest_TestVoid_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 "testVoid" for this struct.

func (*ThriftTest_TestVoid_Result) String 

func (v *ThriftTest_TestVoid_Result) String() string

String returns a readable string representation of a ThriftTest_TestVoid_Result struct.

func (*ThriftTest_TestVoid_Result) ToWire 

func (v *ThriftTest_TestVoid_Result) ToWire() (wire.Value, error)

ToWire translates a ThriftTest_TestVoid_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 UserId 

type UserId int64

func (*UserId) Decode 

func (v *UserId) Decode(sr stream.Reader) error

Decode deserializes UserId directly off the wire.

func (UserId) Encode 

func (v UserId) Encode(sw stream.Writer) error

func (UserId) Equals 

func (lhs UserId) Equals(rhs UserId) bool

Equals returns true if this UserId is equal to the provided UserId.

func (*UserId) FromWire 

func (v *UserId) FromWire(w wire.Value) error

FromWire deserializes UserId from its Thrift-level representation. The Thrift-level representation may be obtained from a ThriftRW protocol implementation.

func (UserId) Ptr 

func (v UserId) Ptr() *UserId

UserIdPtr returns a pointer to a UserId

func (UserId) String 

func (v UserId) String() string

String returns a readable string representation of UserId.

func (UserId) ToWire 

func (v UserId) ToWire() (wire.Value, error)

ToWire translates UserId into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

type VersioningTestV1 

type VersioningTestV1 struct {
	BeginInBoth *int32  `json:"begin_in_both,omitempty"`
	OldString   *string `json:"old_string,omitempty"`
	EndInBoth   *int32  `json:"end_in_both,omitempty"`
}

func (*VersioningTestV1) Decode 

func (v *VersioningTestV1) Decode(sr stream.Reader) error

Decode deserializes a VersioningTestV1 struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a VersioningTestV1 struct could not be generated from the wire representation.

func (*VersioningTestV1) Encode 

func (v *VersioningTestV1) Encode(sw stream.Writer) error

Encode serializes a VersioningTestV1 struct directly into bytes, without going through an intermediary type.

An error is returned if a VersioningTestV1 struct could not be encoded.

func (*VersioningTestV1) Equals 

func (v *VersioningTestV1) Equals(rhs *VersioningTestV1) bool

Equals returns true if all the fields of this VersioningTestV1 match the provided VersioningTestV1.

This function performs a deep comparison.

func (*VersioningTestV1) FromWire 

func (v *VersioningTestV1) FromWire(w wire.Value) error

FromWire deserializes a VersioningTestV1 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 VersioningTestV1 struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v VersioningTestV1
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*VersioningTestV1) GetBeginInBoth 

func (v *VersioningTestV1) GetBeginInBoth() (o int32)

GetBeginInBoth returns the value of BeginInBoth if it is set or its zero value if it is unset.

func (*VersioningTestV1) GetEndInBoth 

func (v *VersioningTestV1) GetEndInBoth() (o int32)

GetEndInBoth returns the value of EndInBoth if it is set or its zero value if it is unset.

func (*VersioningTestV1) GetOldString 

func (v *VersioningTestV1) GetOldString() (o string)

GetOldString returns the value of OldString if it is set or its zero value if it is unset.

func (*VersioningTestV1) IsSetBeginInBoth 

func (v *VersioningTestV1) IsSetBeginInBoth() bool

IsSetBeginInBoth returns true if BeginInBoth is not nil.

func (*VersioningTestV1) IsSetEndInBoth 

func (v *VersioningTestV1) IsSetEndInBoth() bool

IsSetEndInBoth returns true if EndInBoth is not nil.

func (*VersioningTestV1) IsSetOldString 

func (v *VersioningTestV1) IsSetOldString() bool

IsSetOldString returns true if OldString is not nil.

func (*VersioningTestV1) MarshalLogObject 

func (v *VersioningTestV1) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of VersioningTestV1.

func (*VersioningTestV1) String 

func (v *VersioningTestV1) String() string

String returns a readable string representation of a VersioningTestV1 struct.

func (*VersioningTestV1) ToWire 

func (v *VersioningTestV1) ToWire() (wire.Value, error)

ToWire translates a VersioningTestV1 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 VersioningTestV2 

type VersioningTestV2 struct {
	BeginInBoth *int32             `json:"begin_in_both,omitempty"`
	Newint      *int32             `json:"newint,omitempty"`
	Newbyte     *int8              `json:"newbyte,omitempty"`
	Newshort    *int16             `json:"newshort,omitempty"`
	Newlong     *int64             `json:"newlong,omitempty"`
	Newdouble   *float64           `json:"newdouble,omitempty"`
	Newstruct   *Bonk              `json:"newstruct,omitempty"`
	Newlist     []int32            `json:"newlist,omitempty"`
	Newset      map[int32]struct{} `json:"newset,omitempty"`
	Newmap      map[int32]int32    `json:"newmap,omitempty"`
	Newstring   *string            `json:"newstring,omitempty"`
	EndInBoth   *int32             `json:"end_in_both,omitempty"`
}

func (*VersioningTestV2) Decode 

func (v *VersioningTestV2) Decode(sr stream.Reader) error

Decode deserializes a VersioningTestV2 struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a VersioningTestV2 struct could not be generated from the wire representation.

func (*VersioningTestV2) Encode 

func (v *VersioningTestV2) Encode(sw stream.Writer) error

Encode serializes a VersioningTestV2 struct directly into bytes, without going through an intermediary type.

An error is returned if a VersioningTestV2 struct could not be encoded.

func (*VersioningTestV2) Equals 

func (v *VersioningTestV2) Equals(rhs *VersioningTestV2) bool

Equals returns true if all the fields of this VersioningTestV2 match the provided VersioningTestV2.

This function performs a deep comparison.

func (*VersioningTestV2) FromWire 

func (v *VersioningTestV2) FromWire(w wire.Value) error

FromWire deserializes a VersioningTestV2 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 VersioningTestV2 struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v VersioningTestV2
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*VersioningTestV2) GetBeginInBoth 

func (v *VersioningTestV2) GetBeginInBoth() (o int32)

GetBeginInBoth returns the value of BeginInBoth if it is set or its zero value if it is unset.

func (*VersioningTestV2) GetEndInBoth 

func (v *VersioningTestV2) GetEndInBoth() (o int32)

GetEndInBoth returns the value of EndInBoth if it is set or its zero value if it is unset.

func (*VersioningTestV2) GetNewbyte 

func (v *VersioningTestV2) GetNewbyte() (o int8)

GetNewbyte returns the value of Newbyte if it is set or its zero value if it is unset.

func (*VersioningTestV2) GetNewdouble 

func (v *VersioningTestV2) GetNewdouble() (o float64)

GetNewdouble returns the value of Newdouble if it is set or its zero value if it is unset.

func (*VersioningTestV2) GetNewint 

func (v *VersioningTestV2) GetNewint() (o int32)

GetNewint returns the value of Newint if it is set or its zero value if it is unset.

func (*VersioningTestV2) GetNewlist 

func (v *VersioningTestV2) GetNewlist() (o []int32)

GetNewlist returns the value of Newlist if it is set or its zero value if it is unset.

func (*VersioningTestV2) GetNewlong 

func (v *VersioningTestV2) GetNewlong() (o int64)

GetNewlong returns the value of Newlong if it is set or its zero value if it is unset.

func (*VersioningTestV2) GetNewmap 

func (v *VersioningTestV2) GetNewmap() (o map[int32]int32)

GetNewmap returns the value of Newmap if it is set or its zero value if it is unset.

func (*VersioningTestV2) GetNewset 

func (v *VersioningTestV2) GetNewset() (o map[int32]struct{})

GetNewset returns the value of Newset if it is set or its zero value if it is unset.

func (*VersioningTestV2) GetNewshort 

func (v *VersioningTestV2) GetNewshort() (o int16)

GetNewshort returns the value of Newshort if it is set or its zero value if it is unset.

func (*VersioningTestV2) GetNewstring 

func (v *VersioningTestV2) GetNewstring() (o string)

GetNewstring returns the value of Newstring if it is set or its zero value if it is unset.

func (*VersioningTestV2) GetNewstruct 

func (v *VersioningTestV2) GetNewstruct() (o *Bonk)

GetNewstruct returns the value of Newstruct if it is set or its zero value if it is unset.

func (*VersioningTestV2) IsSetBeginInBoth 

func (v *VersioningTestV2) IsSetBeginInBoth() bool

IsSetBeginInBoth returns true if BeginInBoth is not nil.

func (*VersioningTestV2) IsSetEndInBoth 

func (v *VersioningTestV2) IsSetEndInBoth() bool

IsSetEndInBoth returns true if EndInBoth is not nil.

func (*VersioningTestV2) IsSetNewbyte 

func (v *VersioningTestV2) IsSetNewbyte() bool

IsSetNewbyte returns true if Newbyte is not nil.

func (*VersioningTestV2) IsSetNewdouble 

func (v *VersioningTestV2) IsSetNewdouble() bool

IsSetNewdouble returns true if Newdouble is not nil.

func (*VersioningTestV2) IsSetNewint 

func (v *VersioningTestV2) IsSetNewint() bool

IsSetNewint returns true if Newint is not nil.

func (*VersioningTestV2) IsSetNewlist 

func (v *VersioningTestV2) IsSetNewlist() bool

IsSetNewlist returns true if Newlist is not nil.

func (*VersioningTestV2) IsSetNewlong 

func (v *VersioningTestV2) IsSetNewlong() bool

IsSetNewlong returns true if Newlong is not nil.

func (*VersioningTestV2) IsSetNewmap 

func (v *VersioningTestV2) IsSetNewmap() bool

IsSetNewmap returns true if Newmap is not nil.

func (*VersioningTestV2) IsSetNewset 

func (v *VersioningTestV2) IsSetNewset() bool

IsSetNewset returns true if Newset is not nil.

func (*VersioningTestV2) IsSetNewshort 

func (v *VersioningTestV2) IsSetNewshort() bool

IsSetNewshort returns true if Newshort is not nil.

func (*VersioningTestV2) IsSetNewstring 

func (v *VersioningTestV2) IsSetNewstring() bool

IsSetNewstring returns true if Newstring is not nil.

func (*VersioningTestV2) IsSetNewstruct 

func (v *VersioningTestV2) IsSetNewstruct() bool

IsSetNewstruct returns true if Newstruct is not nil.

func (*VersioningTestV2) MarshalLogObject 

func (v *VersioningTestV2) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of VersioningTestV2.

func (*VersioningTestV2) String 

func (v *VersioningTestV2) String() string

String returns a readable string representation of a VersioningTestV2 struct.

func (*VersioningTestV2) ToWire 

func (v *VersioningTestV2) ToWire() (wire.Value, error)

ToWire translates a VersioningTestV2 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 Xception 

type Xception struct {
	ErrorCode *int32  `json:"errorCode,omitempty"`
	Message   *string `json:"message,omitempty"`
}

func (*Xception) Decode 

func (v *Xception) Decode(sr stream.Reader) error

Decode deserializes a Xception struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a Xception struct could not be generated from the wire representation.

func (*Xception) Encode 

func (v *Xception) Encode(sw stream.Writer) error

Encode serializes a Xception struct directly into bytes, without going through an intermediary type.

An error is returned if a Xception struct could not be encoded.

func (*Xception) Equals 

func (v *Xception) Equals(rhs *Xception) bool

Equals returns true if all the fields of this Xception match the provided Xception.

This function performs a deep comparison.

func (*Xception) Error 

func (v *Xception) Error() string

func (*Xception) ErrorName 

func (*Xception) ErrorName() string

ErrorName is the name of this type as defined in the Thrift file.

func (*Xception) FromWire 

func (v *Xception) FromWire(w wire.Value) error

FromWire deserializes a Xception 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 Xception struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v Xception
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*Xception) GetErrorCode 

func (v *Xception) GetErrorCode() (o int32)

GetErrorCode returns the value of ErrorCode if it is set or its zero value if it is unset.

func (*Xception) GetMessage 

func (v *Xception) GetMessage() (o string)

GetMessage returns the value of Message if it is set or its zero value if it is unset.

func (*Xception) IsSetErrorCode 

func (v *Xception) IsSetErrorCode() bool

IsSetErrorCode returns true if ErrorCode is not nil.

func (*Xception) IsSetMessage 

func (v *Xception) IsSetMessage() bool

IsSetMessage returns true if Message is not nil.

func (*Xception) MarshalLogObject 

func (v *Xception) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of Xception.

func (*Xception) String 

func (v *Xception) String() string

String returns a readable string representation of a Xception struct.

func (*Xception) ToWire 

func (v *Xception) ToWire() (wire.Value, error)

ToWire translates a Xception 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
}

func (*Xception) YARPCErrorCode 

func (e *Xception) YARPCErrorCode() *yarpcerrors.Code

YARPCErrorCode returns nil for Xception.

This is derived from the rpc.code annotation on the Thrift exception.

func (*Xception) YARPCErrorName 

func (e *Xception) YARPCErrorName() string

Name is the error name for Xception.

type Xception2 

type Xception2 struct {
	ErrorCode   *int32  `json:"errorCode,omitempty"`
	StructThing *Xtruct `json:"struct_thing,omitempty"`
}

func (*Xception2) Decode 

func (v *Xception2) Decode(sr stream.Reader) error

Decode deserializes a Xception2 struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a Xception2 struct could not be generated from the wire representation.

func (*Xception2) Encode 

func (v *Xception2) Encode(sw stream.Writer) error

Encode serializes a Xception2 struct directly into bytes, without going through an intermediary type.

An error is returned if a Xception2 struct could not be encoded.

func (*Xception2) Equals 

func (v *Xception2) Equals(rhs *Xception2) bool

Equals returns true if all the fields of this Xception2 match the provided Xception2.

This function performs a deep comparison.

func (*Xception2) Error 

func (v *Xception2) Error() string

func (*Xception2) ErrorName 

func (*Xception2) ErrorName() string

ErrorName is the name of this type as defined in the Thrift file.

func (*Xception2) FromWire 

func (v *Xception2) FromWire(w wire.Value) error

FromWire deserializes a Xception2 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 Xception2 struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v Xception2
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*Xception2) GetErrorCode 

func (v *Xception2) GetErrorCode() (o int32)

GetErrorCode returns the value of ErrorCode if it is set or its zero value if it is unset.

func (*Xception2) GetStructThing 

func (v *Xception2) GetStructThing() (o *Xtruct)

GetStructThing returns the value of StructThing if it is set or its zero value if it is unset.

func (*Xception2) IsSetErrorCode 

func (v *Xception2) IsSetErrorCode() bool

IsSetErrorCode returns true if ErrorCode is not nil.

func (*Xception2) IsSetStructThing 

func (v *Xception2) IsSetStructThing() bool

IsSetStructThing returns true if StructThing is not nil.

func (*Xception2) MarshalLogObject 

func (v *Xception2) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of Xception2.

func (*Xception2) String 

func (v *Xception2) String() string

String returns a readable string representation of a Xception2 struct.

func (*Xception2) ToWire 

func (v *Xception2) ToWire() (wire.Value, error)

ToWire translates a Xception2 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
}

func (*Xception2) YARPCErrorCode 

func (e *Xception2) YARPCErrorCode() *yarpcerrors.Code

YARPCErrorCode returns nil for Xception2.

This is derived from the rpc.code annotation on the Thrift exception.

func (*Xception2) YARPCErrorName 

func (e *Xception2) YARPCErrorName() string

Name is the error name for Xception2.

type Xtruct 

type Xtruct struct {
	StringThing *string `json:"string_thing,omitempty"`
	ByteThing   *int8   `json:"byte_thing,omitempty"`
	I32Thing    *int32  `json:"i32_thing,omitempty"`
	I64Thing    *int64  `json:"i64_thing,omitempty"`
}

func (*Xtruct) Decode 

func (v *Xtruct) Decode(sr stream.Reader) error

Decode deserializes a Xtruct struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a Xtruct struct could not be generated from the wire representation.

func (*Xtruct) Encode 

func (v *Xtruct) Encode(sw stream.Writer) error

Encode serializes a Xtruct struct directly into bytes, without going through an intermediary type.

An error is returned if a Xtruct struct could not be encoded.

func (*Xtruct) Equals 

func (v *Xtruct) Equals(rhs *Xtruct) bool

Equals returns true if all the fields of this Xtruct match the provided Xtruct.

This function performs a deep comparison.

func (*Xtruct) FromWire 

func (v *Xtruct) FromWire(w wire.Value) error

FromWire deserializes a Xtruct 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 Xtruct struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v Xtruct
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*Xtruct) GetByteThing 

func (v *Xtruct) GetByteThing() (o int8)

GetByteThing returns the value of ByteThing if it is set or its zero value if it is unset.

func (*Xtruct) GetI32Thing 

func (v *Xtruct) GetI32Thing() (o int32)

GetI32Thing returns the value of I32Thing if it is set or its zero value if it is unset.

func (*Xtruct) GetI64Thing 

func (v *Xtruct) GetI64Thing() (o int64)

GetI64Thing returns the value of I64Thing if it is set or its zero value if it is unset.

func (*Xtruct) GetStringThing 

func (v *Xtruct) GetStringThing() (o string)

GetStringThing returns the value of StringThing if it is set or its zero value if it is unset.

func (*Xtruct) IsSetByteThing 

func (v *Xtruct) IsSetByteThing() bool

IsSetByteThing returns true if ByteThing is not nil.

func (*Xtruct) IsSetI32Thing 

func (v *Xtruct) IsSetI32Thing() bool

IsSetI32Thing returns true if I32Thing is not nil.

func (*Xtruct) IsSetI64Thing 

func (v *Xtruct) IsSetI64Thing() bool

IsSetI64Thing returns true if I64Thing is not nil.

func (*Xtruct) IsSetStringThing 

func (v *Xtruct) IsSetStringThing() bool

IsSetStringThing returns true if StringThing is not nil.

func (*Xtruct) MarshalLogObject 

func (v *Xtruct) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of Xtruct.

func (*Xtruct) String 

func (v *Xtruct) String() string

String returns a readable string representation of a Xtruct struct.

func (*Xtruct) ToWire 

func (v *Xtruct) ToWire() (wire.Value, error)

ToWire translates a Xtruct 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 Xtruct2 

type Xtruct2 struct {
	ByteThing   *int8   `json:"byte_thing,omitempty"`
	StructThing *Xtruct `json:"struct_thing,omitempty"`
	I32Thing    *int32  `json:"i32_thing,omitempty"`
}

func (*Xtruct2) Decode 

func (v *Xtruct2) Decode(sr stream.Reader) error

Decode deserializes a Xtruct2 struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a Xtruct2 struct could not be generated from the wire representation.

func (*Xtruct2) Encode 

func (v *Xtruct2) Encode(sw stream.Writer) error

Encode serializes a Xtruct2 struct directly into bytes, without going through an intermediary type.

An error is returned if a Xtruct2 struct could not be encoded.

func (*Xtruct2) Equals 

func (v *Xtruct2) Equals(rhs *Xtruct2) bool

Equals returns true if all the fields of this Xtruct2 match the provided Xtruct2.

This function performs a deep comparison.

func (*Xtruct2) FromWire 

func (v *Xtruct2) FromWire(w wire.Value) error

FromWire deserializes a Xtruct2 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 Xtruct2 struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v Xtruct2
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*Xtruct2) GetByteThing 

func (v *Xtruct2) GetByteThing() (o int8)

GetByteThing returns the value of ByteThing if it is set or its zero value if it is unset.

func (*Xtruct2) GetI32Thing 

func (v *Xtruct2) GetI32Thing() (o int32)

GetI32Thing returns the value of I32Thing if it is set or its zero value if it is unset.

func (*Xtruct2) GetStructThing 

func (v *Xtruct2) GetStructThing() (o *Xtruct)

GetStructThing returns the value of StructThing if it is set or its zero value if it is unset.

func (*Xtruct2) IsSetByteThing 

func (v *Xtruct2) IsSetByteThing() bool

IsSetByteThing returns true if ByteThing is not nil.

func (*Xtruct2) IsSetI32Thing 

func (v *Xtruct2) IsSetI32Thing() bool

IsSetI32Thing returns true if I32Thing is not nil.

func (*Xtruct2) IsSetStructThing 

func (v *Xtruct2) IsSetStructThing() bool

IsSetStructThing returns true if StructThing is not nil.

func (*Xtruct2) MarshalLogObject 

func (v *Xtruct2) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of Xtruct2.

func (*Xtruct2) String 

func (v *Xtruct2) String() string

String returns a readable string representation of a Xtruct2 struct.

func (*Xtruct2) ToWire 

func (v *Xtruct2) ToWire() (wire.Value, error)

ToWire translates a Xtruct2 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 Xtruct3 

type Xtruct3 struct {
	StringThing *string `json:"string_thing,omitempty"`
	Changed     *int32  `json:"changed,omitempty"`
	I32Thing    *int32  `json:"i32_thing,omitempty"`
	I64Thing    *int64  `json:"i64_thing,omitempty"`
}

func (*Xtruct3) Decode 

func (v *Xtruct3) Decode(sr stream.Reader) error

Decode deserializes a Xtruct3 struct directly from its Thrift-level representation, without going through an intemediary type.

An error is returned if a Xtruct3 struct could not be generated from the wire representation.

func (*Xtruct3) Encode 

func (v *Xtruct3) Encode(sw stream.Writer) error

Encode serializes a Xtruct3 struct directly into bytes, without going through an intermediary type.

An error is returned if a Xtruct3 struct could not be encoded.

func (*Xtruct3) Equals 

func (v *Xtruct3) Equals(rhs *Xtruct3) bool

Equals returns true if all the fields of this Xtruct3 match the provided Xtruct3.

This function performs a deep comparison.

func (*Xtruct3) FromWire 

func (v *Xtruct3) FromWire(w wire.Value) error

FromWire deserializes a Xtruct3 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 Xtruct3 struct from the provided intermediate representation. 

x, err := binaryProtocol.Decode(reader, wire.TStruct)
if err != nil {
	return nil, err
}

var v Xtruct3
if err := v.FromWire(x); err != nil {
	return nil, err
}
return &v, nil

func (*Xtruct3) GetChanged 

func (v *Xtruct3) GetChanged() (o int32)

GetChanged returns the value of Changed if it is set or its zero value if it is unset.

func (*Xtruct3) GetI32Thing 

func (v *Xtruct3) GetI32Thing() (o int32)

GetI32Thing returns the value of I32Thing if it is set or its zero value if it is unset.

func (*Xtruct3) GetI64Thing 

func (v *Xtruct3) GetI64Thing() (o int64)

GetI64Thing returns the value of I64Thing if it is set or its zero value if it is unset.

func (*Xtruct3) GetStringThing 

func (v *Xtruct3) GetStringThing() (o string)

GetStringThing returns the value of StringThing if it is set or its zero value if it is unset.

func (*Xtruct3) IsSetChanged 

func (v *Xtruct3) IsSetChanged() bool

IsSetChanged returns true if Changed is not nil.

func (*Xtruct3) IsSetI32Thing 

func (v *Xtruct3) IsSetI32Thing() bool

IsSetI32Thing returns true if I32Thing is not nil.

func (*Xtruct3) IsSetI64Thing 

func (v *Xtruct3) IsSetI64Thing() bool

IsSetI64Thing returns true if I64Thing is not nil.

func (*Xtruct3) IsSetStringThing 

func (v *Xtruct3) IsSetStringThing() bool

IsSetStringThing returns true if StringThing is not nil.

func (*Xtruct3) MarshalLogObject 

func (v *Xtruct3) MarshalLogObject(enc zapcore.ObjectEncoder) (err error)

MarshalLogObject implements zapcore.ObjectMarshaler, enabling fast logging of Xtruct3.

func (*Xtruct3) String 

func (v *Xtruct3) String() string

String returns a readable string representation of a Xtruct3 struct.

func (*Xtruct3) ToWire 

func (v *Xtruct3) ToWire() (wire.Value, error)

ToWire translates a Xtruct3 struct into a Thrift-level intermediate representation. This intermediate representation may be serialized into bytes using a ThriftRW protocol implementation.

An error is returned if the struct or any of its fields failed to validate. 

x, err := v.ToWire()
if err != nil {
	return err
}

if err := binaryProtocol.Encode(x, writer); err != nil {
	return err
}

Source Files

View all Source files

Directories

Path Synopsis
Package secondservicefx provides better integration for Fx for services implementing or calling SecondService.
 Package secondservicefx provides better integration for Fx for services implementing or calling SecondService.
Package thrifttestfx provides better integration for Fx for services implementing or calling ThriftTest.
 Package thrifttestfx provides better integration for Fx for services implementing or calling ThriftTest.

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.