id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c10700 | lifecycle.NewOnce(),
channel: t.ch,
transport: t,
addr: addr,
}
} | |
c10701 | *Kit {
newK := *k
newK.transportSpec = spec
return &newK
} | |
c10702 | <-p.released:
case <-p.transport.once.Stopping():
}
if !p.timer.Stop() {
<-p.timer.C
}
return false
} | |
c10703 | err := b.buf.Read(p)
b.postOp(version)
return n, err
} | |
c10704 | version := b.preOp()
n, err := b.buf.ReadFrom(r)
b.postOp(version)
return n, err
} | |
c10705 | err := b.buf.WriteTo(w)
b.postOp(version)
return n, err
} | |
c10706 | b.buf.Len()
b.postOp(version)
return n
} | |
c10707 | := b.preOp()
b.buf.Reset()
b.postOp(version)
} | |
c10708 | // 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)
} | |
c10709 | readHeaders(format, getReader)
if err != nil {
return ctx, headers, err
}
return ctx, headers, nil
} | |
c10710 |
if err != nil {
return transport.Headers{}, err
}
headers, err := decodeHeaders(r)
if err != nil {
return headers, err
}
return headers, r.Close()
} | |
c10711 | merged = emptyMap
}
return tchannel.NewArgWriter(getWriter()).WriteJSON(merged)
}
return tchannel.NewArgWriter(getWriter()).Write(encodeHeaders(merged))
} | |
c10712 |
}
// 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
} | |
c10713 | "service name sent from the request does not match the service name "+
"received in the response: sent %q, got: %q", requestService, responseService)
} | |
c10714 | uint16(len(in)))
return copy(out[2:], in) + 2
} | |
c10715 | proto.Unmarshal(input, request); err != nil {
return nil, err
}
return request, nil
} | |
c10716 | := proto.Marshal(response)
if err != nil {
return err
}
if _, err := writer.Write(buf); err != nil {
return err
}
return nil
} | |
c10717 |
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
} | |
c10718 |
pkg := m.File.GoPackage.Name
if alias := m.File.GoPackage.Alias; alias != "" {
pkg = alias
}
return fmt.Sprintf("%s.%s", pkg, name)
} | |
c10719 | return false
}
if !_I32_EqualsPtr(v.Type, rhs.Type) {
return false
}
return true
} | |
c10720 |
enc.AddString("message", *v.Message)
}
if v.Type != nil {
enc.AddInt32("type", *v.Type)
}
return err
} | |
c10721 | = fmt.Sprintf("S: %v", *(v.S))
i++
}
return fmt.Sprintf("BoolTest{%v}", strings.Join(fields[:i], ", "))
} | |
c10722 | {
return false
}
if !_Bool_EqualsPtr(v.B, rhs.B) {
return false
}
if !_String_EqualsPtr(v.S, rhs.S) {
return false
}
return true
} | |
c10723 |
}
if v.S != nil {
enc.AddString("s", *v.S)
}
return err
} | |
c10724 | return *v.B
}
o = true
return
} | |
c10725 | return *v.S
}
o = "true"
return
} | |
c10726 | fmt.Sprintf("ImFalse: %v", *(v.ImFalse))
i++
}
return fmt.Sprintf("Bools{%v}", strings.Join(fields[:i], ", "))
} | |
c10727 |
}
if !_Bool_EqualsPtr(v.ImTrue, rhs.ImTrue) {
return false
}
if !_Bool_EqualsPtr(v.ImFalse, rhs.ImFalse) {
return false
}
return true
} | |
c10728 |
}
if v.ImTrue != nil {
enc.AddBool("im_true", *v.ImTrue)
}
if v.ImFalse != nil {
enc.AddBool("im_false", *v.ImFalse)
}
return err
} | |
c10729 | return *v.ImTrue
}
return
} | |
c10730 | return *v.ImFalse
}
return
} | |
c10731 | = 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], ", "))
} | |
c10732 | !_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
} | |
c10733 | error) {
for _, v := range s {
err = multierr.Append(err, enc.AppendObject(v))
}
return err
} | |
c10734 | (err error) {
for v := range s {
enc.AppendInt32(v)
}
return err
} | |
c10735 | (err error) {
err = multierr.Append(err, enc.AddObject("key", v.Key))
enc.AddString("value", v.Value)
return err
} | |
c10736 | {
for _, v := range l {
err = multierr.Append(err, enc.AppendArray((_Map_Insanity_String_Zapper)(v)))
}
return err
} | |
c10737 | {
for _, v := range s {
err = multierr.Append(err, enc.AppendArray((_List_Map_Insanity_String_Zapper)(v)))
}
return err
} | |
c10738 | enc.AddArray("value", (_Set_List_Map_Insanity_String_Zapper)(v.Value)))
return err
} | |
c10739 |
err = multierr.Append(err, enc.AppendObject(_Map_I32_Set_List_Map_Insanity_String_Item_Zapper{Key: k, Value: v}))
}
return err
} | |
c10740 | = 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
} | |
c10741 | err = multierr.Append(err, enc.AppendObject(_Map_Set_I32_Map_I32_Set_List_Map_Insanity_String_Item_Zapper{Key: k, Value: v}))
}
return err
} | |
c10742 | 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
} | |
c10743 | (_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
} | |
c10744 | {
return *v.StringField
}
return
} | |
c10745 | nil {
return v.SetField
}
return
} | |
c10746 | *Insanity
Value string
}
}) {
if v != nil {
o = v.ListField
}
return
} | |
c10747 | {
return v.BinaryField
}
return
} | |
c10748 |
} else if rhs == nil {
return false
}
return true
} | |
c10749 | if v.MapField != nil {
fields[i] = fmt.Sprintf("MapField: %v", v.MapField)
i++
}
return fmt.Sprintf("GuessProtocolStruct{%v}", strings.Join(fields[:i], ", "))
} | |
c10750 | != nil && _Map_String_String_Equals(v.MapField, rhs.MapField))) {
return false
}
return true
} | |
c10751 | return nil
}
if v.MapField != nil {
err = multierr.Append(err, enc.AddObject("map_field", (_Map_String_String_Zapper)(v.MapField)))
}
return err
} | |
c10752 | {
if v != nil && v.MapField != nil {
return v.MapField
}
return
} | |
c10753 | = fmt.Sprintf("Xtructs: %v", v.Xtructs)
i++
}
return fmt.Sprintf("Insanity{%v}", strings.Join(fields[:i], ", "))
} | |
c10754 | == nil && rhs.Xtructs == nil) || (v.Xtructs != nil && rhs.Xtructs != nil && _List_Xtruct_Equals(v.Xtructs, rhs.Xtructs))) {
return false
}
return true
} | |
c10755 | (err error) {
err = multierr.Append(err, enc.AddObject("key", v.Key))
enc.AddInt64("value", (int64)(v.Value))
return err
} | |
c10756 | err = multierr.Append(err, enc.AppendObject(_Map_Numberz_UserId_Item_Zapper{Key: k, Value: v}))
}
return err
} | |
c10757 | {
err = multierr.Append(err, enc.AddArray("xtructs", (_List_Xtruct_Zapper)(v.Xtructs)))
}
return err
} | |
c10758 | nil {
return v.UserMap
}
return
} | |
c10759 | {
return v.Xtructs
}
return
} | |
c10760 | 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("ASet2... | |
c10761 | 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.BigNumb... | |
c10762 | (err error) {
for v := range s {
enc.AppendString(v)
}
return err
} | |
c10763 | (err error) {
for _, v := range l {
enc.AppendInt32(v)
}
return err
} | |
c10764 | 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 {
... | |
c10765 | nil {
return v.B1
}
return
} | |
c10766 | nil {
return v.B10
}
return
} | |
c10767 | nil {
return v.B100
}
return
} | |
c10768 |
return *v.CheckTrue
}
return
} | |
c10769 | nil {
return v.B1000
}
return
} | |
c10770 |
return *v.CheckFalse
}
return
} | |
c10771 | nil {
return v.Vertwo2000
}
return
} | |
c10772 | nil {
return v.ASet2500
}
return
} | |
c10773 | nil {
return v.Vertwo3000
}
return
} | |
c10774 | {
return v.BigNumbers
}
return
} | |
c10775 |
if v.Bonk != nil {
fields[i] = fmt.Sprintf("Bonk: %v", v.Bonk)
i++
}
return fmt.Sprintf("ListBonks{%v}", strings.Join(fields[:i], ", "))
} | |
c10776 |
}
if !((v.Bonk == nil && rhs.Bonk == nil) || (v.Bonk != nil && rhs.Bonk != nil && _List_Bonk_Equals(v.Bonk, rhs.Bonk))) {
return false
}
return true
} | |
c10777 | enc.AddArray("bonk", (_List_Bonk_Zapper)(v.Bonk)))
}
return err
} | |
c10778 | = fmt.Sprintf("Hello: %v", *(v.Hello))
i++
}
return fmt.Sprintf("ListTypeVersioningV1{%v}", strings.Join(fields[:i], ", "))
} | |
c10779 | == 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
} | |
c10780 | multierr.Append(err, enc.AddArray("myints", (_List_I32_Zapper)(v.Myints)))
}
if v.Hello != nil {
enc.AddString("hello", *v.Hello)
}
return err
} | |
c10781 | nil {
return v.Myints
}
return
} | |
c10782 | = fmt.Sprintf("Hello: %v", *(v.Hello))
i++
}
return fmt.Sprintf("ListTypeVersioningV2{%v}", strings.Join(fields[:i], ", "))
} | |
c10783 | 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
} | |
c10784 | (err error) {
for _, v := range l {
enc.AppendString(v)
}
return err
} | |
c10785 | enc.AddArray("strings", (_List_String_Zapper)(v.Strings)))
}
if v.Hello != nil {
enc.AddString("hello", *v.Hello)
}
return err
} | |
c10786 | nil {
return v.Strings
}
return
} | |
c10787 | error) {
for k, v := range m {
err = multierr.Append(err, enc.AddObject((string)(k), v))
}
return err
} | |
c10788 | wire.NewValueMap(_Map_String_Bonk_MapItemList(x)), error(nil)
} | |
c10789 |
x := (map[string]*Bonk)(v)
return fmt.Sprint(x)
} | |
c10790 | _Map_String_Bonk_Read(w.GetMap())
*v = (MapType)(x)
return err
} | |
c10791 | _Map_String_Bonk_Equals((map[string]*Bonk)(lhs), (map[string]*Bonk)(rhs))
} | |
c10792 | && rhs.Bonk != nil && _List_List_List_Bonk_Equals(v.Bonk, rhs.Bonk))) {
return false
}
return true
} | |
c10793 | {
err = multierr.Append(err, enc.AppendArray((_List_Bonk_Zapper)(v)))
}
return err
} | |
c10794 | enc.AddArray("bonk", (_List_List_List_Bonk_Zapper)(v.Bonk)))
}
return err
} | |
c10795 | }
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
} | |
c10796 |
err = multierr.Append(err, enc.AddArray("integerlist", (_List_List_I32_Zapper)(v.Integerlist)))
}
return err
} | |
c10797 | %v", v.Integerlist)
i++
}
return fmt.Sprintf("NestedListsI32x3{%v}", strings.Join(fields[:i], ", "))
} | |
c10798 |
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
} | |
c10799 | {
for _, v := range l {
err = multierr.Append(err, enc.AppendArray((_List_List_I32_Zapper)(v)))
}
return err
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.