thriftrw: go.uber.org/thriftrw/gen/internal/tests/containers Index | Files

package containers

import "go.uber.org/thriftrw/gen/internal/tests/containers"

Index

Package Files

containers.go

Variables

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.

type ContainersOfContainers Uses

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 Uses

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

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

This function performs a deep comparison.

func (*ContainersOfContainers) FromWire Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v *ContainersOfContainers) IsSetListOfLists() bool

IsSetListOfLists returns true if ListOfLists is not nil.

func (*ContainersOfContainers) IsSetListOfMaps Uses

func (v *ContainersOfContainers) IsSetListOfMaps() bool

IsSetListOfMaps returns true if ListOfMaps is not nil.

func (*ContainersOfContainers) IsSetListOfSets Uses

func (v *ContainersOfContainers) IsSetListOfSets() bool

IsSetListOfSets returns true if ListOfSets is not nil.

func (*ContainersOfContainers) IsSetMapOfListToSet Uses

func (v *ContainersOfContainers) IsSetMapOfListToSet() bool

IsSetMapOfListToSet returns true if MapOfListToSet is not nil.

func (*ContainersOfContainers) IsSetMapOfMapToInt Uses

func (v *ContainersOfContainers) IsSetMapOfMapToInt() bool

IsSetMapOfMapToInt returns true if MapOfMapToInt is not nil.

func (*ContainersOfContainers) IsSetMapOfSetToListOfDouble Uses

func (v *ContainersOfContainers) IsSetMapOfSetToListOfDouble() bool

IsSetMapOfSetToListOfDouble returns true if MapOfSetToListOfDouble is not nil.

func (*ContainersOfContainers) IsSetSetOfLists Uses

func (v *ContainersOfContainers) IsSetSetOfLists() bool

IsSetSetOfLists returns true if SetOfLists is not nil.

func (*ContainersOfContainers) IsSetSetOfMaps Uses

func (v *ContainersOfContainers) IsSetSetOfMaps() bool

IsSetSetOfMaps returns true if SetOfMaps is not nil.

func (*ContainersOfContainers) IsSetSetOfSets Uses

func (v *ContainersOfContainers) IsSetSetOfSets() bool

IsSetSetOfSets returns true if SetOfSets is not nil.

func (*ContainersOfContainers) MarshalLogObject Uses

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

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

func (*ContainersOfContainers) String Uses

func (v *ContainersOfContainers) String() string

String returns a readable string representation of a ContainersOfContainers struct.

func (*ContainersOfContainers) ToWire Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v *EnumContainers) IsSetListOfEnums() bool

IsSetListOfEnums returns true if ListOfEnums is not nil.

func (*EnumContainers) IsSetMapOfEnums Uses

func (v *EnumContainers) IsSetMapOfEnums() bool

IsSetMapOfEnums returns true if MapOfEnums is not nil.

func (*EnumContainers) IsSetSetOfEnums Uses

func (v *EnumContainers) IsSetSetOfEnums() bool

IsSetSetOfEnums returns true if SetOfEnums is not nil.

func (*EnumContainers) MarshalLogObject Uses

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

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

func (*EnumContainers) String Uses

func (v *EnumContainers) String() string

String returns a readable string representation of a EnumContainers struct.

func (*EnumContainers) ToWire Uses

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 Uses

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

func (*ListOfConflictingEnums) Equals Uses

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

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

This function performs a deep comparison.

func (*ListOfConflictingEnums) FromWire Uses

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 Uses

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 Uses

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 Uses

func (v *ListOfConflictingEnums) IsSetOtherRecords() bool

IsSetOtherRecords returns true if OtherRecords is not nil.

func (*ListOfConflictingEnums) IsSetRecords Uses

func (v *ListOfConflictingEnums) IsSetRecords() bool

IsSetRecords returns true if Records is not nil.

func (*ListOfConflictingEnums) MarshalLogObject Uses

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

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

func (*ListOfConflictingEnums) String Uses

func (v *ListOfConflictingEnums) String() string

String returns a readable string representation of a ListOfConflictingEnums struct.

func (*ListOfConflictingEnums) ToWire Uses

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 Uses

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

func (*ListOfConflictingUUIDs) Equals Uses

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

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

This function performs a deep comparison.

func (*ListOfConflictingUUIDs) FromWire Uses

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 Uses

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 Uses

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 Uses

func (v *ListOfConflictingUUIDs) IsSetOtherUUIDs() bool

IsSetOtherUUIDs returns true if OtherUUIDs is not nil.

func (*ListOfConflictingUUIDs) IsSetUuids Uses

func (v *ListOfConflictingUUIDs) IsSetUuids() bool

IsSetUuids returns true if Uuids is not nil.

func (*ListOfConflictingUUIDs) MarshalLogObject Uses

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

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

func (*ListOfConflictingUUIDs) String Uses

func (v *ListOfConflictingUUIDs) String() string

String returns a readable string representation of a ListOfConflictingUUIDs struct.

func (*ListOfConflictingUUIDs) ToWire Uses

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 Uses

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

func (*ListOfOptionalPrimitives) Equals Uses

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

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

This function performs a deep comparison.

func (*ListOfOptionalPrimitives) FromWire Uses

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 Uses

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 Uses

func (v *ListOfOptionalPrimitives) IsSetListOfStrings() bool

IsSetListOfStrings returns true if ListOfStrings is not nil.

func (*ListOfOptionalPrimitives) MarshalLogObject Uses

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

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

func (*ListOfOptionalPrimitives) String Uses

func (v *ListOfOptionalPrimitives) String() string

String returns a readable string representation of a ListOfOptionalPrimitives struct.

func (*ListOfOptionalPrimitives) ToWire Uses

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 Uses

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

func (*ListOfRequiredPrimitives) Equals Uses

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

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

This function performs a deep comparison.

func (*ListOfRequiredPrimitives) FromWire Uses

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 Uses

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 Uses

func (v *ListOfRequiredPrimitives) IsSetListOfStrings() bool

IsSetListOfStrings returns true if ListOfStrings is not nil.

func (*ListOfRequiredPrimitives) MarshalLogObject Uses

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

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

func (*ListOfRequiredPrimitives) String Uses

func (v *ListOfRequiredPrimitives) String() string

String returns a readable string representation of a ListOfRequiredPrimitives struct.

func (*ListOfRequiredPrimitives) ToWire Uses

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 Uses

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

func (*MapOfBinaryAndString) Equals Uses

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

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

This function performs a deep comparison.

func (*MapOfBinaryAndString) FromWire Uses

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 Uses

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 Uses

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 Uses

func (v *MapOfBinaryAndString) IsSetBinaryToString() bool

IsSetBinaryToString returns true if BinaryToString is not nil.

func (*MapOfBinaryAndString) IsSetStringToBinary Uses

func (v *MapOfBinaryAndString) IsSetStringToBinary() bool

IsSetStringToBinary returns true if StringToBinary is not nil.

func (*MapOfBinaryAndString) MarshalLogObject Uses

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

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

func (*MapOfBinaryAndString) String Uses

func (v *MapOfBinaryAndString) String() string

String returns a readable string representation of a MapOfBinaryAndString struct.

func (*MapOfBinaryAndString) ToWire Uses

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 Uses

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 Uses

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

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

This function performs a deep comparison.

func (*PrimitiveContainers) FromWire Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

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 Uses

func (v *PrimitiveContainers) IsSetListOfBinary() bool

IsSetListOfBinary returns true if ListOfBinary is not nil.

func (*PrimitiveContainers) IsSetListOfInts Uses

func (v *PrimitiveContainers) IsSetListOfInts() bool

IsSetListOfInts returns true if ListOfInts is not nil.

func (*PrimitiveContainers) IsSetMapOfIntToString Uses

func (v *PrimitiveContainers) IsSetMapOfIntToString() bool

IsSetMapOfIntToString returns true if MapOfIntToString is not nil.

func (*PrimitiveContainers) IsSetMapOfStringToBool Uses

func (v *PrimitiveContainers) IsSetMapOfStringToBool() bool

IsSetMapOfStringToBool returns true if MapOfStringToBool is not nil.

func (*PrimitiveContainers) IsSetSetOfBytes Uses

func (v *PrimitiveContainers) IsSetSetOfBytes() bool

IsSetSetOfBytes returns true if SetOfBytes is not nil.

func (*PrimitiveContainers) IsSetSetOfStrings Uses

func (v *PrimitiveContainers) IsSetSetOfStrings() bool

IsSetSetOfStrings returns true if SetOfStrings is not nil.

func (*PrimitiveContainers) MarshalLogObject Uses

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

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

func (*PrimitiveContainers) String Uses

func (v *PrimitiveContainers) String() string

String returns a readable string representation of a PrimitiveContainers struct.

func (*PrimitiveContainers) ToWire Uses

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 Uses

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 Uses

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

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

This function performs a deep comparison.

func (*PrimitiveContainersRequired) FromWire Uses

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

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 Uses

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 Uses

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 Uses

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 Uses

func (v *PrimitiveContainersRequired) IsSetListOfStrings() bool

IsSetListOfStrings returns true if ListOfStrings is not nil.

func (*PrimitiveContainersRequired) IsSetMapOfIntsToDoubles Uses

func (v *PrimitiveContainersRequired) IsSetMapOfIntsToDoubles() bool

IsSetMapOfIntsToDoubles returns true if MapOfIntsToDoubles is not nil.

func (*PrimitiveContainersRequired) IsSetSetOfInts Uses

func (v *PrimitiveContainersRequired) IsSetSetOfInts() bool

IsSetSetOfInts returns true if SetOfInts is not nil.

func (*PrimitiveContainersRequired) MarshalLogObject Uses

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

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

func (*PrimitiveContainersRequired) String Uses

func (v *PrimitiveContainersRequired) String() string

String returns a readable string representation of a PrimitiveContainersRequired struct.

func (*PrimitiveContainersRequired) ToWire Uses

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

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
}

Package containers imports 13 packages (graph) and is imported by 2 packages. Updated 2020-04-01. Refresh now. Tools for package owners.