_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q10500 | Subscriber | train | func (t *peerThunk) Subscriber() peer.Subscriber {
t.lock.RLock()
s := t.subscriber
t.lock.RUnlock()
return s
} | go | {
"resource": ""
} |
q10501 | String | train | func (v *Hello_Echo_Args) String() string {
if v == nil {
return "<nil>"
}
var fields [1]string
i := 0
if v.Echo != nil {
fields[i] = fmt.Sprintf("Echo: %v", v.Echo)
i++
}
return fmt.Sprintf("Hello_Echo_Args{%v}", strings.Join(fields[:i], ", "))
} | go | {
"resource": ""
} |
q10502 | Equals | train | func (v *Hello_Echo_Args) Equals(rhs *Hello_Echo_Args) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !((v.Echo == nil && rhs.Echo == nil) || (v.Echo != nil && rhs.Echo != nil && v.Echo.Equals(rhs.Echo))) {
return false
}
return true
} | go | {
"resource": ""
} |
q10503 | MarshalLogObject | train | func (v *Hello_Echo_Args) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
if v.Echo != nil {
err = multierr.Append(err, enc.AddObject("echo", v.Echo))
}
return err
} | go | {
"resource": ""
} |
q10504 | GetEcho | train | func (v *Hello_Echo_Args) GetEcho() (o *EchoRequest) {
if v != nil && v.Echo != nil {
return v.Echo
}
return
} | go | {
"resource": ""
} |
q10505 | Newf | train | func Newf(code Code, format string, args ...interface{}) *Status {
if code == CodeOK {
return nil
}
return &Status{
code: code,
message: sprintf(format, args...),
}
} | go | {
"resource": ""
} |
q10506 | FromError | train | func FromError(err error) *Status {
if err == nil {
return nil
}
if status, ok := err.(*Status); ok {
return status
}
return &Status{
code: CodeUnknown,
message: err.Error(),
}
} | go | {
"resource": ""
} |
q10507 | New | train | func New(opts ...Option) *Configurator {
c := &Configurator{
knownTransports: make(map[string]*compiledTransportSpec),
knownPeerChoosers: make(map[string]*compiledPeerChooserSpec),
knownPeerLists: make(map[string]*compiledPeerListSpec),
knownPeerListUpdaters: make(map[string]*compiledPeerListU... | go | {
"resource": ""
} |
q10508 | RegisterTransport | train | func (c *Configurator) RegisterTransport(t TransportSpec) error {
if t.Name == "" {
return errors.New("name is required")
}
spec, err := compileTransportSpec(&t)
if err != nil {
return fmt.Errorf("invalid TransportSpec for %q: %v", t.Name, err)
}
c.knownTransports[t.Name] = spec
return nil
} | go | {
"resource": ""
} |
q10509 | MustRegisterTransport | train | func (c *Configurator) MustRegisterTransport(t TransportSpec) {
if err := c.RegisterTransport(t); err != nil {
panic(err)
}
} | go | {
"resource": ""
} |
q10510 | RegisterPeerChooser | train | func (c *Configurator) RegisterPeerChooser(s PeerChooserSpec) error {
if s.Name == "" {
return errors.New("name is required")
}
spec, err := compilePeerChooserSpec(&s)
if err != nil {
return fmt.Errorf("invalid PeerChooserSpec for %q: %v", s.Name, err)
}
c.knownPeerChoosers[s.Name] = spec
return nil
} | go | {
"resource": ""
} |
q10511 | MustRegisterPeerChooser | train | func (c *Configurator) MustRegisterPeerChooser(s PeerChooserSpec) {
if err := c.RegisterPeerChooser(s); err != nil {
panic(err)
}
} | go | {
"resource": ""
} |
q10512 | RegisterPeerList | train | func (c *Configurator) RegisterPeerList(s PeerListSpec) error {
if s.Name == "" {
return errors.New("name is required")
}
spec, err := compilePeerListSpec(&s)
if err != nil {
return fmt.Errorf("invalid PeerListSpec for %q: %v", s.Name, err)
}
c.knownPeerLists[s.Name] = spec
return nil
} | go | {
"resource": ""
} |
q10513 | MustRegisterPeerList | train | func (c *Configurator) MustRegisterPeerList(s PeerListSpec) {
if err := c.RegisterPeerList(s); err != nil {
panic(err)
}
} | go | {
"resource": ""
} |
q10514 | RegisterPeerListUpdater | train | func (c *Configurator) RegisterPeerListUpdater(s PeerListUpdaterSpec) error {
if s.Name == "" {
return errors.New("name is required")
}
spec, err := compilePeerListUpdaterSpec(&s)
if err != nil {
return fmt.Errorf("invalid PeerListUpdaterSpec for %q: %v", s.Name, err)
}
c.knownPeerListUpdaters[s.Name] = spe... | go | {
"resource": ""
} |
q10515 | MustRegisterPeerListUpdater | train | func (c *Configurator) MustRegisterPeerListUpdater(s PeerListUpdaterSpec) {
if err := c.RegisterPeerListUpdater(s); err != nil {
panic(err)
}
} | go | {
"resource": ""
} |
q10516 | NewDispatcherFromYAML | train | func (c *Configurator) NewDispatcherFromYAML(serviceName string, r io.Reader) (*yarpc.Dispatcher, error) {
cfg, err := c.LoadConfigFromYAML(serviceName, r)
if err != nil {
return nil, err
}
return yarpc.NewDispatcher(cfg), nil
} | go | {
"resource": ""
} |
q10517 | NewDispatcher | train | func (c *Configurator) NewDispatcher(serviceName string, data interface{}) (*yarpc.Dispatcher, error) {
cfg, err := c.LoadConfig(serviceName, data)
if err != nil {
return nil, err
}
return yarpc.NewDispatcher(cfg), nil
} | go | {
"resource": ""
} |
q10518 | spec | train | func (c *Configurator) spec(name string) (*compiledTransportSpec, error) {
spec, ok := c.knownTransports[name]
if !ok {
return nil, fmt.Errorf("unknown transport %q", name)
}
return spec, nil
} | go | {
"resource": ""
} |
q10519 | Phone | train | func Phone(ctx context.Context, body *PhoneRequest) (*PhoneResponse, error) {
var outbound transport.UnaryOutbound
httpTransport := http.NewTransport()
tchannelTransport, err := tchannel.NewChannelTransport(tchannel.ServiceName("yarpc-test-client"))
if err != nil {
return nil, fmt.Errorf("failed to build Channel... | go | {
"resource": ""
} |
q10520 | Start | train | func Start() {
tch.Start()
yarpc.Start()
http.Start()
apachethrift.Start()
oneway.Start()
googlegrpc.Start()
} | go | {
"resource": ""
} |
q10521 | Stop | train | func Stop() {
tch.Stop()
yarpc.Stop()
http.Stop()
apachethrift.Stop()
oneway.Stop()
googlegrpc.Stop()
} | go | {
"resource": ""
} |
q10522 | AllFunctions | train | func (s *Svc) AllFunctions() []*api.Function {
var (
functions []*api.Function
added = make(map[string]struct{})
services = append([]*Svc{s}, s.Parents...)
)
for _, s := range services {
for _, f := range s.Functions {
if _, taken := added[f.ThriftName]; taken {
continue
}
functions = app... | go | {
"resource": ""
} |
q10523 | Parent | train | func (s *Svc) Parent() *api.Service {
if len(s.Parents) > 0 {
return s.Parents[0].Service
}
return nil
} | go | {
"resource": ""
} |
q10524 | ServerPackagePath | train | func (s *Svc) ServerPackagePath() string {
return fmt.Sprintf("%s/%sserver", s.Module.ImportPath, strings.ToLower(s.Name))
} | go | {
"resource": ""
} |
q10525 | ParentServerPackagePath | train | func (d *templateData) ParentServerPackagePath() string {
if len(d.Parents) == 0 {
return ""
}
return d.Parents[0].ServerPackagePath()
} | go | {
"resource": ""
} |
q10526 | ParentClientPackagePath | train | func (d *templateData) ParentClientPackagePath() string {
if len(d.Parents) == 0 {
return ""
}
return d.Parents[0].ClientPackagePath()
} | go | {
"resource": ""
} |
q10527 | Run | train | func Run(t crossdock.T) {
fatals := crossdock.Fatals(t)
server := t.Param(params.Server)
fatals.NotEmpty(server, "server is required")
clientConn, err := ggrpc.Dial(fmt.Sprintf("%s:8089", server), ggrpc.WithInsecure())
fatals.NoError(err, "grpc.Dial failed")
client := crossdockpb.NewEchoClient(clientConn)
ct... | go | {
"resource": ""
} |
q10528 | Introspect | train | func (d *Dispatcher) Introspect() introspection.DispatcherStatus {
var inbounds []introspection.InboundStatus
for _, i := range d.inbounds {
var status introspection.InboundStatus
if i, ok := i.(introspection.IntrospectableInbound); ok {
status = i.Introspect()
} else {
status = introspection.InboundStatu... | go | {
"resource": ""
} |
q10529 | NewHTTPServer | train | func NewHTTPServer(s *http.Server) *HTTPServer {
return &HTTPServer{
Server: s,
done: make(chan error, 1),
}
} | go | {
"resource": ""
} |
q10530 | Listener | train | func (h *HTTPServer) Listener() net.Listener {
h.lock.RLock()
listener := h.listener
h.lock.RUnlock()
return listener
} | go | {
"resource": ""
} |
q10531 | Shutdown | train | func (h *HTTPServer) Shutdown(ctx context.Context) error {
if h.stopped.Swap(true) {
return nil
}
wasRunning, closeErr := h.shutdownServer(ctx)
if !wasRunning {
return nil
}
serveErr := <-h.done // wait until Serve() stops
if closeErr != nil {
return closeErr
}
return serveErr
} | go | {
"resource": ""
} |
q10532 | NewDialer | train | func (t *Transport) NewDialer(options ...DialOption) *Dialer {
return &Dialer{trans: t, options: newDialOptions(options)}
} | go | {
"resource": ""
} |
q10533 | RetainPeer | train | func (d *Dialer) RetainPeer(id peer.Identifier, ps peer.Subscriber) (peer.Peer, error) {
return d.trans.retainPeer(id, d.options, ps)
} | go | {
"resource": ""
} |
q10534 | ReleasePeer | train | func (d *Dialer) ReleasePeer(id peer.Identifier, ps peer.Subscriber) error {
return d.trans.ReleasePeer(id, ps)
} | go | {
"resource": ""
} |
q10535 | GetValue | train | func (k *KeyValueYARPCServer) GetValue(ctx context.Context, request *examplepb.GetValueRequest) (*examplepb.GetValueResponse, error) {
if request == nil {
return nil, errRequestNil
}
if request.Key == "" {
return nil, errRequestKeyNil
}
k.RLock()
if value, ok := k.items[request.Key]; ok {
k.RUnlock()
var ... | go | {
"resource": ""
} |
q10536 | SetValue | train | func (k *KeyValueYARPCServer) SetValue(ctx context.Context, request *examplepb.SetValueRequest) (*examplepb.SetValueResponse, error) {
if request == nil {
return nil, errRequestNil
}
if request.Key == "" {
return nil, errRequestKeyNil
}
k.Lock()
if request.Value == "" {
delete(k.items, request.Key)
} else ... | go | {
"resource": ""
} |
q10537 | SetNextError | train | func (k *KeyValueYARPCServer) SetNextError(err error) {
k.Lock()
defer k.Unlock()
k.nextError = err
} | go | {
"resource": ""
} |
q10538 | NewSinkYARPCServer | train | func NewSinkYARPCServer(withFireDone bool) *SinkYARPCServer {
var fireDone chan struct{}
if withFireDone {
fireDone = make(chan struct{})
}
return &SinkYARPCServer{sync.RWMutex{}, make([]string, 0), fireDone}
} | go | {
"resource": ""
} |
q10539 | Fire | train | func (s *SinkYARPCServer) Fire(ctx context.Context, request *examplepb.FireRequest) error {
if request == nil {
return errRequestNil
}
if request.Value == "" {
return errRequestValueNil
}
s.Lock()
s.values = append(s.values, request.Value)
s.Unlock()
if s.fireDone == nil {
return nil
}
select {
case s.... | go | {
"resource": ""
} |
q10540 | Values | train | func (s *SinkYARPCServer) Values() []string {
s.RLock()
values := make([]string, len(s.values))
copy(values, s.values)
s.RUnlock()
return values
} | go | {
"resource": ""
} |
q10541 | WaitFireDone | train | func (s *SinkYARPCServer) WaitFireDone() error {
if s.fireDone == nil {
return nil
}
select {
case <-s.fireDone:
case <-time.After(FireDoneTimeout):
return yarpcerrors.Newf(yarpcerrors.CodeDeadlineExceeded, "fire not done after %v", FireDoneTimeout)
}
return nil
} | go | {
"resource": ""
} |
q10542 | EchoOut | train | func (f *FooYARPCServer) EchoOut(server examplepb.FooServiceEchoOutYARPCServer) (*examplepb.EchoOutResponse, error) {
var allMessages []string
call := yarpc.CallFromContext(server.Context())
for k, v := range f.expectedHeaders.Items() {
if call.Header(k) != v {
return nil, yarpcerrors.InvalidArgumentErrorf("did... | go | {
"resource": ""
} |
q10543 | EchoIn | train | func (f *FooYARPCServer) EchoIn(request *examplepb.EchoInRequest, server examplepb.FooServiceEchoInYARPCServer) error {
if request == nil {
return errRequestNil
}
if request.Message == "" {
return errRequestMessageNil
}
if request.NumResponses == 0 {
return errRequestNumResponsesNil
}
call := yarpc.CallFro... | go | {
"resource": ""
} |
q10544 | EchoBoth | train | func (f *FooYARPCServer) EchoBoth(server examplepb.FooServiceEchoBothYARPCServer) error {
call := yarpc.CallFromContext(server.Context())
for k, v := range f.expectedHeaders.Items() {
if call.Header(k) != v {
return yarpcerrors.InvalidArgumentErrorf("did not receive proper headers, missing %q:%q", k, v)
}
}
... | go | {
"resource": ""
} |
q10545 | NewOutbound | train | func (t *Transport) NewOutbound(chooser peer.Chooser) *Outbound {
return &Outbound{
once: lifecycle.NewOnce(),
transport: t,
chooser: chooser,
}
} | go | {
"resource": ""
} |
q10546 | NewSingleOutbound | train | func (t *Transport) NewSingleOutbound(addr string) *Outbound {
chooser := peerchooser.NewSingle(hostport.PeerIdentifier(addr), t)
return t.NewOutbound(chooser)
} | go | {
"resource": ""
} |
q10547 | Call | train | func (p *tchannelPeer) Call(ctx context.Context, req *transport.Request) (*transport.Response, error) {
root := p.transport.ch.RootPeers()
tp := root.GetOrAdd(p.HostPort())
return callWithPeer(ctx, req, tp, p.transport.headerCase)
} | go | {
"resource": ""
} |
q10548 | callWithPeer | train | func callWithPeer(ctx context.Context, req *transport.Request, peer *tchannel.Peer, headerCase headerCase) (*transport.Response, error) {
// NB(abg): Under the current API, the local service's name is required
// twice: once when constructing the TChannel and then again when
// constructing the RPC.
var call *tchan... | go | {
"resource": ""
} |
q10549 | Start | train | func (o *Outbound) Start() error {
return o.once.Start(o.chooser.Start)
} | go | {
"resource": ""
} |
q10550 | Stop | train | func (o *Outbound) Stop() error {
return o.once.Stop(o.chooser.Stop)
} | go | {
"resource": ""
} |
q10551 | ToName | train | func ToName(serviceName string, methodName string) string {
return fmt.Sprintf("%s::%s", serviceName, methodName)
} | go | {
"resource": ""
} |
q10552 | FromName | train | func FromName(name string) (serviceName string, methodName string) {
parts := strings.SplitN(name, "::", 2)
if len(parts) == 1 {
return parts[0], ""
}
return parts[0], parts[1]
} | go | {
"resource": ""
} |
q10553 | New | train | func New(transport peer.Transport, opts ...ListOption) *List {
cfg := defaultListConfig
for _, o := range opts {
o(&cfg)
}
plOpts := []peerlist.ListOption{
peerlist.Capacity(cfg.capacity),
}
if !cfg.shuffle {
plOpts = append(plOpts, peerlist.NoShuffle())
}
nextRandFn := nextRand(cfg.seed)
if cfg.nextRa... | go | {
"resource": ""
} |
q10554 | nextRand | train | func nextRand(seed int64) func(int) int {
r := rand.New(rand.NewSource(seed))
return func(numPeers int) int {
if numPeers == 0 {
return 0
}
return r.Intn(numPeers)
}
} | go | {
"resource": ""
} |
q10555 | String | train | func (v *ResourceDoesNotExist) String() string {
if v == nil {
return "<nil>"
}
var fields [2]string
i := 0
fields[i] = fmt.Sprintf("Key: %v", v.Key)
i++
if v.Message != nil {
fields[i] = fmt.Sprintf("Message: %v", *(v.Message))
i++
}
return fmt.Sprintf("ResourceDoesNotExist{%v}", strings.Join(fields[:... | go | {
"resource": ""
} |
q10556 | Equals | train | func (v *ResourceDoesNotExist) Equals(rhs *ResourceDoesNotExist) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !(v.Key == rhs.Key) {
return false
}
if !_String_EqualsPtr(v.Message, rhs.Message) {
return false
}
return true
} | go | {
"resource": ""
} |
q10557 | MarshalLogObject | train | func (v *ResourceDoesNotExist) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
enc.AddString("key", v.Key)
if v.Message != nil {
enc.AddString("message", *v.Message)
}
return err
} | go | {
"resource": ""
} |
q10558 | NewKeyValueYARPCClient | train | func NewKeyValueYARPCClient(clientConfig transport.ClientConfig, options ...protobuf.ClientOption) KeyValueYARPCClient {
return &_KeyValueYARPCCaller{protobuf.NewStreamClient(
protobuf.ClientParams{
ServiceName: "uber.yarpc.internal.examples.protobuf.example.KeyValue",
ClientConfig: clientConfig,
Options: ... | go | {
"resource": ""
} |
q10559 | BuildKeyValueYARPCProcedures | train | func BuildKeyValueYARPCProcedures(server KeyValueYARPCServer) []transport.Procedure {
handler := &_KeyValueYARPCHandler{server}
return protobuf.BuildProcedures(
protobuf.BuildProceduresParams{
ServiceName: "uber.yarpc.internal.examples.protobuf.example.KeyValue",
UnaryHandlerParams: []protobuf.BuildProcedures... | go | {
"resource": ""
} |
q10560 | NewSinkYARPCClient | train | func NewSinkYARPCClient(clientConfig transport.ClientConfig, options ...protobuf.ClientOption) SinkYARPCClient {
return &_SinkYARPCCaller{protobuf.NewStreamClient(
protobuf.ClientParams{
ServiceName: "uber.yarpc.internal.examples.protobuf.example.Sink",
ClientConfig: clientConfig,
Options: options,
... | go | {
"resource": ""
} |
q10561 | BuildSinkYARPCProcedures | train | func BuildSinkYARPCProcedures(server SinkYARPCServer) []transport.Procedure {
handler := &_SinkYARPCHandler{server}
return protobuf.BuildProcedures(
protobuf.BuildProceduresParams{
ServiceName: "uber.yarpc.internal.examples.protobuf.example.Sink",
UnaryHandlerParams: []protobuf.BuildProceduresUnaryHand... | go | {
"resource": ""
} |
q10562 | NewFooYARPCClient | train | func NewFooYARPCClient(clientConfig transport.ClientConfig, options ...protobuf.ClientOption) FooYARPCClient {
return &_FooYARPCCaller{protobuf.NewStreamClient(
protobuf.ClientParams{
ServiceName: "uber.yarpc.internal.examples.protobuf.example.Foo",
ClientConfig: clientConfig,
Options: options,
},
... | go | {
"resource": ""
} |
q10563 | BuildFooYARPCProcedures | train | func BuildFooYARPCProcedures(server FooYARPCServer) []transport.Procedure {
handler := &_FooYARPCHandler{server}
return protobuf.BuildProcedures(
protobuf.BuildProceduresParams{
ServiceName: "uber.yarpc.internal.examples.protobuf.example.Foo",
UnaryHandlerParams: []protobuf.BuildProceduresUnaryHandle... | go | {
"resource": ""
} |
q10564 | Seed | train | func Seed(seed int64) ListOption {
return listOptionFunc(func(options *listOptions) {
options.source = rand.NewSource(seed)
})
} | go | {
"resource": ""
} |
q10565 | Source | train | func Source(source rand.Source) ListOption {
return listOptionFunc(func(options *listOptions) {
options.source = source
})
} | go | {
"resource": ""
} |
q10566 | New | train | func New(transport peer.Transport, opts ...ListOption) *List {
options := defaultListOptions
for _, opt := range opts {
opt.apply(&options)
}
if options.source == nil {
options.source = rand.NewSource(time.Now().UnixNano())
}
plOpts := []peerlist.ListOption{
peerlist.Capacity(options.capacity),
peerlist... | go | {
"resource": ""
} |
q10567 | Submit | train | func (ew *ErrorWaiter) Submit(f func() error) {
ew.wait.Add(1)
go func() {
defer ew.wait.Done()
if err := f(); err != nil {
ew.lock.Lock()
ew.errors = append(ew.errors, err)
ew.lock.Unlock()
}
}()
} | go | {
"resource": ""
} |
q10568 | Procedure | train | func Procedure(name string, handler UnaryHandler) []transport.Procedure {
return []transport.Procedure{
{
Name: name,
HandlerSpec: transport.NewUnaryHandlerSpec(rawUnaryHandler{handler}),
},
}
} | go | {
"resource": ""
} |
q10569 | OnewayProcedure | train | func OnewayProcedure(name string, handler OnewayHandler) []transport.Procedure {
return []transport.Procedure{
{
Name: name,
HandlerSpec: transport.NewOnewayHandlerSpec(rawOnewayHandler{handler}),
},
}
} | go | {
"resource": ""
} |
q10570 | SleepRaw | train | func SleepRaw(ctx context.Context, body []byte) ([]byte, error) {
time.Sleep(1 * time.Second)
return nil, nil
} | go | {
"resource": ""
} |
q10571 | WaitForTimeoutRaw | train | func WaitForTimeoutRaw(ctx context.Context, body []byte) ([]byte, error) {
if _, ok := ctx.Deadline(); !ok {
return nil, fmt.Errorf("no deadline set in context")
}
<-ctx.Done()
return nil, ctx.Err()
} | go | {
"resource": ""
} |
q10572 | RequestBodyEncodeError | train | func RequestBodyEncodeError(req *transport.Request, err error) error {
return newClientEncodingError(req, false /*isResponse*/, false /*isHeader*/, err)
} | go | {
"resource": ""
} |
q10573 | RequestHeadersEncodeError | train | func RequestHeadersEncodeError(req *transport.Request, err error) error {
return newClientEncodingError(req, false /*isResponse*/, true /*isHeader*/, err)
} | go | {
"resource": ""
} |
q10574 | ResponseHeadersDecodeError | train | func ResponseHeadersDecodeError(req *transport.Request, err error) error {
return newClientEncodingError(req, true /*isResponse*/, true /*isHeader*/, err)
} | go | {
"resource": ""
} |
q10575 | readFromStream | train | func readFromStream(
ctx context.Context,
stream transport.Stream,
newMessage func() proto.Message,
) (proto.Message, error) {
streamMsg, err := stream.ReceiveMessage(ctx)
if err != nil {
return nil, err
}
message := newMessage()
if err := unmarshal(stream.Request().Meta.Encoding, streamMsg.Body, message); er... | go | {
"resource": ""
} |
q10576 | writeToStream | train | func writeToStream(ctx context.Context, stream transport.Stream, message proto.Message) error {
messageData, cleanup, err := marshal(stream.Request().Meta.Encoding, message)
if err != nil {
return err
}
return stream.SendMessage(
ctx,
&transport.StreamMessage{
Body: readCloser{Reader: bytes.NewReader(messa... | go | {
"resource": ""
} |
q10577 | NewHandler | train | func NewHandler(dispatcher *yarpc.Dispatcher, opts ...Option) http.HandlerFunc {
return newHandler(dispatcher, opts...).handle
} | go | {
"resource": ""
} |
q10578 | Swap | train | func (ph *peerHeap) Swap(i, j int) {
p1 := ph.peers[i]
p2 := ph.peers[j]
ph.peers[i], ph.peers[j] = ph.peers[j], ph.peers[i]
p1.idx = j
p2.idx = i
} | go | {
"resource": ""
} |
q10579 | Push | train | func (ph *peerHeap) Push(x interface{}) {
ps := x.(*peerScore)
ps.idx = len(ph.peers)
ph.peers = append(ph.peers, ps)
} | go | {
"resource": ""
} |
q10580 | Pop | train | func (ph *peerHeap) Pop() interface{} {
lastIdx := len(ph.peers) - 1
last := ph.peers[lastIdx]
ph.peers = ph.peers[:lastIdx]
return last
} | go | {
"resource": ""
} |
q10581 | Bytes | train | func Bytes(length int) []byte {
out := make([]byte, length)
if _, err := io.ReadFull(rand.Reader, out); err != nil {
panic(err)
}
return out
} | go | {
"resource": ""
} |
q10582 | String | train | func String(length int) string {
return base64.RawStdEncoding.EncodeToString(Bytes(length))[:length]
} | go | {
"resource": ""
} |
q10583 | String | train | func (c Code) String() string {
s, ok := _codeToString[c]
if ok {
return s
}
return strconv.Itoa(int(c))
} | go | {
"resource": ""
} |
q10584 | NewSingleOutbound | train | func (t *Transport) NewSingleOutbound(uri string, opts ...OutboundOption) *Outbound {
parsedURL, err := url.Parse(uri)
if err != nil {
panic(err.Error())
}
chooser := peerchooser.NewSingle(hostport.PeerIdentifier(parsedURL.Host), t)
o := t.NewOutbound(chooser)
for _, opt := range opts {
opt(o)
}
o.setURLTe... | go | {
"resource": ""
} |
q10585 | Call | train | func (o *Outbound) Call(ctx context.Context, treq *transport.Request) (*transport.Response, error) {
if treq == nil {
return nil, yarpcerrors.InvalidArgumentErrorf("request for http unary outbound was nil")
}
return o.call(ctx, treq)
} | go | {
"resource": ""
} |
q10586 | CallOneway | train | func (o *Outbound) CallOneway(ctx context.Context, treq *transport.Request) (transport.Ack, error) {
if treq == nil {
return nil, yarpcerrors.InvalidArgumentErrorf("request for http oneway outbound was nil")
}
_, err := o.call(ctx, treq)
if err != nil {
return nil, err
}
return time.Now(), nil
} | go | {
"resource": ""
} |
q10587 | checkServiceMatch | train | func checkServiceMatch(reqSvcName string, resHeaders http.Header) (bool, string) {
serviceName := resHeaders.Get(ServiceHeader)
return serviceName == "" || serviceName == reqSvcName, serviceName
} | go | {
"resource": ""
} |
q10588 | String | train | func (v *RPC) String() string {
if v == nil {
return "<nil>"
}
var fields [10]string
i := 0
fields[i] = fmt.Sprintf("SpanContext: %v", v.SpanContext)
i++
fields[i] = fmt.Sprintf("CallerName: %v", v.CallerName)
i++
fields[i] = fmt.Sprintf("ServiceName: %v", v.ServiceName)
i++
fields[i] = fmt.Sprintf("Encod... | go | {
"resource": ""
} |
q10589 | Equals | train | func (v *RPC) Equals(rhs *RPC) bool {
if v == nil {
return rhs == nil
} else if rhs == nil {
return false
}
if !bytes.Equal(v.SpanContext, rhs.SpanContext) {
return false
}
if !(v.CallerName == rhs.CallerName) {
return false
}
if !(v.ServiceName == rhs.ServiceName) {
return false
}
if !(v.Encoding =... | go | {
"resource": ""
} |
q10590 | MarshalLogObject | train | func (m _Map_String_String_Zapper) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
for k, v := range m {
enc.AddString((string)(k), v)
}
return err
} | go | {
"resource": ""
} |
q10591 | MarshalLogObject | train | func (v *RPC) MarshalLogObject(enc zapcore.ObjectEncoder) (err error) {
if v == nil {
return nil
}
enc.AddString("spanContext", base64.StdEncoding.EncodeToString(v.SpanContext))
enc.AddString("callerName", v.CallerName)
enc.AddString("serviceName", v.ServiceName)
enc.AddString("encoding", v.Encoding)
enc.AddSt... | go | {
"resource": ""
} |
q10592 | GetSpanContext | train | func (v *RPC) GetSpanContext() (o []byte) {
if v != nil {
o = v.SpanContext
}
return
} | go | {
"resource": ""
} |
q10593 | GetCallerName | train | func (v *RPC) GetCallerName() (o string) {
if v != nil {
o = v.CallerName
}
return
} | go | {
"resource": ""
} |
q10594 | GetServiceName | train | func (v *RPC) GetServiceName() (o string) {
if v != nil {
o = v.ServiceName
}
return
} | go | {
"resource": ""
} |
q10595 | GetEncoding | train | func (v *RPC) GetEncoding() (o string) {
if v != nil {
o = v.Encoding
}
return
} | go | {
"resource": ""
} |
q10596 | GetProcedure | train | func (v *RPC) GetProcedure() (o string) {
if v != nil {
o = v.Procedure
}
return
} | go | {
"resource": ""
} |
q10597 | GetHeaders | train | func (v *RPC) GetHeaders() (o map[string]string) {
if v != nil && v.Headers != nil {
return v.Headers
}
return
} | go | {
"resource": ""
} |
q10598 | GetShardKey | train | func (v *RPC) GetShardKey() (o string) {
if v != nil && v.ShardKey != nil {
return *v.ShardKey
}
return
} | go | {
"resource": ""
} |
q10599 | GetRoutingKey | train | func (v *RPC) GetRoutingKey() (o string) {
if v != nil && v.RoutingKey != nil {
return *v.RoutingKey
}
return
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.