_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q10800 | MarshalLogObject | train | func (v *NestedListsI32x3) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.Integerlist != nil {
err = multierr.Append(err, enc.AddArray("integerlist", (_List_List_List_I32_Zapper)(v.Integerlist)))
}
return err
} | go | {
"resource": ""
} |
q10801 | String | train | func (v *NestedMixedx2) String() string {
if v == nil {
return "<nil>"
}
var fields [3]string
i := 0
if v.IntSetList != nil {
fields[i] = fmt.Sprintf("IntSetList: %v", v.IntSetList)
i++
}
if v.MapIntStrset != nil {
fields[i] = fmt.Sprintf("MapIntStrset: %v", v.MapIntStrset)
i++
}
if v.MapIntStrsetList != nil {
fields[i] = fmt.Sprintf("MapIntStrsetList: %v", v.MapIntStrsetList)
i++
}
return fmt.Sprintf("NestedMixedx2{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10802 | Equals | train | func (v *NestedMixedx2) Equals(rhs *NestedMixedx2) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !((v.IntSetList == nil && rhs.IntSetList == nil) || (v.IntSetList != nil && rhs.IntSetList != nil && _List_Set_I32_Equals(v.IntSetList, rhs.IntSetList))) {
return false
}
if !((v.MapIntStrset == nil && rhs.MapIntStrset == nil) || (v.MapIntStrset != nil && rhs.MapIntStrset != nil && _Map_I32_Set_String_Equals(v.MapIntStrset, rhs.MapIntStrset))) {
return false
}
if !((v.MapIntStrsetList == nil && rhs.MapIntStrsetList == nil) || (v.MapIntStrsetList != nil && rhs.MapIntStrsetList != nil && _List_Map_I32_Set_String_Equals(v.MapIntStrsetList, rhs.MapIntStrsetList))) {
return false
}
return true
} | go | {
"resource": ""
} |
q10803 | MarshalLogArray | train | func (l _List_Set_I32_Zapper) MarshalLogArray(enc zapcore.ArrayEncoder) (err error) {
for _, v := range l {
err = multierr.Append(err, enc.AppendArray((_Set_I32_Zapper)(v)))
}
return err
} | go | {
"resource": ""
} |
q10804 | MarshalLogObject | train | func (v _Map_I32_Set_String_Item_Zapper) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
enc.AddInt32("key", v.Key)
err = multierr.Append(err, enc.AddArray("value", (_Set_String_Zapper)(v.Value)))
return err
} | go | {
"resource": ""
} |
q10805 | MarshalLogArray | train | func (m _Map_I32_Set_String_Zapper) MarshalLogArray(enc zapcore.ArrayEncoder) (err error) {
for k, v := range m {
err = multierr.Append(err, enc.AppendObject(_Map_I32_Set_String_Item_Zapper{Key: k, Value: v}))
}
return err
} | go | {
"resource": ""
} |
q10806 | MarshalLogArray | train | func (l _List_Map_I32_Set_String_Zapper) MarshalLogArray(enc zapcore.ArrayEncoder) (err error) {
for _, v := range l {
err = multierr.Append(err, enc.AppendArray((_Map_I32_Set_String_Zapper)(v)))
}
return err
} | go | {
"resource": ""
} |
q10807 | MarshalLogObject | train | func (v *NestedMixedx2) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.IntSetList != nil {
err = multierr.Append(err, enc.AddArray("int_set_list", (_List_Set_I32_Zapper)(v.IntSetList)))
}
if v.MapIntStrset != nil {
err = multierr.Append(err, enc.AddArray("map_int_strset", (_Map_I32_Set_String_Zapper)(v.MapIntStrset)))
}
if v.MapIntStrsetList != nil {
err = multierr.Append(err, enc.AddArray("map_int_strset_list", (_List_Map_I32_Set_String_Zapper)(v.MapIntStrsetList)))
}
return err
} | go | {
"resource": ""
} |
q10808 | GetIntSetList | train | func (v *NestedMixedx2) GetIntSetList() (o []map[int32]struct{}) {
if v != nil && v.IntSetList != nil {
return v.IntSetList
}
return
} | go | {
"resource": ""
} |
q10809 | GetMapIntStrset | train | func (v *NestedMixedx2) GetMapIntStrset() (o map[int32]map[string]struct{}) {
if v != nil && v.MapIntStrset != nil {
return v.MapIntStrset
}
return
} | go | {
"resource": ""
} |
q10810 | GetMapIntStrsetList | train | func (v *NestedMixedx2) GetMapIntStrsetList() (o []map[int32]map[string]struct{}) {
if v != nil && v.MapIntStrsetList != nil {
return v.MapIntStrsetList
}
return
} | go | {
"resource": ""
} |
q10811 | MarshalLogObject | train | func (v Numberz) MarshalLogObject(enc zapcore.ObjectEncoder) error {
enc.AddInt32("value", int32(v))
switch int32(v) {
case 1:
enc.AddString("name", "ONE")
case 2:
enc.AddString("name", "TWO")
case 3:
enc.AddString("name", "THREE")
case 5:
enc.AddString("name", "FIVE")
case 6:
enc.AddString("name", "SIX")
case 8:
enc.AddString("name", "EIGHT")
}
return nil
} | go | {
"resource": ""
} |
q10812 | String | train | func (v Numberz) String() string {
w := int32(v)
switch w {
case 1:
return "ONE"
case 2:
return "TWO"
case 3:
return "THREE"
case 5:
return "FIVE"
case 6:
return "SIX"
case 8:
return "EIGHT"
}
return fmt.Sprintf("Numberz(%d)", w)
} | go | {
"resource": ""
} |
q10813 | UnmarshalJSON | train | func (v *Numberz) UnmarshalJSON(text []byte) error {
d := json.NewDecoder(bytes.NewReader(text))
d.UseNumber()
t, err := d.Token()
if err != nil {
return err
}
switch w := t.(type) {
case json.Number:
x, err := w.Int64()
if err != nil {
return err
}
if x > math.MaxInt32 {
return fmt.Errorf("enum overflow from JSON %q for %q", text, "Numberz")
}
if x < math.MinInt32 {
return fmt.Errorf("enum underflow from JSON %q for %q", text, "Numberz")
}
*v = (Numberz)(x)
return nil
case string:
return v.UnmarshalText([]byte(w))
default:
return fmt.Errorf("invalid JSON value %q (%T) to unmarshal into %q", t, t, "Numberz")
}
} | go | {
"resource": ""
} |
q10814 | String | train | func (v *OneField) String() string {
if v == nil {
return "<nil>"
}
var fields [1]string
i := 0
if v.Field != nil {
fields[i] = fmt.Sprintf("Field: %v", v.Field)
i++
}
return fmt.Sprintf("OneField{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10815 | Equals | train | func (v *OneField) Equals(rhs *OneField) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !((v.Field == nil && rhs.Field == nil) || (v.Field != nil && rhs.Field != nil && v.Field.Equals(rhs.Field))) {
return false
}
return true
} | go | {
"resource": ""
} |
q10816 | MarshalLogObject | train | func (v *OneField) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.Field != nil {
err = multierr.Append(err, enc.AddObject("field", v.Field))
}
return err
} | go | {
"resource": ""
} |
q10817 | GetField | train | func (v *OneField) GetField() (o *EmptyStruct) {
if v != nil && v.Field != nil {
return v.Field
}
return
} | go | {
"resource": ""
} |
q10818 | String | train | func (v *StructA) String() string {
if v == nil {
return "<nil>"
}
var fields [1]string
i := 0
fields[i] = fmt.Sprintf("S: %v", v.S)
i++
return fmt.Sprintf("StructA{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10819 | Equals | train | func (v *StructA) Equals(rhs *StructA) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !(v.S == rhs.S) {
return false
}
return true
} | go | {
"resource": ""
} |
q10820 | MarshalLogObject | train | func (v *StructA) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
enc.AddString("s", v.S)
return err
} | go | {
"resource": ""
} |
q10821 | GetS | train | func (v *StructA) GetS() (o string) {
if v != nil {
o = v.S
}
return
} | go | {
"resource": ""
} |
q10822 | String | train | func (v *StructB) String() string {
if v == nil {
return "<nil>"
}
var fields [2]string
i := 0
if v.Aa != nil {
fields[i] = fmt.Sprintf("Aa: %v", v.Aa)
i++
}
fields[i] = fmt.Sprintf("Ab: %v", v.Ab)
i++
return fmt.Sprintf("StructB{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10823 | Equals | train | func (v *StructB) Equals(rhs *StructB) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !((v.Aa == nil && rhs.Aa == nil) || (v.Aa != nil && rhs.Aa != nil && v.Aa.Equals(rhs.Aa))) {
return false
}
if !v.Ab.Equals(rhs.Ab) {
return false
}
return true
} | go | {
"resource": ""
} |
q10824 | MarshalLogObject | train | func (v *StructB) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.Aa != nil {
err = multierr.Append(err, enc.AddObject("aa", v.Aa))
}
err = multierr.Append(err, enc.AddObject("ab", v.Ab))
return err
} | go | {
"resource": ""
} |
q10825 | GetAa | train | func (v *StructB) GetAa() (o *StructA) {
if v != nil && v.Aa != nil {
return v.Aa
}
return
} | go | {
"resource": ""
} |
q10826 | GetAb | train | func (v *StructB) GetAb() (o *StructA) {
if v != nil {
o = v.Ab
}
return
} | go | {
"resource": ""
} |
q10827 | ToWire | train | func (v UserId) ToWire() (wire.Value, error) {
x := (int64)(v)
return wire.NewValueI64(x), error(nil)
} | go | {
"resource": ""
} |
q10828 | String | train | func (v UserId) String() string {
x := (int64)(v)
return fmt.Sprint(x)
} | go | {
"resource": ""
} |
q10829 | FromWire | train | func (v *UserId) FromWire(w wire.Value) error {
x, err := w.GetI64(), error(nil)
*v = (UserId)(x)
return err
} | go | {
"resource": ""
} |
q10830 | Equals | train | func (lhs UserId) Equals(rhs UserId) bool {
return ((int64)(lhs) == (int64)(rhs))
} | go | {
"resource": ""
} |
q10831 | String | train | func (v *VersioningTestV1) String() string {
if v == nil {
return "<nil>"
}
var fields [3]string
i := 0
if v.BeginInBoth != nil {
fields[i] = fmt.Sprintf("BeginInBoth: %v", *(v.BeginInBoth))
i++
}
if v.OldString != nil {
fields[i] = fmt.Sprintf("OldString: %v", *(v.OldString))
i++
}
if v.EndInBoth != nil {
fields[i] = fmt.Sprintf("EndInBoth: %v", *(v.EndInBoth))
i++
}
return fmt.Sprintf("VersioningTestV1{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10832 | Equals | train | func (v *VersioningTestV1) Equals(rhs *VersioningTestV1) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !_I32_EqualsPtr(v.BeginInBoth, rhs.BeginInBoth) {
return false
}
if !_String_EqualsPtr(v.OldString, rhs.OldString) {
return false
}
if !_I32_EqualsPtr(v.EndInBoth, rhs.EndInBoth) {
return false
}
return true
} | go | {
"resource": ""
} |
q10833 | MarshalLogObject | train | func (v *VersioningTestV1) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.BeginInBoth != nil {
enc.AddInt32("begin_in_both", *v.BeginInBoth)
}
if v.OldString != nil {
enc.AddString("old_string", *v.OldString)
}
if v.EndInBoth != nil {
enc.AddInt32("end_in_both", *v.EndInBoth)
}
return err
} | go | {
"resource": ""
} |
q10834 | GetOldString | train | func (v *VersioningTestV1) GetOldString() (o string) {
if v != nil && v.OldString != nil {
return *v.OldString
}
return
} | go | {
"resource": ""
} |
q10835 | String | train | func (v *VersioningTestV2) String() string {
if v == nil {
return "<nil>"
}
var fields [12]string
i := 0
if v.BeginInBoth != nil {
fields[i] = fmt.Sprintf("BeginInBoth: %v", *(v.BeginInBoth))
i++
}
if v.Newint != nil {
fields[i] = fmt.Sprintf("Newint: %v", *(v.Newint))
i++
}
if v.Newbyte != nil {
fields[i] = fmt.Sprintf("Newbyte: %v", *(v.Newbyte))
i++
}
if v.Newshort != nil {
fields[i] = fmt.Sprintf("Newshort: %v", *(v.Newshort))
i++
}
if v.Newlong != nil {
fields[i] = fmt.Sprintf("Newlong: %v", *(v.Newlong))
i++
}
if v.Newdouble != nil {
fields[i] = fmt.Sprintf("Newdouble: %v", *(v.Newdouble))
i++
}
if v.Newstruct != nil {
fields[i] = fmt.Sprintf("Newstruct: %v", v.Newstruct)
i++
}
if v.Newlist != nil {
fields[i] = fmt.Sprintf("Newlist: %v", v.Newlist)
i++
}
if v.Newset != nil {
fields[i] = fmt.Sprintf("Newset: %v", v.Newset)
i++
}
if v.Newmap != nil {
fields[i] = fmt.Sprintf("Newmap: %v", v.Newmap)
i++
}
if v.Newstring != nil {
fields[i] = fmt.Sprintf("Newstring: %v", *(v.Newstring))
i++
}
if v.EndInBoth != nil {
fields[i] = fmt.Sprintf("EndInBoth: %v", *(v.EndInBoth))
i++
}
return fmt.Sprintf("VersioningTestV2{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10836 | Equals | train | func (v *VersioningTestV2) Equals(rhs *VersioningTestV2) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !_I32_EqualsPtr(v.BeginInBoth, rhs.BeginInBoth) {
return false
}
if !_I32_EqualsPtr(v.Newint, rhs.Newint) {
return false
}
if !_Byte_EqualsPtr(v.Newbyte, rhs.Newbyte) {
return false
}
if !_I16_EqualsPtr(v.Newshort, rhs.Newshort) {
return false
}
if !_I64_EqualsPtr(v.Newlong, rhs.Newlong) {
return false
}
if !_Double_EqualsPtr(v.Newdouble, rhs.Newdouble) {
return false
}
if !((v.Newstruct == nil && rhs.Newstruct == nil) || (v.Newstruct != nil && rhs.Newstruct != nil && v.Newstruct.Equals(rhs.Newstruct))) {
return false
}
if !((v.Newlist == nil && rhs.Newlist == nil) || (v.Newlist != nil && rhs.Newlist != nil && _List_I32_Equals(v.Newlist, rhs.Newlist))) {
return false
}
if !((v.Newset == nil && rhs.Newset == nil) || (v.Newset != nil && rhs.Newset != nil && _Set_I32_Equals(v.Newset, rhs.Newset))) {
return false
}
if !((v.Newmap == nil && rhs.Newmap == nil) || (v.Newmap != nil && rhs.Newmap != nil && _Map_I32_I32_Equals(v.Newmap, rhs.Newmap))) {
return false
}
if !_String_EqualsPtr(v.Newstring, rhs.Newstring) {
return false
}
if !_I32_EqualsPtr(v.EndInBoth, rhs.EndInBoth) {
return false
}
return true
} | go | {
"resource": ""
} |
q10837 | MarshalLogObject | train | func (v _Map_I32_I32_Item_Zapper) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
enc.AddInt32("key", v.Key)
enc.AddInt32("value", v.Value)
return err
} | go | {
"resource": ""
} |
q10838 | MarshalLogArray | train | func (m _Map_I32_I32_Zapper) MarshalLogArray(enc zapcore.ArrayEncoder) (err error) {
for k, v := range m {
err = multierr.Append(err, enc.AppendObject(_Map_I32_I32_Item_Zapper{Key: k, Value: v}))
}
return err
} | go | {
"resource": ""
} |
q10839 | MarshalLogObject | train | func (v *VersioningTestV2) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.BeginInBoth != nil {
enc.AddInt32("begin_in_both", *v.BeginInBoth)
}
if v.Newint != nil {
enc.AddInt32("newint", *v.Newint)
}
if v.Newbyte != nil {
enc.AddInt8("newbyte", *v.Newbyte)
}
if v.Newshort != nil {
enc.AddInt16("newshort", *v.Newshort)
}
if v.Newlong != nil {
enc.AddInt64("newlong", *v.Newlong)
}
if v.Newdouble != nil {
enc.AddFloat64("newdouble", *v.Newdouble)
}
if v.Newstruct != nil {
err = multierr.Append(err, enc.AddObject("newstruct", v.Newstruct))
}
if v.Newlist != nil {
err = multierr.Append(err, enc.AddArray("newlist", (_List_I32_Zapper)(v.Newlist)))
}
if v.Newset != nil {
err = multierr.Append(err, enc.AddArray("newset", (_Set_I32_Zapper)(v.Newset)))
}
if v.Newmap != nil {
err = multierr.Append(err, enc.AddArray("newmap", (_Map_I32_I32_Zapper)(v.Newmap)))
}
if v.Newstring != nil {
enc.AddString("newstring", *v.Newstring)
}
if v.EndInBoth != nil {
enc.AddInt32("end_in_both", *v.EndInBoth)
}
return err
} | go | {
"resource": ""
} |
q10840 | GetNewint | train | func (v *VersioningTestV2) GetNewint() (o int32) {
if v != nil && v.Newint != nil {
return *v.Newint
}
return
} | go | {
"resource": ""
} |
q10841 | GetNewbyte | train | func (v *VersioningTestV2) GetNewbyte() (o int8) {
if v != nil && v.Newbyte != nil {
return *v.Newbyte
}
return
} | go | {
"resource": ""
} |
q10842 | GetNewshort | train | func (v *VersioningTestV2) GetNewshort() (o int16) {
if v != nil && v.Newshort != nil {
return *v.Newshort
}
return
} | go | {
"resource": ""
} |
q10843 | GetNewlong | train | func (v *VersioningTestV2) GetNewlong() (o int64) {
if v != nil && v.Newlong != nil {
return *v.Newlong
}
return
} | go | {
"resource": ""
} |
q10844 | GetNewdouble | train | func (v *VersioningTestV2) GetNewdouble() (o float64) {
if v != nil && v.Newdouble != nil {
return *v.Newdouble
}
return
} | go | {
"resource": ""
} |
q10845 | GetNewstruct | train | func (v *VersioningTestV2) GetNewstruct() (o *Bonk) {
if v != nil && v.Newstruct != nil {
return v.Newstruct
}
return
} | go | {
"resource": ""
} |
q10846 | GetNewlist | train | func (v *VersioningTestV2) GetNewlist() (o []int32) {
if v != nil && v.Newlist != nil {
return v.Newlist
}
return
} | go | {
"resource": ""
} |
q10847 | GetNewset | train | func (v *VersioningTestV2) GetNewset() (o map[int32]struct{}) {
if v != nil && v.Newset != nil {
return v.Newset
}
return
} | go | {
"resource": ""
} |
q10848 | GetNewmap | train | func (v *VersioningTestV2) GetNewmap() (o map[int32]int32) {
if v != nil && v.Newmap != nil {
return v.Newmap
}
return
} | go | {
"resource": ""
} |
q10849 | GetNewstring | train | func (v *VersioningTestV2) GetNewstring() (o string) {
if v != nil && v.Newstring != nil {
return *v.Newstring
}
return
} | go | {
"resource": ""
} |
q10850 | String | train | func (v *Xception) String() string {
if v == nil {
return "<nil>"
}
var fields [2]string
i := 0
if v.ErrorCode != nil {
fields[i] = fmt.Sprintf("ErrorCode: %v", *(v.ErrorCode))
i++
}
if v.Message != nil {
fields[i] = fmt.Sprintf("Message: %v", *(v.Message))
i++
}
return fmt.Sprintf("Xception{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10851 | Equals | train | func (v *Xception) Equals(rhs *Xception) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !_I32_EqualsPtr(v.ErrorCode, rhs.ErrorCode) {
return false
}
if !_String_EqualsPtr(v.Message, rhs.Message) {
return false
}
return true
} | go | {
"resource": ""
} |
q10852 | MarshalLogObject | train | func (v *Xception) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.ErrorCode != nil {
enc.AddInt32("errorCode", *v.ErrorCode)
}
if v.Message != nil {
enc.AddString("message", *v.Message)
}
return err
} | go | {
"resource": ""
} |
q10853 | String | train | func (v *Xception2) String() string {
if v == nil {
return "<nil>"
}
var fields [2]string
i := 0
if v.ErrorCode != nil {
fields[i] = fmt.Sprintf("ErrorCode: %v", *(v.ErrorCode))
i++
}
if v.StructThing != nil {
fields[i] = fmt.Sprintf("StructThing: %v", v.StructThing)
i++
}
return fmt.Sprintf("Xception2{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10854 | Equals | train | func (v *Xception2) Equals(rhs *Xception2) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !_I32_EqualsPtr(v.ErrorCode, rhs.ErrorCode) {
return false
}
if !((v.StructThing == nil && rhs.StructThing == nil) || (v.StructThing != nil && rhs.StructThing != nil && v.StructThing.Equals(rhs.StructThing))) {
return false
}
return true
} | go | {
"resource": ""
} |
q10855 | MarshalLogObject | train | func (v *Xception2) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.ErrorCode != nil {
enc.AddInt32("errorCode", *v.ErrorCode)
}
if v.StructThing != nil {
err = multierr.Append(err, enc.AddObject("struct_thing", v.StructThing))
}
return err
} | go | {
"resource": ""
} |
q10856 | String | train | func (v *Xtruct) String() string {
if v == nil {
return "<nil>"
}
var fields [4]string
i := 0
if v.StringThing != nil {
fields[i] = fmt.Sprintf("StringThing: %v", *(v.StringThing))
i++
}
if v.ByteThing != nil {
fields[i] = fmt.Sprintf("ByteThing: %v", *(v.ByteThing))
i++
}
if v.I32Thing != nil {
fields[i] = fmt.Sprintf("I32Thing: %v", *(v.I32Thing))
i++
}
if v.I64Thing != nil {
fields[i] = fmt.Sprintf("I64Thing: %v", *(v.I64Thing))
i++
}
return fmt.Sprintf("Xtruct{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10857 | Equals | train | func (v *Xtruct) Equals(rhs *Xtruct) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !_String_EqualsPtr(v.StringThing, rhs.StringThing) {
return false
}
if !_Byte_EqualsPtr(v.ByteThing, rhs.ByteThing) {
return false
}
if !_I32_EqualsPtr(v.I32Thing, rhs.I32Thing) {
return false
}
if !_I64_EqualsPtr(v.I64Thing, rhs.I64Thing) {
return false
}
return true
} | go | {
"resource": ""
} |
q10858 | MarshalLogObject | train | func (v *Xtruct) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.StringThing != nil {
enc.AddString("string_thing", *v.StringThing)
}
if v.ByteThing != nil {
enc.AddInt8("byte_thing", *v.ByteThing)
}
if v.I32Thing != nil {
enc.AddInt32("i32_thing", *v.I32Thing)
}
if v.I64Thing != nil {
enc.AddInt64("i64_thing", *v.I64Thing)
}
return err
} | go | {
"resource": ""
} |
q10859 | String | train | func (v *Xtruct2) String() string {
if v == nil {
return "<nil>"
}
var fields [3]string
i := 0
if v.ByteThing != nil {
fields[i] = fmt.Sprintf("ByteThing: %v", *(v.ByteThing))
i++
}
if v.StructThing != nil {
fields[i] = fmt.Sprintf("StructThing: %v", v.StructThing)
i++
}
if v.I32Thing != nil {
fields[i] = fmt.Sprintf("I32Thing: %v", *(v.I32Thing))
i++
}
return fmt.Sprintf("Xtruct2{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10860 | Equals | train | func (v *Xtruct2) Equals(rhs *Xtruct2) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !_Byte_EqualsPtr(v.ByteThing, rhs.ByteThing) {
return false
}
if !((v.StructThing == nil && rhs.StructThing == nil) || (v.StructThing != nil && rhs.StructThing != nil && v.StructThing.Equals(rhs.StructThing))) {
return false
}
if !_I32_EqualsPtr(v.I32Thing, rhs.I32Thing) {
return false
}
return true
} | go | {
"resource": ""
} |
q10861 | MarshalLogObject | train | func (v *Xtruct2) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.ByteThing != nil {
enc.AddInt8("byte_thing", *v.ByteThing)
}
if v.StructThing != nil {
err = multierr.Append(err, enc.AddObject("struct_thing", v.StructThing))
}
if v.I32Thing != nil {
enc.AddInt32("i32_thing", *v.I32Thing)
}
return err
} | go | {
"resource": ""
} |
q10862 | String | train | func (v *Xtruct3) String() string {
if v == nil {
return "<nil>"
}
var fields [4]string
i := 0
if v.StringThing != nil {
fields[i] = fmt.Sprintf("StringThing: %v", *(v.StringThing))
i++
}
if v.Changed != nil {
fields[i] = fmt.Sprintf("Changed: %v", *(v.Changed))
i++
}
if v.I32Thing != nil {
fields[i] = fmt.Sprintf("I32Thing: %v", *(v.I32Thing))
i++
}
if v.I64Thing != nil {
fields[i] = fmt.Sprintf("I64Thing: %v", *(v.I64Thing))
i++
}
return fmt.Sprintf("Xtruct3{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10863 | Equals | train | func (v *Xtruct3) Equals(rhs *Xtruct3) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !_String_EqualsPtr(v.StringThing, rhs.StringThing) {
return false
}
if !_I32_EqualsPtr(v.Changed, rhs.Changed) {
return false
}
if !_I32_EqualsPtr(v.I32Thing, rhs.I32Thing) {
return false
}
if !_I64_EqualsPtr(v.I64Thing, rhs.I64Thing) {
return false
}
return true
} | go | {
"resource": ""
} |
q10864 | MarshalLogObject | train | func (v *Xtruct3) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.StringThing != nil {
enc.AddString("string_thing", *v.StringThing)
}
if v.Changed != nil {
enc.AddInt32("changed", *v.Changed)
}
if v.I32Thing != nil {
enc.AddInt32("i32_thing", *v.I32Thing)
}
if v.I64Thing != nil {
enc.AddInt64("i64_thing", *v.I64Thing)
}
return err
} | go | {
"resource": ""
} |
q10865 | GetChanged | train | func (v *Xtruct3) GetChanged() (o int32) {
if v != nil && v.Changed != nil {
return *v.Changed
}
return
} | go | {
"resource": ""
} |
q10866 | Run | train | func Run(t crossdock.T) {
fatals := crossdock.Fatals(t)
server := t.Param(params.Server)
fatals.NotEmpty(server, "server is required")
dispatcher := yarpc.NewDispatcher(yarpc.Config{
Name: "client",
Outbounds: yarpc.Outbounds{
"yarpc-test": {
Unary: grpc.NewTransport().NewSingleOutbound(fmt.Sprintf("%s:8090", server)),
},
},
})
fatals.NoError(dispatcher.Start(), "could not start Dispatcher")
defer dispatcher.Stop()
client := crossdockpb.NewEchoYARPCClient(dispatcher.ClientConfig("yarpc-test"))
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
token := random.String(5)
pong, err := client.Echo(ctx, &crossdockpb.Ping{Beep: token})
crossdock.Fatals(t).NoError(err, "call to Echo::echo failed: %v", err)
crossdock.Assert(t).Equal(token, pong.Boop, "server said: %v", pong.Boop)
} | go | {
"resource": ""
} |
q10867 | TransportSpec | train | func TransportSpec(opts ...Option) yarpcconfig.TransportSpec {
transportSpec, err := newTransportSpec(opts...)
if err != nil {
panic(err.Error())
}
return yarpcconfig.TransportSpec{
Name: transportName,
BuildTransport: transportSpec.buildTransport,
BuildInbound: transportSpec.buildInbound,
BuildUnaryOutbound: transportSpec.buildUnaryOutbound,
BuildStreamOutbound: transportSpec.buildStreamOutbound,
}
} | go | {
"resource": ""
} |
q10868 | JSON | train | func JSON(t crossdock.T, dispatcher *yarpc.Dispatcher, serverCalledBack <-chan []byte, callBackAddr string) {
assert := crossdock.Assert(t)
fatals := crossdock.Fatals(t)
client := json.New(dispatcher.ClientConfig("oneway-server"))
token := getRandomID()
ctx, cancel := context.WithTimeout(context.Background(), time.Second)
defer cancel()
ack, err := client.CallOneway(
ctx,
"echo/json",
&jsonToken{Token: token},
yarpc.WithHeader("callBackAddr", callBackAddr),
)
// ensure channel hasn't been filled yet
select {
case <-serverCalledBack:
fatals.FailNow("oneway json test failed", "client waited for server to fill channel")
default:
}
fatals.NoError(err, "call to oneway/json failed: %v", err)
fatals.NotNil(ack, "ack is nil")
serverToken := <-serverCalledBack
assert.Equal(token, string(serverToken), "JSON token mismatch")
} | go | {
"resource": ""
} |
q10869 | Run | train | func Run(t crossdock.T) {
callBackHandler, serverCalledBack := newCallBackHandler()
dispatcher, callBackAddr := dispatcher.CreateOnewayDispatcher(t, callBackHandler)
defer dispatcher.Stop()
encoding := t.Param(params.Encoding)
switch encoding {
case "raw":
Raw(t, dispatcher, serverCalledBack, callBackAddr)
case "json":
JSON(t, dispatcher, serverCalledBack, callBackAddr)
case "thrift":
Thrift(t, dispatcher, serverCalledBack, callBackAddr)
case "protobuf":
Protobuf(t, dispatcher, serverCalledBack, callBackAddr)
default:
crossdock.Fatals(t).Fail("unknown encoding", "%v", encoding)
}
} | go | {
"resource": ""
} |
q10870 | newCallBackHandler | train | func newCallBackHandler() (raw.OnewayHandler, <-chan []byte) {
serverCalledBack := make(chan []byte)
return func(ctx context.Context, body []byte) error {
serverCalledBack <- body
return nil
}, serverCalledBack
} | go | {
"resource": ""
} |
q10871 | ToHTTPHeaders | train | func (hm headerMapper) ToHTTPHeaders(from transport.Headers, to http.Header) http.Header {
if to == nil {
to = make(http.Header, from.Len())
}
for k, v := range from.Items() {
to.Add(hm.Prefix+k, v)
}
return to
} | go | {
"resource": ""
} |
q10872 | FromHTTPHeaders | train | func (hm headerMapper) FromHTTPHeaders(from http.Header, to transport.Headers) transport.Headers {
prefixLen := len(hm.Prefix)
for k := range from {
if strings.HasPrefix(k, hm.Prefix) {
key := k[prefixLen:]
to = to.With(key, from.Get(k))
}
// Note: undefined behavior for multiple occurrences of the same header
}
return to
} | go | {
"resource": ""
} |
q10873 | ReleasePeer | train | func (t *Transport) ReleasePeer(pid peer.Identifier, sub peer.Subscriber) error {
t.lock.Lock()
defer t.lock.Unlock()
p, ok := t.peers[pid.Identifier()]
if !ok {
return peer.ErrTransportHasNoReferenceToPeer{
TransportName: "tchannel.Transport",
PeerIdentifier: pid.Identifier(),
}
}
if err := p.Unsubscribe(sub); err != nil {
return err
}
if p.NumSubscribers() == 0 {
// Release the peer so that the connection retention loop stops.
p.Release()
delete(t.peers, pid.Identifier())
}
return nil
} | go | {
"resource": ""
} |
q10874 | onPeerStatusChanged | train | func (t *Transport) onPeerStatusChanged(tp *tchannel.Peer) {
t.lock.Lock()
defer t.lock.Unlock()
p, ok := t.peers[tp.HostPort()]
if !ok {
return
}
p.OnStatusChanged()
} | go | {
"resource": ""
} |
q10875 | Equals | train | func (v *Echo_Echo_Args) Equals(rhs *Echo_Echo_Args) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !((v.Ping == nil && rhs.Ping == nil) || (v.Ping != nil && rhs.Ping != nil && v.Ping.Equals(rhs.Ping))) {
return false
}
return true
} | go | {
"resource": ""
} |
q10876 | MarshalLogObject | train | func (v *Echo_Echo_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.Ping != nil {
err = multierr.Append(err, enc.AddObject("ping", v.Ping))
}
return err
} | go | {
"resource": ""
} |
q10877 | GetPing | train | func (v *Echo_Echo_Args) GetPing() (o *Ping) {
if v != nil && v.Ping != nil {
return v.Ping
}
return
} | go | {
"resource": ""
} |
q10878 | String | train | func (v *Echo_Echo_Result) String() string {
if v == nil {
return "<nil>"
}
var fields [1]string
i := 0
if v.Success != nil {
fields[i] = fmt.Sprintf("Success: %v", v.Success)
i++
}
return fmt.Sprintf("Echo_Echo_Result{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10879 | NewPeer | train | func NewPeer(pid PeerIdentifier, transport peer.Transport) *Peer {
p := &Peer{
PeerIdentifier: pid,
transport: transport,
subscribers: make(map[peer.Subscriber]struct{}),
}
p.connectionStatus.Store(int32(peer.Unavailable))
return p
} | go | {
"resource": ""
} |
q10880 | Subscribe | train | func (p *Peer) Subscribe(sub peer.Subscriber) {
p.lock.Lock()
p.subscribers[sub] = struct{}{}
p.lock.Unlock()
} | go | {
"resource": ""
} |
q10881 | Unsubscribe | train | func (p *Peer) Unsubscribe(sub peer.Subscriber) error {
p.lock.Lock()
defer p.lock.Unlock()
if _, ok := p.subscribers[sub]; !ok {
return peer.ErrPeerHasNoReferenceToSubscriber{
PeerIdentifier: p.PeerIdentifier,
PeerSubscriber: sub,
}
}
delete(p.subscribers, sub)
return nil
} | go | {
"resource": ""
} |
q10882 | NumSubscribers | train | func (p *Peer) NumSubscribers() int {
p.lock.RLock()
subs := len(p.subscribers)
p.lock.RUnlock()
return subs
} | go | {
"resource": ""
} |
q10883 | Status | train | func (p *Peer) Status() peer.Status {
return peer.Status{
PendingRequestCount: int(p.pending.Load()),
ConnectionStatus: peer.ConnectionStatus(p.connectionStatus.Load()),
}
} | go | {
"resource": ""
} |
q10884 | Run | train | func Run(t crossdock.T) {
fatals := crossdock.Fatals(t)
encoding := t.Param(params.Encoding)
server := t.Param(params.Server)
serverHostPort := fmt.Sprintf("%v:%v", server, serverPort)
tchannelTransport, err := tchannel.NewChannelTransport(tchannel.ServiceName("yarpc-client"))
fatals.NoError(err, "Failed to build ChannelTransport")
dispatcher := yarpc.NewDispatcher(yarpc.Config{
Name: "yarpc-client",
Outbounds: yarpc.Outbounds{
serverName: {
Unary: tchannelTransport.NewSingleOutbound(serverHostPort),
},
},
})
fatals.NoError(dispatcher.Start(), "could not start Dispatcher")
defer dispatcher.Stop()
switch encoding {
case "raw":
runRaw(t, dispatcher)
case "json":
runJSON(t, dispatcher)
case "thrift":
runThrift(t, dispatcher)
default:
fatals.Fail("", "unknown encoding %q", encoding)
}
} | go | {
"resource": ""
} |
q10885 | checkServiceMatch | train | func checkServiceMatch(reqSvcName string, responseMD metadata.MD) (bool, string) {
if resSvcName, ok := responseMD[ServiceHeader]; ok {
return reqSvcName == resSvcName[0], resSvcName[0]
}
return true, ""
} | go | {
"resource": ""
} |
q10886 | CallFromContext | train | func CallFromContext(ctx context.Context) *Call {
if ic, ok := getInboundCall(ctx); ok {
return &Call{ic}
}
return nil
} | go | {
"resource": ""
} |
q10887 | Caller | train | func (c *Call) Caller() string {
if c == nil {
return ""
}
return c.ic.req.Caller
} | go | {
"resource": ""
} |
q10888 | Service | train | func (c *Call) Service() string {
if c == nil {
return ""
}
return c.ic.req.Service
} | go | {
"resource": ""
} |
q10889 | Transport | train | func (c *Call) Transport() string {
if c == nil {
return ""
}
return c.ic.req.Transport
} | go | {
"resource": ""
} |
q10890 | Procedure | train | func (c *Call) Procedure() string {
if c == nil {
return ""
}
return c.ic.req.Procedure
} | go | {
"resource": ""
} |
q10891 | Encoding | train | func (c *Call) Encoding() transport.Encoding {
if c == nil {
return ""
}
return c.ic.req.Encoding
} | go | {
"resource": ""
} |
q10892 | HeaderNames | train | func (c *Call) HeaderNames() []string {
if c == nil {
return nil
}
var names []string
for k := range c.ic.req.Headers.Items() {
names = append(names, k)
}
sort.Strings(names)
return names
} | go | {
"resource": ""
} |
q10893 | ShardKey | train | func (c *Call) ShardKey() string {
if c == nil {
return ""
}
return c.ic.req.ShardKey
} | go | {
"resource": ""
} |
q10894 | RoutingKey | train | func (c *Call) RoutingKey() string {
if c == nil {
return ""
}
return c.ic.req.RoutingKey
} | go | {
"resource": ""
} |
q10895 | RoutingDelegate | train | func (c *Call) RoutingDelegate() string {
if c == nil {
return ""
}
return c.ic.req.RoutingDelegate
} | go | {
"resource": ""
} |
q10896 | Run | train | func Run(t crossdock.T) {
assert := crossdock.Assert(t)
fatals := crossdock.Fatals(t)
ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
defer cancel()
dispatcher := disp.Create(t)
fatals.NoError(dispatcher.Start(), "could not start Dispatcher")
defer dispatcher.Stop()
client := raw.New(dispatcher.ClientConfig("yarpc-test"))
_, err := client.Call(ctx, "sleep/raw", nil)
fatals.Error(err, "expected a failure for timeout")
if yarpcerrors.FromError(err).Code() == yarpcerrors.CodeInvalidArgument {
t.Skipf("sleep/raw method not implemented: %v", err)
return
}
assert.Equal(yarpcerrors.CodeDeadlineExceeded, yarpcerrors.FromError(err).Code(), "is an error with code CodeDeadlineExceeded: %v", err)
} | go | {
"resource": ""
} |
q10897 | KeepAlive | train | func KeepAlive(t time.Duration) TransportOption {
return func(options *transportOptions) {
options.keepAlive = t
}
} | go | {
"resource": ""
} |
q10898 | InnocenceWindow | train | func InnocenceWindow(d time.Duration) TransportOption {
return func(options *transportOptions) {
options.innocenceWindow = d
}
} | go | {
"resource": ""
} |
q10899 | Tracer | train | func Tracer(tracer opentracing.Tracer) TransportOption {
return func(options *transportOptions) {
options.tracer = tracer
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.