Documentation

Index

Constants

This section is empty.

Variables

View Source
var ThriftModule = &thriftreflect.ThriftModule{
	Name:     "containers",
	Package:  "go.uber.org/thriftrw/gen/internal/tests/containers",
	FilePath: "containers.thrift",
	SHA1:     "b4682204a85cf94d3742f09ef77d1a386b6c2ee7",
	Includes: []*thriftreflect.ThriftModule{
		enum_conflict.ThriftModule,
		enums.ThriftModule,
		typedefs.ThriftModule,
		uuid_conflict.ThriftModule,
	},
	Raw: rawIDL,
}

    ThriftModule represents the IDL file used to generate this package.

    Functions

    This section is empty.

    Types

    type ContainersOfContainers

    type ContainersOfContainers struct {
    	ListOfLists   [][]int32             `json:"listOfLists,omitempty"`
    	ListOfSets    []map[int32]struct{}  `json:"listOfSets,omitempty"`
    	ListOfMaps    []map[int32]int32     `json:"listOfMaps,omitempty"`
    	SetOfSets     []map[string]struct{} `json:"setOfSets,omitempty"`
    	SetOfLists    [][]string            `json:"setOfLists,omitempty"`
    	SetOfMaps     []map[string]string   `json:"setOfMaps,omitempty"`
    	MapOfMapToInt []struct {
    		Key   map[string]int32
    		Value int64
    	} `json:"mapOfMapToInt,omitempty"`
    	MapOfListToSet []struct {
    		Key   []int32
    		Value map[int64]struct{}
    	} `json:"mapOfListToSet,omitempty"`
    	MapOfSetToListOfDouble []struct {
    		Key   map[int32]struct{}
    		Value []float64
    	} `json:"mapOfSetToListOfDouble,omitempty"`
    }

    func (*ContainersOfContainers) Equals

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

      This function performs a deep comparison.

      func (*ContainersOfContainers) FromWire

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

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

        An error is returned if we were unable to build a ContainersOfContainers struct from the provided intermediate representation.

        x, err := binaryProtocol.Decode(reader, wire.TStruct)
        if err != nil {
          return nil, err
        }
        
        var v ContainersOfContainers
        if err := v.FromWire(x); err != nil {
          return nil, err
        }
        return &v, nil
        

        func (*ContainersOfContainers) GetListOfLists

        func (v *ContainersOfContainers) GetListOfLists() (o [][]int32)

          GetListOfLists returns the value of ListOfLists if it is set or its zero value if it is unset.

          func (*ContainersOfContainers) GetListOfMaps

          func (v *ContainersOfContainers) GetListOfMaps() (o []map[int32]int32)

            GetListOfMaps returns the value of ListOfMaps if it is set or its zero value if it is unset.

            func (*ContainersOfContainers) GetListOfSets

            func (v *ContainersOfContainers) GetListOfSets() (o []map[int32]struct{})

              GetListOfSets returns the value of ListOfSets if it is set or its zero value if it is unset.

              func (*ContainersOfContainers) GetMapOfListToSet

              func (v *ContainersOfContainers) GetMapOfListToSet() (o []struct {
              	Key   []int32
              	Value map[int64]struct{}
              })

                GetMapOfListToSet returns the value of MapOfListToSet if it is set or its zero value if it is unset.

                func (*ContainersOfContainers) GetMapOfMapToInt

                func (v *ContainersOfContainers) GetMapOfMapToInt() (o []struct {
                	Key   map[string]int32
                	Value int64
                })

                  GetMapOfMapToInt returns the value of MapOfMapToInt if it is set or its zero value if it is unset.

                  func (*ContainersOfContainers) GetMapOfSetToListOfDouble

                  func (v *ContainersOfContainers) GetMapOfSetToListOfDouble() (o []struct {
                  	Key   map[int32]struct{}
                  	Value []float64
                  })

                    GetMapOfSetToListOfDouble returns the value of MapOfSetToListOfDouble if it is set or its zero value if it is unset.

                    func (*ContainersOfContainers) GetSetOfLists

                    func (v *ContainersOfContainers) GetSetOfLists() (o [][]string)

                      GetSetOfLists returns the value of SetOfLists if it is set or its zero value if it is unset.

                      func (*ContainersOfContainers) GetSetOfMaps

                      func (v *ContainersOfContainers) GetSetOfMaps() (o []map[string]string)

                        GetSetOfMaps returns the value of SetOfMaps if it is set or its zero value if it is unset.

                        func (*ContainersOfContainers) GetSetOfSets

                        func (v *ContainersOfContainers) GetSetOfSets() (o []map[string]struct{})

                          GetSetOfSets returns the value of SetOfSets if it is set or its zero value if it is unset.

                          func (*ContainersOfContainers) IsSetListOfLists

                          func (v *ContainersOfContainers) IsSetListOfLists() bool

                            IsSetListOfLists returns true if ListOfLists is not nil.

                            func (*ContainersOfContainers) IsSetListOfMaps

                            func (v *ContainersOfContainers) IsSetListOfMaps() bool

                              IsSetListOfMaps returns true if ListOfMaps is not nil.

                              func (*ContainersOfContainers) IsSetListOfSets

                              func (v *ContainersOfContainers) IsSetListOfSets() bool

                                IsSetListOfSets returns true if ListOfSets is not nil.

                                func (*ContainersOfContainers) IsSetMapOfListToSet

                                func (v *ContainersOfContainers) IsSetMapOfListToSet() bool

                                  IsSetMapOfListToSet returns true if MapOfListToSet is not nil.

                                  func (*ContainersOfContainers) IsSetMapOfMapToInt

                                  func (v *ContainersOfContainers) IsSetMapOfMapToInt() bool

                                    IsSetMapOfMapToInt returns true if MapOfMapToInt is not nil.

                                    func (*ContainersOfContainers) IsSetMapOfSetToListOfDouble

                                    func (v *ContainersOfContainers) IsSetMapOfSetToListOfDouble() bool

                                      IsSetMapOfSetToListOfDouble returns true if MapOfSetToListOfDouble is not nil.

                                      func (*ContainersOfContainers) IsSetSetOfLists

                                      func (v *ContainersOfContainers) IsSetSetOfLists() bool

                                        IsSetSetOfLists returns true if SetOfLists is not nil.

                                        func (*ContainersOfContainers) IsSetSetOfMaps

                                        func (v *ContainersOfContainers) IsSetSetOfMaps() bool

                                          IsSetSetOfMaps returns true if SetOfMaps is not nil.

                                          func (*ContainersOfContainers) IsSetSetOfSets

                                          func (v *ContainersOfContainers) IsSetSetOfSets() bool

                                            IsSetSetOfSets returns true if SetOfSets is not nil.

                                            func (*ContainersOfContainers) MarshalLogObject

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

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

                                              func (*ContainersOfContainers) String

                                              func (v *ContainersOfContainers) String() string

                                                String returns a readable string representation of a ContainersOfContainers struct.

                                                func (*ContainersOfContainers) ToWire

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

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

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

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

                                                  type EnumContainers

                                                  type EnumContainers struct {
                                                  	ListOfEnums []enums.EnumDefault                     `json:"listOfEnums,omitempty"`
                                                  	SetOfEnums  map[enums.EnumWithValues]struct{}       `json:"setOfEnums,omitempty"`
                                                  	MapOfEnums  map[enums.EnumWithDuplicateValues]int32 `json:"mapOfEnums,omitempty"`
                                                  }

                                                  func (*EnumContainers) Equals

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

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

                                                    This function performs a deep comparison.

                                                    func (*EnumContainers) FromWire

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

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

                                                      An error is returned if we were unable to build a EnumContainers struct from the provided intermediate representation.

                                                      x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                      if err != nil {
                                                        return nil, err
                                                      }
                                                      
                                                      var v EnumContainers
                                                      if err := v.FromWire(x); err != nil {
                                                        return nil, err
                                                      }
                                                      return &v, nil
                                                      

                                                      func (*EnumContainers) GetListOfEnums

                                                      func (v *EnumContainers) GetListOfEnums() (o []enums.EnumDefault)

                                                        GetListOfEnums returns the value of ListOfEnums if it is set or its zero value if it is unset.

                                                        func (*EnumContainers) GetMapOfEnums

                                                        func (v *EnumContainers) GetMapOfEnums() (o map[enums.EnumWithDuplicateValues]int32)

                                                          GetMapOfEnums returns the value of MapOfEnums if it is set or its zero value if it is unset.

                                                          func (*EnumContainers) GetSetOfEnums

                                                          func (v *EnumContainers) GetSetOfEnums() (o map[enums.EnumWithValues]struct{})

                                                            GetSetOfEnums returns the value of SetOfEnums if it is set or its zero value if it is unset.

                                                            func (*EnumContainers) IsSetListOfEnums

                                                            func (v *EnumContainers) IsSetListOfEnums() bool

                                                              IsSetListOfEnums returns true if ListOfEnums is not nil.

                                                              func (*EnumContainers) IsSetMapOfEnums

                                                              func (v *EnumContainers) IsSetMapOfEnums() bool

                                                                IsSetMapOfEnums returns true if MapOfEnums is not nil.

                                                                func (*EnumContainers) IsSetSetOfEnums

                                                                func (v *EnumContainers) IsSetSetOfEnums() bool

                                                                  IsSetSetOfEnums returns true if SetOfEnums is not nil.

                                                                  func (*EnumContainers) MarshalLogObject

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

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

                                                                    func (*EnumContainers) String

                                                                    func (v *EnumContainers) String() string

                                                                      String returns a readable string representation of a EnumContainers struct.

                                                                      func (*EnumContainers) ToWire

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

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

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

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

                                                                        type ListOfConflictingEnums

                                                                        type ListOfConflictingEnums struct {
                                                                        	Records      []enum_conflict.RecordType `json:"records,required"`
                                                                        	OtherRecords []enums.RecordType         `json:"otherRecords,required"`
                                                                        }

                                                                        func (*ListOfConflictingEnums) Equals

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

                                                                          This function performs a deep comparison.

                                                                          func (*ListOfConflictingEnums) FromWire

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

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

                                                                            An error is returned if we were unable to build a ListOfConflictingEnums struct from the provided intermediate representation.

                                                                            x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                            if err != nil {
                                                                              return nil, err
                                                                            }
                                                                            
                                                                            var v ListOfConflictingEnums
                                                                            if err := v.FromWire(x); err != nil {
                                                                              return nil, err
                                                                            }
                                                                            return &v, nil
                                                                            

                                                                            func (*ListOfConflictingEnums) GetOtherRecords

                                                                            func (v *ListOfConflictingEnums) GetOtherRecords() (o []enums.RecordType)

                                                                              GetOtherRecords returns the value of OtherRecords if it is set or its zero value if it is unset.

                                                                              func (*ListOfConflictingEnums) GetRecords

                                                                              func (v *ListOfConflictingEnums) GetRecords() (o []enum_conflict.RecordType)

                                                                                GetRecords returns the value of Records if it is set or its zero value if it is unset.

                                                                                func (*ListOfConflictingEnums) IsSetOtherRecords

                                                                                func (v *ListOfConflictingEnums) IsSetOtherRecords() bool

                                                                                  IsSetOtherRecords returns true if OtherRecords is not nil.

                                                                                  func (*ListOfConflictingEnums) IsSetRecords

                                                                                  func (v *ListOfConflictingEnums) IsSetRecords() bool

                                                                                    IsSetRecords returns true if Records is not nil.

                                                                                    func (*ListOfConflictingEnums) MarshalLogObject

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

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

                                                                                      func (*ListOfConflictingEnums) String

                                                                                      func (v *ListOfConflictingEnums) String() string

                                                                                        String returns a readable string representation of a ListOfConflictingEnums struct.

                                                                                        func (*ListOfConflictingEnums) ToWire

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

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

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

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

                                                                                          type ListOfConflictingUUIDs

                                                                                          type ListOfConflictingUUIDs struct {
                                                                                          	Uuids      []*typedefs.UUID     `json:"uuids,required"`
                                                                                          	OtherUUIDs []uuid_conflict.UUID `json:"otherUUIDs,required"`
                                                                                          }

                                                                                          func (*ListOfConflictingUUIDs) Equals

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

                                                                                            This function performs a deep comparison.

                                                                                            func (*ListOfConflictingUUIDs) FromWire

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

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

                                                                                              An error is returned if we were unable to build a ListOfConflictingUUIDs struct from the provided intermediate representation.

                                                                                              x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                              if err != nil {
                                                                                                return nil, err
                                                                                              }
                                                                                              
                                                                                              var v ListOfConflictingUUIDs
                                                                                              if err := v.FromWire(x); err != nil {
                                                                                                return nil, err
                                                                                              }
                                                                                              return &v, nil
                                                                                              

                                                                                              func (*ListOfConflictingUUIDs) GetOtherUUIDs

                                                                                              func (v *ListOfConflictingUUIDs) GetOtherUUIDs() (o []uuid_conflict.UUID)

                                                                                                GetOtherUUIDs returns the value of OtherUUIDs if it is set or its zero value if it is unset.

                                                                                                func (*ListOfConflictingUUIDs) GetUuids

                                                                                                func (v *ListOfConflictingUUIDs) GetUuids() (o []*typedefs.UUID)

                                                                                                  GetUuids returns the value of Uuids if it is set or its zero value if it is unset.

                                                                                                  func (*ListOfConflictingUUIDs) IsSetOtherUUIDs

                                                                                                  func (v *ListOfConflictingUUIDs) IsSetOtherUUIDs() bool

                                                                                                    IsSetOtherUUIDs returns true if OtherUUIDs is not nil.

                                                                                                    func (*ListOfConflictingUUIDs) IsSetUuids

                                                                                                    func (v *ListOfConflictingUUIDs) IsSetUuids() bool

                                                                                                      IsSetUuids returns true if Uuids is not nil.

                                                                                                      func (*ListOfConflictingUUIDs) MarshalLogObject

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

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

                                                                                                        func (*ListOfConflictingUUIDs) String

                                                                                                        func (v *ListOfConflictingUUIDs) String() string

                                                                                                          String returns a readable string representation of a ListOfConflictingUUIDs struct.

                                                                                                          func (*ListOfConflictingUUIDs) ToWire

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

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

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

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

                                                                                                            type ListOfOptionalPrimitives

                                                                                                            type ListOfOptionalPrimitives struct {
                                                                                                            	ListOfStrings []string `json:"listOfStrings,omitempty"`
                                                                                                            }

                                                                                                            func (*ListOfOptionalPrimitives) Equals

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

                                                                                                              This function performs a deep comparison.

                                                                                                              func (*ListOfOptionalPrimitives) FromWire

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

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

                                                                                                                An error is returned if we were unable to build a ListOfOptionalPrimitives struct from the provided intermediate representation.

                                                                                                                x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                                                if err != nil {
                                                                                                                  return nil, err
                                                                                                                }
                                                                                                                
                                                                                                                var v ListOfOptionalPrimitives
                                                                                                                if err := v.FromWire(x); err != nil {
                                                                                                                  return nil, err
                                                                                                                }
                                                                                                                return &v, nil
                                                                                                                

                                                                                                                func (*ListOfOptionalPrimitives) GetListOfStrings

                                                                                                                func (v *ListOfOptionalPrimitives) GetListOfStrings() (o []string)

                                                                                                                  GetListOfStrings returns the value of ListOfStrings if it is set or its zero value if it is unset.

                                                                                                                  func (*ListOfOptionalPrimitives) IsSetListOfStrings

                                                                                                                  func (v *ListOfOptionalPrimitives) IsSetListOfStrings() bool

                                                                                                                    IsSetListOfStrings returns true if ListOfStrings is not nil.

                                                                                                                    func (*ListOfOptionalPrimitives) MarshalLogObject

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

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

                                                                                                                      func (*ListOfOptionalPrimitives) String

                                                                                                                      func (v *ListOfOptionalPrimitives) String() string

                                                                                                                        String returns a readable string representation of a ListOfOptionalPrimitives struct.

                                                                                                                        func (*ListOfOptionalPrimitives) ToWire

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

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

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

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

                                                                                                                          type ListOfRequiredPrimitives

                                                                                                                          type ListOfRequiredPrimitives struct {
                                                                                                                          	ListOfStrings []string `json:"listOfStrings,required"`
                                                                                                                          }

                                                                                                                          func (*ListOfRequiredPrimitives) Equals

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

                                                                                                                            This function performs a deep comparison.

                                                                                                                            func (*ListOfRequiredPrimitives) FromWire

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

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

                                                                                                                              An error is returned if we were unable to build a ListOfRequiredPrimitives struct from the provided intermediate representation.

                                                                                                                              x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                                                              if err != nil {
                                                                                                                                return nil, err
                                                                                                                              }
                                                                                                                              
                                                                                                                              var v ListOfRequiredPrimitives
                                                                                                                              if err := v.FromWire(x); err != nil {
                                                                                                                                return nil, err
                                                                                                                              }
                                                                                                                              return &v, nil
                                                                                                                              

                                                                                                                              func (*ListOfRequiredPrimitives) GetListOfStrings

                                                                                                                              func (v *ListOfRequiredPrimitives) GetListOfStrings() (o []string)

                                                                                                                                GetListOfStrings returns the value of ListOfStrings if it is set or its zero value if it is unset.

                                                                                                                                func (*ListOfRequiredPrimitives) IsSetListOfStrings

                                                                                                                                func (v *ListOfRequiredPrimitives) IsSetListOfStrings() bool

                                                                                                                                  IsSetListOfStrings returns true if ListOfStrings is not nil.

                                                                                                                                  func (*ListOfRequiredPrimitives) MarshalLogObject

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

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

                                                                                                                                    func (*ListOfRequiredPrimitives) String

                                                                                                                                    func (v *ListOfRequiredPrimitives) String() string

                                                                                                                                      String returns a readable string representation of a ListOfRequiredPrimitives struct.

                                                                                                                                      func (*ListOfRequiredPrimitives) ToWire

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

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

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

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

                                                                                                                                        type MapOfBinaryAndString

                                                                                                                                        type MapOfBinaryAndString struct {
                                                                                                                                        	BinaryToString []struct {
                                                                                                                                        		Key   []byte
                                                                                                                                        		Value string
                                                                                                                                        	} `json:"binaryToString,omitempty"`
                                                                                                                                        	StringToBinary map[string][]byte `json:"stringToBinary,omitempty"`
                                                                                                                                        }

                                                                                                                                        func (*MapOfBinaryAndString) Equals

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

                                                                                                                                          This function performs a deep comparison.

                                                                                                                                          func (*MapOfBinaryAndString) FromWire

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

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

                                                                                                                                            An error is returned if we were unable to build a MapOfBinaryAndString struct from the provided intermediate representation.

                                                                                                                                            x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                                                                            if err != nil {
                                                                                                                                              return nil, err
                                                                                                                                            }
                                                                                                                                            
                                                                                                                                            var v MapOfBinaryAndString
                                                                                                                                            if err := v.FromWire(x); err != nil {
                                                                                                                                              return nil, err
                                                                                                                                            }
                                                                                                                                            return &v, nil
                                                                                                                                            

                                                                                                                                            func (*MapOfBinaryAndString) GetBinaryToString

                                                                                                                                            func (v *MapOfBinaryAndString) GetBinaryToString() (o []struct {
                                                                                                                                            	Key   []byte
                                                                                                                                            	Value string
                                                                                                                                            })

                                                                                                                                              GetBinaryToString returns the value of BinaryToString if it is set or its zero value if it is unset.

                                                                                                                                              func (*MapOfBinaryAndString) GetStringToBinary

                                                                                                                                              func (v *MapOfBinaryAndString) GetStringToBinary() (o map[string][]byte)

                                                                                                                                                GetStringToBinary returns the value of StringToBinary if it is set or its zero value if it is unset.

                                                                                                                                                func (*MapOfBinaryAndString) IsSetBinaryToString

                                                                                                                                                func (v *MapOfBinaryAndString) IsSetBinaryToString() bool

                                                                                                                                                  IsSetBinaryToString returns true if BinaryToString is not nil.

                                                                                                                                                  func (*MapOfBinaryAndString) IsSetStringToBinary

                                                                                                                                                  func (v *MapOfBinaryAndString) IsSetStringToBinary() bool

                                                                                                                                                    IsSetStringToBinary returns true if StringToBinary is not nil.

                                                                                                                                                    func (*MapOfBinaryAndString) MarshalLogObject

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

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

                                                                                                                                                      func (*MapOfBinaryAndString) String

                                                                                                                                                      func (v *MapOfBinaryAndString) String() string

                                                                                                                                                        String returns a readable string representation of a MapOfBinaryAndString struct.

                                                                                                                                                        func (*MapOfBinaryAndString) ToWire

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

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

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

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

                                                                                                                                                          type PrimitiveContainers

                                                                                                                                                          type PrimitiveContainers struct {
                                                                                                                                                          	ListOfBinary      [][]byte            `json:"listOfBinary,omitempty"`
                                                                                                                                                          	ListOfInts        []int64             `json:"listOfInts,omitempty"`
                                                                                                                                                          	SetOfStrings      map[string]struct{} `json:"setOfStrings,omitempty"`
                                                                                                                                                          	SetOfBytes        map[int8]struct{}   `json:"setOfBytes,omitempty"`
                                                                                                                                                          	MapOfIntToString  map[int32]string    `json:"mapOfIntToString,omitempty"`
                                                                                                                                                          	MapOfStringToBool map[string]bool     `json:"mapOfStringToBool,omitempty"`
                                                                                                                                                          }

                                                                                                                                                          func (*PrimitiveContainers) Equals

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

                                                                                                                                                            This function performs a deep comparison.

                                                                                                                                                            func (*PrimitiveContainers) FromWire

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

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

                                                                                                                                                              An error is returned if we were unable to build a PrimitiveContainers struct from the provided intermediate representation.

                                                                                                                                                              x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                                                                                              if err != nil {
                                                                                                                                                                return nil, err
                                                                                                                                                              }
                                                                                                                                                              
                                                                                                                                                              var v PrimitiveContainers
                                                                                                                                                              if err := v.FromWire(x); err != nil {
                                                                                                                                                                return nil, err
                                                                                                                                                              }
                                                                                                                                                              return &v, nil
                                                                                                                                                              

                                                                                                                                                              func (*PrimitiveContainers) GetListOfBinary

                                                                                                                                                              func (v *PrimitiveContainers) GetListOfBinary() (o [][]byte)

                                                                                                                                                                GetListOfBinary returns the value of ListOfBinary if it is set or its zero value if it is unset.

                                                                                                                                                                func (*PrimitiveContainers) GetListOfInts

                                                                                                                                                                func (v *PrimitiveContainers) GetListOfInts() (o []int64)

                                                                                                                                                                  GetListOfInts returns the value of ListOfInts if it is set or its zero value if it is unset.

                                                                                                                                                                  func (*PrimitiveContainers) GetMapOfIntToString

                                                                                                                                                                  func (v *PrimitiveContainers) GetMapOfIntToString() (o map[int32]string)

                                                                                                                                                                    GetMapOfIntToString returns the value of MapOfIntToString if it is set or its zero value if it is unset.

                                                                                                                                                                    func (*PrimitiveContainers) GetMapOfStringToBool

                                                                                                                                                                    func (v *PrimitiveContainers) GetMapOfStringToBool() (o map[string]bool)

                                                                                                                                                                      GetMapOfStringToBool returns the value of MapOfStringToBool if it is set or its zero value if it is unset.

                                                                                                                                                                      func (*PrimitiveContainers) GetSetOfBytes

                                                                                                                                                                      func (v *PrimitiveContainers) GetSetOfBytes() (o map[int8]struct{})

                                                                                                                                                                        GetSetOfBytes returns the value of SetOfBytes if it is set or its zero value if it is unset.

                                                                                                                                                                        func (*PrimitiveContainers) GetSetOfStrings

                                                                                                                                                                        func (v *PrimitiveContainers) GetSetOfStrings() (o map[string]struct{})

                                                                                                                                                                          GetSetOfStrings returns the value of SetOfStrings if it is set or its zero value if it is unset.

                                                                                                                                                                          func (*PrimitiveContainers) IsSetListOfBinary

                                                                                                                                                                          func (v *PrimitiveContainers) IsSetListOfBinary() bool

                                                                                                                                                                            IsSetListOfBinary returns true if ListOfBinary is not nil.

                                                                                                                                                                            func (*PrimitiveContainers) IsSetListOfInts

                                                                                                                                                                            func (v *PrimitiveContainers) IsSetListOfInts() bool

                                                                                                                                                                              IsSetListOfInts returns true if ListOfInts is not nil.

                                                                                                                                                                              func (*PrimitiveContainers) IsSetMapOfIntToString

                                                                                                                                                                              func (v *PrimitiveContainers) IsSetMapOfIntToString() bool

                                                                                                                                                                                IsSetMapOfIntToString returns true if MapOfIntToString is not nil.

                                                                                                                                                                                func (*PrimitiveContainers) IsSetMapOfStringToBool

                                                                                                                                                                                func (v *PrimitiveContainers) IsSetMapOfStringToBool() bool

                                                                                                                                                                                  IsSetMapOfStringToBool returns true if MapOfStringToBool is not nil.

                                                                                                                                                                                  func (*PrimitiveContainers) IsSetSetOfBytes

                                                                                                                                                                                  func (v *PrimitiveContainers) IsSetSetOfBytes() bool

                                                                                                                                                                                    IsSetSetOfBytes returns true if SetOfBytes is not nil.

                                                                                                                                                                                    func (*PrimitiveContainers) IsSetSetOfStrings

                                                                                                                                                                                    func (v *PrimitiveContainers) IsSetSetOfStrings() bool

                                                                                                                                                                                      IsSetSetOfStrings returns true if SetOfStrings is not nil.

                                                                                                                                                                                      func (*PrimitiveContainers) MarshalLogObject

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

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

                                                                                                                                                                                        func (*PrimitiveContainers) String

                                                                                                                                                                                        func (v *PrimitiveContainers) String() string

                                                                                                                                                                                          String returns a readable string representation of a PrimitiveContainers struct.

                                                                                                                                                                                          func (*PrimitiveContainers) ToWire

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

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

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

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

                                                                                                                                                                                            type PrimitiveContainersRequired

                                                                                                                                                                                            type PrimitiveContainersRequired struct {
                                                                                                                                                                                            	ListOfStrings      []string           `json:"listOfStrings,required"`
                                                                                                                                                                                            	SetOfInts          map[int32]struct{} `json:"setOfInts,required"`
                                                                                                                                                                                            	MapOfIntsToDoubles map[int64]float64  `json:"mapOfIntsToDoubles,required"`
                                                                                                                                                                                            }

                                                                                                                                                                                            func (*PrimitiveContainersRequired) Equals

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

                                                                                                                                                                                              This function performs a deep comparison.

                                                                                                                                                                                              func (*PrimitiveContainersRequired) FromWire

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

                                                                                                                                                                                                An error is returned if we were unable to build a PrimitiveContainersRequired struct from the provided intermediate representation.

                                                                                                                                                                                                x, err := binaryProtocol.Decode(reader, wire.TStruct)
                                                                                                                                                                                                if err != nil {
                                                                                                                                                                                                  return nil, err
                                                                                                                                                                                                }
                                                                                                                                                                                                
                                                                                                                                                                                                var v PrimitiveContainersRequired
                                                                                                                                                                                                if err := v.FromWire(x); err != nil {
                                                                                                                                                                                                  return nil, err
                                                                                                                                                                                                }
                                                                                                                                                                                                return &v, nil
                                                                                                                                                                                                

                                                                                                                                                                                                func (*PrimitiveContainersRequired) GetListOfStrings

                                                                                                                                                                                                func (v *PrimitiveContainersRequired) GetListOfStrings() (o []string)

                                                                                                                                                                                                  GetListOfStrings returns the value of ListOfStrings if it is set or its zero value if it is unset.

                                                                                                                                                                                                  func (*PrimitiveContainersRequired) GetMapOfIntsToDoubles

                                                                                                                                                                                                  func (v *PrimitiveContainersRequired) GetMapOfIntsToDoubles() (o map[int64]float64)

                                                                                                                                                                                                    GetMapOfIntsToDoubles returns the value of MapOfIntsToDoubles if it is set or its zero value if it is unset.

                                                                                                                                                                                                    func (*PrimitiveContainersRequired) GetSetOfInts

                                                                                                                                                                                                    func (v *PrimitiveContainersRequired) GetSetOfInts() (o map[int32]struct{})

                                                                                                                                                                                                      GetSetOfInts returns the value of SetOfInts if it is set or its zero value if it is unset.

                                                                                                                                                                                                      func (*PrimitiveContainersRequired) IsSetListOfStrings

                                                                                                                                                                                                      func (v *PrimitiveContainersRequired) IsSetListOfStrings() bool

                                                                                                                                                                                                        IsSetListOfStrings returns true if ListOfStrings is not nil.

                                                                                                                                                                                                        func (*PrimitiveContainersRequired) IsSetMapOfIntsToDoubles

                                                                                                                                                                                                        func (v *PrimitiveContainersRequired) IsSetMapOfIntsToDoubles() bool

                                                                                                                                                                                                          IsSetMapOfIntsToDoubles returns true if MapOfIntsToDoubles is not nil.

                                                                                                                                                                                                          func (*PrimitiveContainersRequired) IsSetSetOfInts

                                                                                                                                                                                                          func (v *PrimitiveContainersRequired) IsSetSetOfInts() bool

                                                                                                                                                                                                            IsSetSetOfInts returns true if SetOfInts is not nil.

                                                                                                                                                                                                            func (*PrimitiveContainersRequired) MarshalLogObject

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

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

                                                                                                                                                                                                              func (*PrimitiveContainersRequired) String

                                                                                                                                                                                                              func (v *PrimitiveContainersRequired) String() string

                                                                                                                                                                                                                String returns a readable string representation of a PrimitiveContainersRequired struct.

                                                                                                                                                                                                                func (*PrimitiveContainersRequired) ToWire

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

                                                                                                                                                                                                                  An error is returned if the struct or any of 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