Back to godoc.org

Package gauntlet

v1.42.1
Latest Go to latest
Published: Dec 2, 2019 | License: MIT | Module: go.uber.org/yarpc

Index

Package Files

Variables

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

type Bonk

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

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 (*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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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) 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
}

type Xception2

type Xception2 struct {
	ErrorCode   *int32  `json:"errorCode,omitempty"`
	StructThing *Xtruct `json:"struct_thing,omitempty"`
}

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

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

Jump to identifier

Keyboard shortcuts

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