_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q10700 | NewSingleOutbound | train | func (t *ChannelTransport) NewSingleOutbound(addr string) *ChannelOutbound {
return &ChannelOutbound{
once: lifecycle.NewOnce(),
channel: t.ch,
transport: t,
addr: addr,
}
} | go | {
"resource": ""
} |
q10701 | withTransportSpec | train | func (k *Kit) withTransportSpec(spec *compiledTransportSpec) *Kit {
newK := *k
newK.transportSpec = spec
return &newK
} | go | {
"resource": ""
} |
q10702 | sleep | train | func (p *tchannelPeer) sleep(delay time.Duration) (completed bool) {
p.timer.Reset(delay)
select {
case <-p.timer.C:
return true
case <-p.released:
case <-p.transport.once.Stopping():
}
if !p.timer.Stop() {
<-p.timer.C
}
return false
} | go | {
"resource": ""
} |
q10703 | Read | train | func (b *Buffer) Read(p []byte) (int, error) {
version := b.preOp()
n, err := b.buf.Read(p)
b.postOp(version)
return n, err
} | go | {
"resource": ""
} |
q10704 | ReadFrom | train | func (b *Buffer) ReadFrom(r io.Reader) (int64, error) {
version := b.preOp()
n, err := b.buf.ReadFrom(r)
b.postOp(version)
return n, err
} | go | {
"resource": ""
} |
q10705 | WriteTo | train | func (b *Buffer) WriteTo(w io.Writer) (int64, error) {
version := b.preOp()
n, err := b.buf.WriteTo(w)
b.postOp(version)
return n, err
} | go | {
"resource": ""
} |
q10706 | Len | train | func (b *Buffer) Len() int {
version := b.preOp()
n := b.buf.Len()
b.postOp(version)
return n
} | go | {
"resource": ""
} |
q10707 | Reset | train | func (b *Buffer) Reset() {
version := b.preOp()
b.buf.Reset()
b.postOp(version)
} | go | {
"resource": ""
} |
q10708 | Release | train | func (b *Buffer) Release() {
// Increment the version so overlapping operations fail.
b.postOp(b.preOp())
if b.pool.testDetectUseAfterFree {
b.releaseDetectUseAfterFree()
return
}
// Before releasing a buffer, we should reset it to "clear" the buffer
// while holding on to the capacity of the buffer.
b.Reset()
// We must mark released after the `Reset`, so that `Reset` doesn't
// trigger use-after-free.
b.released = true
b.pool.release(b)
} | go | {
"resource": ""
} |
q10709 | readRequestHeaders | train | func readRequestHeaders(
ctx context.Context,
format tchannel.Format,
getReader func() (tchannel.ArgReader, error),
) (context.Context, transport.Headers, error) {
headers, err := readHeaders(format, getReader)
if err != nil {
return ctx, headers, err
}
return ctx, headers, nil
} | go | {
"resource": ""
} |
q10710 | readHeaders | train | func readHeaders(format tchannel.Format, getReader func() (tchannel.ArgReader, error)) (transport.Headers, error) {
if format == tchannel.JSON {
// JSON is special
var headers map[string]string
err := tchannel.NewArgReader(getReader()).ReadJSON(&headers)
return transport.HeadersFromMap(headers), err
}
r, err := getReader()
if err != nil {
return transport.Headers{}, err
}
headers, err := decodeHeaders(r)
if err != nil {
return headers, err
}
return headers, r.Close()
} | go | {
"resource": ""
} |
q10711 | writeHeaders | train | func writeHeaders(format tchannel.Format, headers map[string]string, tracingBaggage map[string]string, getWriter func() (tchannel.ArgWriter, error)) error {
merged := mergeHeaders(headers, tracingBaggage)
if format == tchannel.JSON {
// JSON is special
if merged == nil {
// We want to write "{}", not "null" for empty map.
merged = emptyMap
}
return tchannel.NewArgWriter(getWriter()).WriteJSON(merged)
}
return tchannel.NewArgWriter(getWriter()).Write(encodeHeaders(merged))
} | go | {
"resource": ""
} |
q10712 | mergeHeaders | train | func mergeHeaders(m1, m2 map[string]string) map[string]string {
if len(m1) == 0 {
return m2
}
if len(m2) == 0 {
return m1
}
// merge and return
merged := make(map[string]string, len(m1)+len(m2))
for k, v := range m1 {
merged[k] = v
}
for k, v := range m2 {
merged[k] = v
}
return merged
} | go | {
"resource": ""
} |
q10713 | validateServiceName | train | func validateServiceName(requestService, responseService string) error {
// an empty service string means that we're talking to an older YARPC
// TChannel client
if responseService == "" || requestService == responseService {
return nil
}
return yarpcerrors.InternalErrorf(
"service name sent from the request does not match the service name "+
"received in the response: sent %q, got: %q", requestService, responseService)
} | go | {
"resource": ""
} |
q10714 | _putStr16 | train | func _putStr16(in string, out []byte) int {
binary.BigEndian.PutUint16(out, uint16(len(in)))
return copy(out[2:], in) + 2
} | go | {
"resource": ""
} |
q10715 | ReadRequest | train | func ReadRequest(reader io.Reader) (*plugin_go.CodeGeneratorRequest, error) {
input, err := ioutil.ReadAll(reader)
if err != nil {
return nil, err
}
request := &plugin_go.CodeGeneratorRequest{}
if err := proto.Unmarshal(input, request); err != nil {
return nil, err
}
return request, nil
} | go | {
"resource": ""
} |
q10716 | WriteResponse | train | func WriteResponse(writer io.Writer, response *plugin_go.CodeGeneratorResponse) error {
buf, err := proto.Marshal(response)
if err != nil {
return err
}
if _, err := writer.Write(buf); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q10717 | SerializedFileDescriptor | train | func (f *File) SerializedFileDescriptor() ([]byte, error) {
pb := proto.Clone(f.FileDescriptorProto).(*descriptor.FileDescriptorProto)
pb.SourceCodeInfo = nil
b, err := proto.Marshal(pb)
if err != nil {
return nil, err
}
var buf bytes.Buffer
w, err := gzip.NewWriterLevel(&buf, gzip.BestCompression)
if err != nil {
return nil, err
}
_, err = w.Write(b)
if err != nil {
return nil, err
}
w.Close()
return buf.Bytes(), nil
} | go | {
"resource": ""
} |
q10718 | GoType | train | func (m *Message) GoType(currentPackage string) string {
var components []string
components = append(components, m.Outers...)
components = append(components, m.GetName())
name := strings.Join(components, "_")
if m.File.GoPackage.Path == currentPackage {
return name
}
pkg := m.File.GoPackage.Name
if alias := m.File.GoPackage.Alias; alias != "" {
pkg = alias
}
return fmt.Sprintf("%s.%s", pkg, name)
} | go | {
"resource": ""
} |
q10719 | Equals | train | func (v *Bonk) Equals(rhs *Bonk) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !_String_EqualsPtr(v.Message, rhs.Message) {
return false
}
if !_I32_EqualsPtr(v.Type, rhs.Type) {
return false
}
return true
} | go | {
"resource": ""
} |
q10720 | MarshalLogObject | train | func (v *Bonk) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.Message != nil {
enc.AddString("message", *v.Message)
}
if v.Type != nil {
enc.AddInt32("type", *v.Type)
}
return err
} | go | {
"resource": ""
} |
q10721 | String | train | func (v *BoolTest) String() string {
if v == nil {
return "<nil>"
}
var fields [2]string
i := 0
if v.B != nil {
fields[i] = fmt.Sprintf("B: %v", *(v.B))
i++
}
if v.S != nil {
fields[i] = fmt.Sprintf("S: %v", *(v.S))
i++
}
return fmt.Sprintf("BoolTest{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10722 | Equals | train | func (v *BoolTest) Equals(rhs *BoolTest) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !_Bool_EqualsPtr(v.B, rhs.B) {
return false
}
if !_String_EqualsPtr(v.S, rhs.S) {
return false
}
return true
} | go | {
"resource": ""
} |
q10723 | MarshalLogObject | train | func (v *BoolTest) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.B != nil {
enc.AddBool("b", *v.B)
}
if v.S != nil {
enc.AddString("s", *v.S)
}
return err
} | go | {
"resource": ""
} |
q10724 | GetB | train | func (v *BoolTest) GetB() (o bool) {
if v != nil && v.B != nil {
return *v.B
}
o = true
return
} | go | {
"resource": ""
} |
q10725 | GetS | train | func (v *BoolTest) GetS() (o string) {
if v != nil && v.S != nil {
return *v.S
}
o = "true"
return
} | go | {
"resource": ""
} |
q10726 | String | train | func (v *Bools) String() string {
if v == nil {
return "<nil>"
}
var fields [2]string
i := 0
if v.ImTrue != nil {
fields[i] = fmt.Sprintf("ImTrue: %v", *(v.ImTrue))
i++
}
if v.ImFalse != nil {
fields[i] = fmt.Sprintf("ImFalse: %v", *(v.ImFalse))
i++
}
return fmt.Sprintf("Bools{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10727 | Equals | train | func (v *Bools) Equals(rhs *Bools) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !_Bool_EqualsPtr(v.ImTrue, rhs.ImTrue) {
return false
}
if !_Bool_EqualsPtr(v.ImFalse, rhs.ImFalse) {
return false
}
return true
} | go | {
"resource": ""
} |
q10728 | MarshalLogObject | train | func (v *Bools) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.ImTrue != nil {
enc.AddBool("im_true", *v.ImTrue)
}
if v.ImFalse != nil {
enc.AddBool("im_false", *v.ImFalse)
}
return err
} | go | {
"resource": ""
} |
q10729 | GetImTrue | train | func (v *Bools) GetImTrue() (o bool) {
if v != nil && v.ImTrue != nil {
return *v.ImTrue
}
return
} | go | {
"resource": ""
} |
q10730 | GetImFalse | train | func (v *Bools) GetImFalse() (o bool) {
if v != nil && v.ImFalse != nil {
return *v.ImFalse
}
return
} | go | {
"resource": ""
} |
q10731 | String | train | func (v *CrazyNesting) String() string {
if v == nil {
return "<nil>"
}
var fields [4]string
i := 0
if v.StringField != nil {
fields[i] = fmt.Sprintf("StringField: %v", *(v.StringField))
i++
}
if v.SetField != nil {
fields[i] = fmt.Sprintf("SetField: %v", v.SetField)
i++
}
fields[i] = fmt.Sprintf("ListField: %v", v.ListField)
i++
if v.BinaryField != nil {
fields[i] = fmt.Sprintf("BinaryField: %v", v.BinaryField)
i++
}
return fmt.Sprintf("CrazyNesting{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10732 | Equals | train | func (v *CrazyNesting) Equals(rhs *CrazyNesting) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !_String_EqualsPtr(v.StringField, rhs.StringField) {
return false
}
if !((v.SetField == nil && rhs.SetField == nil) || (v.SetField != nil && rhs.SetField != nil && _Set_Insanity_Equals(v.SetField, rhs.SetField))) {
return false
}
if !_List_Map_Set_I32_Map_I32_Set_List_Map_Insanity_String_Equals(v.ListField, rhs.ListField) {
return false
}
if !((v.BinaryField == nil && rhs.BinaryField == nil) || (v.BinaryField != nil && rhs.BinaryField != nil && bytes.Equal(v.BinaryField, rhs.BinaryField))) {
return false
}
return true
} | go | {
"resource": ""
} |
q10733 | MarshalLogArray | train | func (s _Set_Insanity_Zapper) MarshalLogArray(enc zapcore.ArrayEncoder) (err error) {
for _, v := range s {
err = multierr.Append(err, enc.AppendObject(v))
}
return err
} | go | {
"resource": ""
} |
q10734 | MarshalLogArray | train | func (s _Set_I32_Zapper) MarshalLogArray(enc zapcore.ArrayEncoder) (err error) {
for v := range s {
enc.AppendInt32(v)
}
return err
} | go | {
"resource": ""
} |
q10735 | MarshalLogObject | train | func (v _Map_Insanity_String_Item_Zapper) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
err = multierr.Append(err, enc.AddObject("key", v.Key))
enc.AddString("value", v.Value)
return err
} | go | {
"resource": ""
} |
q10736 | MarshalLogArray | train | func (l _List_Map_Insanity_String_Zapper) MarshalLogArray(enc zapcore.ArrayEncoder) (err error) {
for _, v := range l {
err = multierr.Append(err, enc.AppendArray((_Map_Insanity_String_Zapper)(v)))
}
return err
} | go | {
"resource": ""
} |
q10737 | MarshalLogArray | train | func (s _Set_List_Map_Insanity_String_Zapper) MarshalLogArray(enc zapcore.ArrayEncoder) (err error) {
for _, v := range s {
err = multierr.Append(err, enc.AppendArray((_List_Map_Insanity_String_Zapper)(v)))
}
return err
} | go | {
"resource": ""
} |
q10738 | MarshalLogObject | train | func (v _Map_I32_Set_List_Map_Insanity_String_Item_Zapper) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
enc.AddInt32("key", v.Key)
err = multierr.Append(err, enc.AddArray("value", (_Set_List_Map_Insanity_String_Zapper)(v.Value)))
return err
} | go | {
"resource": ""
} |
q10739 | MarshalLogArray | train | func (m _Map_I32_Set_List_Map_Insanity_String_Zapper) MarshalLogArray(enc zapcore.ArrayEncoder) (err error) {
for k, v := range m {
err = multierr.Append(err, enc.AppendObject(_Map_I32_Set_List_Map_Insanity_String_Item_Zapper{Key: k, Value: v}))
}
return err
} | go | {
"resource": ""
} |
q10740 | MarshalLogObject | train | func (v _Map_Set_I32_Map_I32_Set_List_Map_Insanity_String_Item_Zapper) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
err = multierr.Append(err, enc.AddArray("key", (_Set_I32_Zapper)(v.Key)))
err = multierr.Append(err, enc.AddArray("value", (_Map_I32_Set_List_Map_Insanity_String_Zapper)(v.Value)))
return err
} | go | {
"resource": ""
} |
q10741 | MarshalLogArray | train | func (m _Map_Set_I32_Map_I32_Set_List_Map_Insanity_String_Zapper) MarshalLogArray(enc zapcore.ArrayEncoder) (err error) {
for _, i := range m {
k := i.Key
v := i.Value
err = multierr.Append(err, enc.AppendObject(_Map_Set_I32_Map_I32_Set_List_Map_Insanity_String_Item_Zapper{Key: k, Value: v}))
}
return err
} | go | {
"resource": ""
} |
q10742 | MarshalLogArray | train | func (l _List_Map_Set_I32_Map_I32_Set_List_Map_Insanity_String_Zapper) MarshalLogArray(enc zapcore.ArrayEncoder) (err error) {
for _, v := range l {
err = multierr.Append(err, enc.AppendArray((_Map_Set_I32_Map_I32_Set_List_Map_Insanity_String_Zapper)(v)))
}
return err
} | go | {
"resource": ""
} |
q10743 | MarshalLogObject | train | func (v *CrazyNesting) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.StringField != nil {
enc.AddString("string_field", *v.StringField)
}
if v.SetField != nil {
err = multierr.Append(err, enc.AddArray("set_field", (_Set_Insanity_Zapper)(v.SetField)))
}
err = multierr.Append(err, enc.AddArray("list_field", (_List_Map_Set_I32_Map_I32_Set_List_Map_Insanity_String_Zapper)(v.ListField)))
if v.BinaryField != nil {
enc.AddString("binary_field", base64.StdEncoding.EncodeToString(v.BinaryField))
}
return err
} | go | {
"resource": ""
} |
q10744 | GetStringField | train | func (v *CrazyNesting) GetStringField() (o string) {
if v != nil && v.StringField != nil {
return *v.StringField
}
return
} | go | {
"resource": ""
} |
q10745 | GetSetField | train | func (v *CrazyNesting) GetSetField() (o []*Insanity) {
if v != nil && v.SetField != nil {
return v.SetField
}
return
} | go | {
"resource": ""
} |
q10746 | GetListField | train | func (v *CrazyNesting) GetListField() (o [][]struct {
Key map[int32]struct{}
Value map[int32][][][]struct {
Key *Insanity
Value string
}
}) {
if v != nil {
o = v.ListField
}
return
} | go | {
"resource": ""
} |
q10747 | GetBinaryField | train | func (v *CrazyNesting) GetBinaryField() (o []byte) {
if v != nil && v.BinaryField != nil {
return v.BinaryField
}
return
} | go | {
"resource": ""
} |
q10748 | Equals | train | func (v *EmptyStruct) Equals(rhs *EmptyStruct) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
return true
} | go | {
"resource": ""
} |
q10749 | String | train | func (v *GuessProtocolStruct) String() string {
if v == nil {
return "<nil>"
}
var fields [1]string
i := 0
if v.MapField != nil {
fields[i] = fmt.Sprintf("MapField: %v", v.MapField)
i++
}
return fmt.Sprintf("GuessProtocolStruct{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10750 | Equals | train | func (v *GuessProtocolStruct) Equals(rhs *GuessProtocolStruct) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !((v.MapField == nil && rhs.MapField == nil) || (v.MapField != nil && rhs.MapField != nil && _Map_String_String_Equals(v.MapField, rhs.MapField))) {
return false
}
return true
} | go | {
"resource": ""
} |
q10751 | MarshalLogObject | train | func (v *GuessProtocolStruct) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.MapField != nil {
err = multierr.Append(err, enc.AddObject("map_field", (_Map_String_String_Zapper)(v.MapField)))
}
return err
} | go | {
"resource": ""
} |
q10752 | GetMapField | train | func (v *GuessProtocolStruct) GetMapField() (o map[string]string) {
if v != nil && v.MapField != nil {
return v.MapField
}
return
} | go | {
"resource": ""
} |
q10753 | String | train | func (v *Insanity) String() string {
if v == nil {
return "<nil>"
}
var fields [2]string
i := 0
if v.UserMap != nil {
fields[i] = fmt.Sprintf("UserMap: %v", v.UserMap)
i++
}
if v.Xtructs != nil {
fields[i] = fmt.Sprintf("Xtructs: %v", v.Xtructs)
i++
}
return fmt.Sprintf("Insanity{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10754 | Equals | train | func (v *Insanity) Equals(rhs *Insanity) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !((v.UserMap == nil && rhs.UserMap == nil) || (v.UserMap != nil && rhs.UserMap != nil && _Map_Numberz_UserId_Equals(v.UserMap, rhs.UserMap))) {
return false
}
if !((v.Xtructs == nil && rhs.Xtructs == nil) || (v.Xtructs != nil && rhs.Xtructs != nil && _List_Xtruct_Equals(v.Xtructs, rhs.Xtructs))) {
return false
}
return true
} | go | {
"resource": ""
} |
q10755 | MarshalLogObject | train | func (v _Map_Numberz_UserId_Item_Zapper) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
err = multierr.Append(err, enc.AddObject("key", v.Key))
enc.AddInt64("value", (int64)(v.Value))
return err
} | go | {
"resource": ""
} |
q10756 | MarshalLogArray | train | func (m _Map_Numberz_UserId_Zapper) MarshalLogArray(enc zapcore.ArrayEncoder) (err error) {
for k, v := range m {
err = multierr.Append(err, enc.AppendObject(_Map_Numberz_UserId_Item_Zapper{Key: k, Value: v}))
}
return err
} | go | {
"resource": ""
} |
q10757 | MarshalLogObject | train | func (v *Insanity) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.UserMap != nil {
err = multierr.Append(err, enc.AddArray("userMap", (_Map_Numberz_UserId_Zapper)(v.UserMap)))
}
if v.Xtructs != nil {
err = multierr.Append(err, enc.AddArray("xtructs", (_List_Xtruct_Zapper)(v.Xtructs)))
}
return err
} | go | {
"resource": ""
} |
q10758 | GetUserMap | train | func (v *Insanity) GetUserMap() (o map[Numberz]UserId) {
if v != nil && v.UserMap != nil {
return v.UserMap
}
return
} | go | {
"resource": ""
} |
q10759 | GetXtructs | train | func (v *Insanity) GetXtructs() (o []*Xtruct) {
if v != nil && v.Xtructs != nil {
return v.Xtructs
}
return
} | go | {
"resource": ""
} |
q10760 | String | train | func (v *LargeDeltas) String() string {
if v == nil {
return "<nil>"
}
var fields [10]string
i := 0
if v.B1 != nil {
fields[i] = fmt.Sprintf("B1: %v", v.B1)
i++
}
if v.B10 != nil {
fields[i] = fmt.Sprintf("B10: %v", v.B10)
i++
}
if v.B100 != nil {
fields[i] = fmt.Sprintf("B100: %v", v.B100)
i++
}
if v.CheckTrue != nil {
fields[i] = fmt.Sprintf("CheckTrue: %v", *(v.CheckTrue))
i++
}
if v.B1000 != nil {
fields[i] = fmt.Sprintf("B1000: %v", v.B1000)
i++
}
if v.CheckFalse != nil {
fields[i] = fmt.Sprintf("CheckFalse: %v", *(v.CheckFalse))
i++
}
if v.Vertwo2000 != nil {
fields[i] = fmt.Sprintf("Vertwo2000: %v", v.Vertwo2000)
i++
}
if v.ASet2500 != nil {
fields[i] = fmt.Sprintf("ASet2500: %v", v.ASet2500)
i++
}
if v.Vertwo3000 != nil {
fields[i] = fmt.Sprintf("Vertwo3000: %v", v.Vertwo3000)
i++
}
if v.BigNumbers != nil {
fields[i] = fmt.Sprintf("BigNumbers: %v", v.BigNumbers)
i++
}
return fmt.Sprintf("LargeDeltas{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10761 | Equals | train | func (v *LargeDeltas) Equals(rhs *LargeDeltas) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !((v.B1 == nil && rhs.B1 == nil) || (v.B1 != nil && rhs.B1 != nil && v.B1.Equals(rhs.B1))) {
return false
}
if !((v.B10 == nil && rhs.B10 == nil) || (v.B10 != nil && rhs.B10 != nil && v.B10.Equals(rhs.B10))) {
return false
}
if !((v.B100 == nil && rhs.B100 == nil) || (v.B100 != nil && rhs.B100 != nil && v.B100.Equals(rhs.B100))) {
return false
}
if !_Bool_EqualsPtr(v.CheckTrue, rhs.CheckTrue) {
return false
}
if !((v.B1000 == nil && rhs.B1000 == nil) || (v.B1000 != nil && rhs.B1000 != nil && v.B1000.Equals(rhs.B1000))) {
return false
}
if !_Bool_EqualsPtr(v.CheckFalse, rhs.CheckFalse) {
return false
}
if !((v.Vertwo2000 == nil && rhs.Vertwo2000 == nil) || (v.Vertwo2000 != nil && rhs.Vertwo2000 != nil && v.Vertwo2000.Equals(rhs.Vertwo2000))) {
return false
}
if !((v.ASet2500 == nil && rhs.ASet2500 == nil) || (v.ASet2500 != nil && rhs.ASet2500 != nil && _Set_String_Equals(v.ASet2500, rhs.ASet2500))) {
return false
}
if !((v.Vertwo3000 == nil && rhs.Vertwo3000 == nil) || (v.Vertwo3000 != nil && rhs.Vertwo3000 != nil && v.Vertwo3000.Equals(rhs.Vertwo3000))) {
return false
}
if !((v.BigNumbers == nil && rhs.BigNumbers == nil) || (v.BigNumbers != nil && rhs.BigNumbers != nil && _List_I32_Equals(v.BigNumbers, rhs.BigNumbers))) {
return false
}
return true
} | go | {
"resource": ""
} |
q10762 | MarshalLogArray | train | func (s _Set_String_Zapper) MarshalLogArray(enc zapcore.ArrayEncoder) (err error) {
for v := range s {
enc.AppendString(v)
}
return err
} | go | {
"resource": ""
} |
q10763 | MarshalLogArray | train | func (l _List_I32_Zapper) MarshalLogArray(enc zapcore.ArrayEncoder) (err error) {
for _, v := range l {
enc.AppendInt32(v)
}
return err
} | go | {
"resource": ""
} |
q10764 | MarshalLogObject | train | func (v *LargeDeltas) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.B1 != nil {
err = multierr.Append(err, enc.AddObject("b1", v.B1))
}
if v.B10 != nil {
err = multierr.Append(err, enc.AddObject("b10", v.B10))
}
if v.B100 != nil {
err = multierr.Append(err, enc.AddObject("b100", v.B100))
}
if v.CheckTrue != nil {
enc.AddBool("check_true", *v.CheckTrue)
}
if v.B1000 != nil {
err = multierr.Append(err, enc.AddObject("b1000", v.B1000))
}
if v.CheckFalse != nil {
enc.AddBool("check_false", *v.CheckFalse)
}
if v.Vertwo2000 != nil {
err = multierr.Append(err, enc.AddObject("vertwo2000", v.Vertwo2000))
}
if v.ASet2500 != nil {
err = multierr.Append(err, enc.AddArray("a_set2500", (_Set_String_Zapper)(v.ASet2500)))
}
if v.Vertwo3000 != nil {
err = multierr.Append(err, enc.AddObject("vertwo3000", v.Vertwo3000))
}
if v.BigNumbers != nil {
err = multierr.Append(err, enc.AddArray("big_numbers", (_List_I32_Zapper)(v.BigNumbers)))
}
return err
} | go | {
"resource": ""
} |
q10765 | GetB1 | train | func (v *LargeDeltas) GetB1() (o *Bools) {
if v != nil && v.B1 != nil {
return v.B1
}
return
} | go | {
"resource": ""
} |
q10766 | GetB10 | train | func (v *LargeDeltas) GetB10() (o *Bools) {
if v != nil && v.B10 != nil {
return v.B10
}
return
} | go | {
"resource": ""
} |
q10767 | GetB100 | train | func (v *LargeDeltas) GetB100() (o *Bools) {
if v != nil && v.B100 != nil {
return v.B100
}
return
} | go | {
"resource": ""
} |
q10768 | GetCheckTrue | train | func (v *LargeDeltas) GetCheckTrue() (o bool) {
if v != nil && v.CheckTrue != nil {
return *v.CheckTrue
}
return
} | go | {
"resource": ""
} |
q10769 | GetB1000 | train | func (v *LargeDeltas) GetB1000() (o *Bools) {
if v != nil && v.B1000 != nil {
return v.B1000
}
return
} | go | {
"resource": ""
} |
q10770 | GetCheckFalse | train | func (v *LargeDeltas) GetCheckFalse() (o bool) {
if v != nil && v.CheckFalse != nil {
return *v.CheckFalse
}
return
} | go | {
"resource": ""
} |
q10771 | GetVertwo2000 | train | func (v *LargeDeltas) GetVertwo2000() (o *VersioningTestV2) {
if v != nil && v.Vertwo2000 != nil {
return v.Vertwo2000
}
return
} | go | {
"resource": ""
} |
q10772 | GetASet2500 | train | func (v *LargeDeltas) GetASet2500() (o map[string]struct{}) {
if v != nil && v.ASet2500 != nil {
return v.ASet2500
}
return
} | go | {
"resource": ""
} |
q10773 | GetVertwo3000 | train | func (v *LargeDeltas) GetVertwo3000() (o *VersioningTestV2) {
if v != nil && v.Vertwo3000 != nil {
return v.Vertwo3000
}
return
} | go | {
"resource": ""
} |
q10774 | GetBigNumbers | train | func (v *LargeDeltas) GetBigNumbers() (o []int32) {
if v != nil && v.BigNumbers != nil {
return v.BigNumbers
}
return
} | go | {
"resource": ""
} |
q10775 | String | train | func (v *ListBonks) String() string {
if v == nil {
return "<nil>"
}
var fields [1]string
i := 0
if v.Bonk != nil {
fields[i] = fmt.Sprintf("Bonk: %v", v.Bonk)
i++
}
return fmt.Sprintf("ListBonks{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10776 | Equals | train | func (v *ListBonks) Equals(rhs *ListBonks) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !((v.Bonk == nil && rhs.Bonk == nil) || (v.Bonk != nil && rhs.Bonk != nil && _List_Bonk_Equals(v.Bonk, rhs.Bonk))) {
return false
}
return true
} | go | {
"resource": ""
} |
q10777 | MarshalLogObject | train | func (v *ListBonks) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.Bonk != nil {
err = multierr.Append(err, enc.AddArray("bonk", (_List_Bonk_Zapper)(v.Bonk)))
}
return err
} | go | {
"resource": ""
} |
q10778 | String | train | func (v *ListTypeVersioningV1) String() string {
if v == nil {
return "<nil>"
}
var fields [2]string
i := 0
if v.Myints != nil {
fields[i] = fmt.Sprintf("Myints: %v", v.Myints)
i++
}
if v.Hello != nil {
fields[i] = fmt.Sprintf("Hello: %v", *(v.Hello))
i++
}
return fmt.Sprintf("ListTypeVersioningV1{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10779 | Equals | train | func (v *ListTypeVersioningV1) Equals(rhs *ListTypeVersioningV1) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !((v.Myints == nil && rhs.Myints == nil) || (v.Myints != nil && rhs.Myints != nil && _List_I32_Equals(v.Myints, rhs.Myints))) {
return false
}
if !_String_EqualsPtr(v.Hello, rhs.Hello) {
return false
}
return true
} | go | {
"resource": ""
} |
q10780 | MarshalLogObject | train | func (v *ListTypeVersioningV1) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.Myints != nil {
err = multierr.Append(err, enc.AddArray("myints", (_List_I32_Zapper)(v.Myints)))
}
if v.Hello != nil {
enc.AddString("hello", *v.Hello)
}
return err
} | go | {
"resource": ""
} |
q10781 | GetMyints | train | func (v *ListTypeVersioningV1) GetMyints() (o []int32) {
if v != nil && v.Myints != nil {
return v.Myints
}
return
} | go | {
"resource": ""
} |
q10782 | String | train | func (v *ListTypeVersioningV2) String() string {
if v == nil {
return "<nil>"
}
var fields [2]string
i := 0
if v.Strings != nil {
fields[i] = fmt.Sprintf("Strings: %v", v.Strings)
i++
}
if v.Hello != nil {
fields[i] = fmt.Sprintf("Hello: %v", *(v.Hello))
i++
}
return fmt.Sprintf("ListTypeVersioningV2{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10783 | Equals | train | func (v *ListTypeVersioningV2) Equals(rhs *ListTypeVersioningV2) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !((v.Strings == nil && rhs.Strings == nil) || (v.Strings != nil && rhs.Strings != nil && _List_String_Equals(v.Strings, rhs.Strings))) {
return false
}
if !_String_EqualsPtr(v.Hello, rhs.Hello) {
return false
}
return true
} | go | {
"resource": ""
} |
q10784 | MarshalLogArray | train | func (l _List_String_Zapper) MarshalLogArray(enc zapcore.ArrayEncoder) (err error) {
for _, v := range l {
enc.AppendString(v)
}
return err
} | go | {
"resource": ""
} |
q10785 | MarshalLogObject | train | func (v *ListTypeVersioningV2) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.Strings != nil {
err = multierr.Append(err, enc.AddArray("strings", (_List_String_Zapper)(v.Strings)))
}
if v.Hello != nil {
enc.AddString("hello", *v.Hello)
}
return err
} | go | {
"resource": ""
} |
q10786 | GetStrings | train | func (v *ListTypeVersioningV2) GetStrings() (o []string) {
if v != nil && v.Strings != nil {
return v.Strings
}
return
} | go | {
"resource": ""
} |
q10787 | MarshalLogObject | train | func (m _Map_String_Bonk_Zapper) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
for k, v := range m {
err = multierr.Append(err, enc.AddObject((string)(k), v))
}
return err
} | go | {
"resource": ""
} |
q10788 | ToWire | train | func (v MapType) ToWire() (wire.Value, error) {
x := (map[string]*Bonk)(v)
return wire.NewValueMap(_Map_String_Bonk_MapItemList(x)), error(nil)
} | go | {
"resource": ""
} |
q10789 | String | train | func (v MapType) String() string {
x := (map[string]*Bonk)(v)
return fmt.Sprint(x)
} | go | {
"resource": ""
} |
q10790 | FromWire | train | func (v *MapType) FromWire(w wire.Value) error {
x, err := _Map_String_Bonk_Read(w.GetMap())
*v = (MapType)(x)
return err
} | go | {
"resource": ""
} |
q10791 | Equals | train | func (lhs MapType) Equals(rhs MapType) bool {
return _Map_String_Bonk_Equals((map[string]*Bonk)(lhs), (map[string]*Bonk)(rhs))
} | go | {
"resource": ""
} |
q10792 | Equals | train | func (v *NestedListsBonk) Equals(rhs *NestedListsBonk) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !((v.Bonk == nil && rhs.Bonk == nil) || (v.Bonk != nil && rhs.Bonk != nil && _List_List_List_Bonk_Equals(v.Bonk, rhs.Bonk))) {
return false
}
return true
} | go | {
"resource": ""
} |
q10793 | MarshalLogArray | train | func (l _List_List_Bonk_Zapper) MarshalLogArray(enc zapcore.ArrayEncoder) (err error) {
for _, v := range l {
err = multierr.Append(err, enc.AppendArray((_List_Bonk_Zapper)(v)))
}
return err
} | go | {
"resource": ""
} |
q10794 | MarshalLogObject | train | func (v *NestedListsBonk) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.Bonk != nil {
err = multierr.Append(err, enc.AddArray("bonk", (_List_List_List_Bonk_Zapper)(v.Bonk)))
}
return err
} | go | {
"resource": ""
} |
q10795 | Equals | train | func (v *NestedListsI32x2) Equals(rhs *NestedListsI32x2) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !((v.Integerlist == nil && rhs.Integerlist == nil) || (v.Integerlist != nil && rhs.Integerlist != nil && _List_List_I32_Equals(v.Integerlist, rhs.Integerlist))) {
return false
}
return true
} | go | {
"resource": ""
} |
q10796 | MarshalLogObject | train | func (v *NestedListsI32x2) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.Integerlist != nil {
err = multierr.Append(err, enc.AddArray("integerlist", (_List_List_I32_Zapper)(v.Integerlist)))
}
return err
} | go | {
"resource": ""
} |
q10797 | String | train | func (v *NestedListsI32x3) String() string {
if v == nil {
return "<nil>"
}
var fields [1]string
i := 0
if v.Integerlist != nil {
fields[i] = fmt.Sprintf("Integerlist: %v", v.Integerlist)
i++
}
return fmt.Sprintf("NestedListsI32x3{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10798 | Equals | train | func (v *NestedListsI32x3) Equals(rhs *NestedListsI32x3) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !((v.Integerlist == nil && rhs.Integerlist == nil) || (v.Integerlist != nil && rhs.Integerlist != nil && _List_List_List_I32_Equals(v.Integerlist, rhs.Integerlist))) {
return false
}
return true
} | go | {
"resource": ""
} |
q10799 | MarshalLogArray | train | func (l _List_List_List_I32_Zapper) MarshalLogArray(enc zapcore.ArrayEncoder) (err error) {
for _, v := range l {
err = multierr.Append(err, enc.AppendArray((_List_List_I32_Zapper)(v)))
}
return err
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.