gauntlet

package
v1.16.0 Latest Latest
Warning

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

 Go to latest Published: Sep 18, 2017 License: MIT Imports: 11 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

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

	// IsException returns true if the given error can be thrown
	// by blahBlah.
	//
	// An error can be thrown by blahBlah only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

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

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

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

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

	// IsException returns true if the given error can be thrown
	// by secondtestString.
	//
	// An error can be thrown by secondtestString only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

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

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

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

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

ThriftModule represents the IDL file used to generate this package.

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

	// IsException returns true if the given error can be thrown
	// by testBinary.
	//
	// An error can be thrown by testBinary only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

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

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

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

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

	// IsException returns true if the given error can be thrown
	// by testByte.
	//
	// An error can be thrown by testByte only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

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

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

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

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

	// IsException returns true if the given error can be thrown
	// by testDouble.
	//
	// An error can be thrown by testDouble only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

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

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

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

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

	// IsException returns true if the given error can be thrown
	// by testEnum.
	//
	// An error can be thrown by testEnum only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

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

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

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

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

	// IsException returns true if the given error can be thrown
	// by testException.
	//
	// An error can be thrown by testException only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

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

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

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

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

	// IsException returns true if the given error can be thrown
	// by testI32.
	//
	// An error can be thrown by testI32 only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

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

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

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

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

	// IsException returns true if the given error can be thrown
	// by testI64.
	//
	// An error can be thrown by testI64 only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

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

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

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

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

	// IsException returns true if the given error can be thrown
	// by testInsanity.
	//
	// An error can be thrown by testInsanity only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

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

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

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

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

	// IsException returns true if the given error can be thrown
	// by testList.
	//
	// An error can be thrown by testList only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

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

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

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

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

	// IsException returns true if the given error can be thrown
	// by testMapMap.
	//
	// An error can be thrown by testMapMap only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

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

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

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

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

	// IsException returns true if the given error can be thrown
	// by testMap.
	//
	// An error can be thrown by testMap only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

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

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

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

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

	// IsException returns true if the given error can be thrown
	// by testMultiException.
	//
	// An error can be thrown by testMultiException only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

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

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

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

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

	// IsException returns true if the given error can be thrown
	// by testMulti.
	//
	// An error can be thrown by testMulti only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

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

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

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

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

	// IsException returns true if the given error can be thrown
	// by testNest.
	//
	// An error can be thrown by testNest only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

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

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

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

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

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

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

	// IsException returns true if the given error can be thrown
	// by testSet.
	//
	// An error can be thrown by testSet only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

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

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

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

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

	// IsException returns true if the given error can be thrown
	// by testStringMap.
	//
	// An error can be thrown by testStringMap only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

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

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

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

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

	// IsException returns true if the given error can be thrown
	// by testString.
	//
	// An error can be thrown by testString only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

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

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

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

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

	// IsException returns true if the given error can be thrown
	// by testStruct.
	//
	// An error can be thrown by testStruct only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

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

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

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

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

	// IsException returns true if the given error can be thrown
	// by testTypedef.
	//
	// An error can be thrown by testTypedef only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

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

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

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

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

	// IsException returns true if the given error can be thrown
	// by testVoid.
	//
	// An error can be thrown by testVoid only if the
	// corresponding exception type was mentioned in the 'throws'
	// section for it in the Thrift file.
	IsException func(error) bool

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

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

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

Functions

This section is empty.

Types

type Bonk 

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

func (*Bonk) Equals added in v1.8.0 

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 added in v1.14.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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

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

func (*BoolTest) GetS added in v1.14.0 

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

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

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 added in v1.8.0 

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 added in v1.14.0 

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 added in v1.14.0 

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) 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"`
	ListField   [][]struct {
		Key   map[int32]struct{}
		Value map[int32][][][]struct {
			Key   *Insanity
			Value string
		}
	} `json:"list_field,required"`
	BinaryField []byte `json:"binary_field"`
}

func (*CrazyNesting) Equals added in v1.8.0 

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) GetStringField added in v1.14.0 

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) 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 added in v1.8.0 

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

func (*GuessProtocolStruct) Equals added in v1.8.0 

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) 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"`
	Xtructs []*Xtruct          `json:"xtructs"`
}

func (*Insanity) Equals added in v1.8.0 

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) 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"`
	Vertwo3000 *VersioningTestV2   `json:"vertwo3000,omitempty"`
	BigNumbers []int32             `json:"big_numbers"`
}

func (*LargeDeltas) Equals added in v1.8.0 

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) GetCheckFalse added in v1.14.0 

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 added in v1.14.0 

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

func (*ListBonks) Equals added in v1.8.0 

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) 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"`
	Hello  *string `json:"hello,omitempty"`
}

func (*ListTypeVersioningV1) Equals added in v1.8.0 

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 added in v1.14.0 

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) 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"`
	Hello   *string  `json:"hello,omitempty"`
}

func (*ListTypeVersioningV2) Equals added in v1.8.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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

func (*NestedListsBonk) Equals added in v1.8.0 

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

func (*NestedListsI32x2) Equals added in v1.8.0 

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

func (*NestedListsI32x3) Equals added in v1.8.0 

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) 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"`
	MapIntStrset     map[int32]map[string]struct{}   `json:"map_int_strset"`
	MapIntStrsetList []map[int32]map[string]struct{} `json:"map_int_strset_list"`
}

func (*NestedMixedx2) Equals added in v1.8.0 

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) 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 added in v1.10.0 

func Numberz_Values() []Numberz

Numberz_Values returns all recognized values of Numberz.

func (Numberz) Equals added in v1.8.0 

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) 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 added in v1.10.0 

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 added in v1.8.0 

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) 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 added in v1.8.0 

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) 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 added in v1.8.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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) 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 added in v1.8.0 

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

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 added in v1.8.0 

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

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 added in v1.8.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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

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 added in v1.8.0 

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

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 added in v1.8.0 

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

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 added in v1.8.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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

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 added in v1.8.0 

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

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 added in v1.8.0 

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

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 added in v1.8.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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) 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"`
	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 added in v1.8.0 

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 added in v1.14.0 

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 added in v1.14.0 

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 added in v1.14.0 

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) GetArg4 added in v1.14.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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) 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 added in v1.8.0 

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) 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 added in v1.8.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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

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 added in v1.8.0 

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

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 added in v1.8.0 

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

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 added in v1.8.0 

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

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 added in v1.8.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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) 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 added in v1.8.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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) 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 added in v1.8.0 

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) 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 added in v1.8.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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 added in v1.14.0 

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 added in v1.14.0 

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) 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"`
	Newset      map[int32]struct{} `json:"newset"`
	Newmap      map[int32]int32    `json:"newmap"`
	Newstring   *string            `json:"newstring,omitempty"`
	EndInBoth   *int32             `json:"end_in_both,omitempty"`
}

func (*VersioningTestV2) Equals added in v1.8.0 

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 added in v1.14.0 

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 added in v1.14.0 

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 added in v1.14.0 

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 added in v1.14.0 

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 added in v1.14.0 

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) GetNewlong added in v1.14.0 

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) GetNewshort added in v1.14.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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 added in v1.14.0 

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 added in v1.14.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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 added in v1.14.0 

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) 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 added in v1.8.0 

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 added in v1.14.0 

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 added in v1.14.0 

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 added in v1.14.0 

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 added in v1.14.0 

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

func (v *Xtruct3) String() string

String returns a readable string representation of a Xtruct3 struct.

func (*Xtruct3) ToWire 

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

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

An error is returned if the struct or any of its fields failed to validate. 

x, err := v.ToWire()
if err != nil {
  return err
}

if err := binaryProtocol.Encode(x, writer); err != nil {
  return err
}

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

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