_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q178200 | Len | test | func (l *PeerList) Len() int {
l.RLock()
defer l.RUnlock()
return l.peerHeap.Len()
} | go | {
"resource": ""
} |
q178201 | exists | test | func (l *PeerList) exists(hostPort string) (*peerScore, bool) {
l.RLock()
ps, ok := l.peersByHostPort[hostPort]
l.RUnlock()
return ps, ok
} | go | {
"resource": ""
} |
q178202 | getPeerScore | test | func (l *PeerList) getPeerScore(hostPort string) (*peerScore, uint64, bool) {
ps, ok := l.peersByHostPort[hostPort]
if !ok {
return nil, 0, false
}
return ps, ps.score, ok
} | go | {
"resource": ""
} |
q178203 | onPeerChange | test | func (l *PeerList) onPeerChange(p *Peer) {
l.RLock()
ps, psScore, ok := l.getPeerScore(p.hostPort)
sc := l.scoreCalculator
l.RUnlock()
if !ok {
return
}
newScore := sc.GetScore(ps.Peer)
if newScore == psScore {
return
}
l.Lock()
l.updatePeer(ps, newScore)
l.Unlock()
} | go | {
"resource": ""
} |
q178204 | updatePeer | test | func (l *PeerList) updatePeer(ps *peerScore, newScore uint64) {
if ps.score == newScore {
return
}
ps.score = newScore
l.peerHeap.updatePeer(ps)
} | go | {
"resource": ""
} |
q178205 | getConn | test | func (p *Peer) getConn(i int) *Connection {
inboundLen := len(p.inboundConnections)
if i < inboundLen {
return p.inboundConnections[i]
}
return p.outboundConnections[i-inboundLen]
} | go | {
"resource": ""
} |
q178206 | GetConnection | test | func (p *Peer) GetConnection(ctx context.Context) (*Connection, error) {
if activeConn, ok := p.getActiveConn(); ok {
return activeConn, nil
}
// Lock here to restrict new connection creation attempts to one goroutine
p.newConnLock.Lock()
defer p.newConnLock.Unlock()
// Check active connections again in case ... | go | {
"resource": ""
} |
q178207 | getConnectionRelay | test | func (p *Peer) getConnectionRelay(timeout time.Duration) (*Connection, error) {
if conn, ok := p.getActiveConn(); ok {
return conn, nil
}
// Lock here to restrict new connection creation attempts to one goroutine
p.newConnLock.Lock()
defer p.newConnLock.Unlock()
// Check active connections again in case someo... | go | {
"resource": ""
} |
q178208 | canRemove | test | func (p *Peer) canRemove() bool {
p.RLock()
count := len(p.inboundConnections) + len(p.outboundConnections) + int(p.scCount)
p.RUnlock()
return count == 0
} | go | {
"resource": ""
} |
q178209 | addConnection | test | func (p *Peer) addConnection(c *Connection, direction connectionDirection) error {
conns := p.connectionsFor(direction)
if c.readState() != connectionActive {
return ErrInvalidConnectionState
}
p.Lock()
*conns = append(*conns, c)
p.Unlock()
// Inform third parties that a peer gained a connection.
p.onStatu... | go | {
"resource": ""
} |
q178210 | removeConnection | test | func (p *Peer) removeConnection(connsPtr *[]*Connection, changed *Connection) bool {
conns := *connsPtr
for i, c := range conns {
if c == changed {
// Remove the connection by moving the last item forward, and slicing the list.
last := len(conns) - 1
conns[i], conns[last] = conns[last], nil
*connsPtr = ... | go | {
"resource": ""
} |
q178211 | connectionCloseStateChange | test | func (p *Peer) connectionCloseStateChange(changed *Connection) {
if changed.IsActive() {
return
}
p.Lock()
found := p.removeConnection(&p.inboundConnections, changed)
if !found {
found = p.removeConnection(&p.outboundConnections, changed)
}
p.Unlock()
if found {
p.onClosedConnRemoved(p)
// Inform thir... | go | {
"resource": ""
} |
q178212 | Connect | test | func (p *Peer) Connect(ctx context.Context) (*Connection, error) {
return p.channel.Connect(ctx, p.hostPort)
} | go | {
"resource": ""
} |
q178213 | BeginCall | test | func (p *Peer) BeginCall(ctx context.Context, serviceName, methodName string, callOptions *CallOptions) (*OutboundCall, error) {
if callOptions == nil {
callOptions = defaultCallOptions
}
callOptions.RequestState.AddSelectedPeer(p.HostPort())
if err := validateCall(ctx, serviceName, methodName, callOptions); err... | go | {
"resource": ""
} |
q178214 | NumConnections | test | func (p *Peer) NumConnections() (inbound int, outbound int) {
p.RLock()
inbound = len(p.inboundConnections)
outbound = len(p.outboundConnections)
p.RUnlock()
return inbound, outbound
} | go | {
"resource": ""
} |
q178215 | NumPendingOutbound | test | func (p *Peer) NumPendingOutbound() int {
count := 0
p.RLock()
for _, c := range p.outboundConnections {
count += c.outbound.count()
}
for _, c := range p.inboundConnections {
count += c.outbound.count()
}
p.RUnlock()
return count
} | go | {
"resource": ""
} |
q178216 | isEphemeralHostPort | test | func isEphemeralHostPort(hostPort string) bool {
return hostPort == "" || hostPort == ephemeralHostPort || strings.HasSuffix(hostPort, ":0")
} | go | {
"resource": ""
} |
q178217 | Get | test | func (h *kvHandler) Get(ctx thrift.Context, key string) (string, error) {
if err := isValidKey(key); err != nil {
return "", err
}
h.RLock()
defer h.RUnlock()
if val, ok := h.vals[key]; ok {
return val, nil
}
return "", &keyvalue.KeyNotFound{Key: key}
} | go | {
"resource": ""
} |
q178218 | Set | test | func (h *kvHandler) Set(ctx thrift.Context, key, value string) error {
if err := isValidKey(key); err != nil {
return err
}
h.Lock()
defer h.Unlock()
h.vals[key] = value
// Example of how to use response headers. Normally, these values should be passed via result structs.
ctx.SetResponseHeaders(map[string]st... | go | {
"resource": ""
} |
q178219 | ClearAll | test | func (h *kvHandler) ClearAll(ctx thrift.Context) error {
if !isAdmin(ctx) {
return &keyvalue.NotAuthorized{}
}
h.Lock()
defer h.Unlock()
h.vals = make(map[string]string)
return nil
} | go | {
"resource": ""
} |
q178220 | NewChannel | test | func NewChannel(serviceName string, opts *ChannelOptions) (*Channel, error) {
if serviceName == "" {
return nil, ErrNoServiceName
}
if opts == nil {
opts = &ChannelOptions{}
}
processName := opts.ProcessName
if processName == "" {
processName = fmt.Sprintf("%s[%d]", filepath.Base(os.Args[0]), os.Getpid())... | go | {
"resource": ""
} |
q178221 | Serve | test | func (ch *Channel) Serve(l net.Listener) error {
mutable := &ch.mutable
mutable.Lock()
defer mutable.Unlock()
if mutable.l != nil {
return errAlreadyListening
}
mutable.l = tnet.Wrap(l)
if mutable.state != ChannelClient {
return errInvalidStateForOp
}
mutable.state = ChannelListening
mutable.peerInfo.H... | go | {
"resource": ""
} |
q178222 | ListenAndServe | test | func (ch *Channel) ListenAndServe(hostPort string) error {
mutable := &ch.mutable
mutable.RLock()
if mutable.l != nil {
mutable.RUnlock()
return errAlreadyListening
}
l, err := net.Listen("tcp", hostPort)
if err != nil {
mutable.RUnlock()
return err
}
mutable.RUnlock()
return ch.Serve(l)
} | go | {
"resource": ""
} |
q178223 | Register | test | func (ch *Channel) Register(h Handler, methodName string) {
if _, ok := ch.handler.(channelHandler); !ok {
panic("can't register handler when channel configured with alternate root handler")
}
ch.GetSubChannel(ch.PeerInfo().ServiceName).Register(h, methodName)
} | go | {
"resource": ""
} |
q178224 | PeerInfo | test | func (ch *Channel) PeerInfo() LocalPeerInfo {
ch.mutable.RLock()
peerInfo := ch.mutable.peerInfo
ch.mutable.RUnlock()
return peerInfo
} | go | {
"resource": ""
} |
q178225 | GetSubChannel | test | func (ch *Channel) GetSubChannel(serviceName string, opts ...SubChannelOption) *SubChannel {
sub, added := ch.subChannels.getOrAdd(serviceName, ch)
if added {
for _, opt := range opts {
opt(sub)
}
}
return sub
} | go | {
"resource": ""
} |
q178226 | serve | test | func (ch *Channel) serve() {
acceptBackoff := 0 * time.Millisecond
for {
netConn, err := ch.mutable.l.Accept()
if err != nil {
// Backoff from new accepts if this is a temporary error
if ne, ok := err.(net.Error); ok && ne.Temporary() {
if acceptBackoff == 0 {
acceptBackoff = 5 * time.Millisecond
... | go | {
"resource": ""
} |
q178227 | Ping | test | func (ch *Channel) Ping(ctx context.Context, hostPort string) error {
peer := ch.RootPeers().GetOrAdd(hostPort)
conn, err := peer.GetConnection(ctx)
if err != nil {
return err
}
return conn.ping(ctx)
} | go | {
"resource": ""
} |
q178228 | StatsTags | test | func (ch *Channel) StatsTags() map[string]string {
m := make(map[string]string)
for k, v := range ch.commonStatsTags {
m[k] = v
}
return m
} | go | {
"resource": ""
} |
q178229 | Connect | test | func (ch *Channel) Connect(ctx context.Context, hostPort string) (*Connection, error) {
switch state := ch.State(); state {
case ChannelClient, ChannelListening:
break
default:
ch.log.Debugf("Connect rejecting new connection as state is %v", state)
return nil, errInvalidStateForOp
}
// The context timeout a... | go | {
"resource": ""
} |
q178230 | exchangeUpdated | test | func (ch *Channel) exchangeUpdated(c *Connection) {
if c.remotePeerInfo.HostPort == "" {
// Hostport is unknown until we get init resp.
return
}
p, ok := ch.RootPeers().Get(c.remotePeerInfo.HostPort)
if !ok {
return
}
ch.updatePeer(p)
} | go | {
"resource": ""
} |
q178231 | updatePeer | test | func (ch *Channel) updatePeer(p *Peer) {
ch.peers.onPeerChange(p)
ch.subChannels.updatePeer(p)
p.callOnUpdateComplete()
} | go | {
"resource": ""
} |
q178232 | addConnection | test | func (ch *Channel) addConnection(c *Connection, direction connectionDirection) bool {
ch.mutable.Lock()
defer ch.mutable.Unlock()
if c.readState() != connectionActive {
return false
}
switch state := ch.mutable.state; state {
case ChannelClient, ChannelListening:
break
default:
return false
}
ch.mutab... | go | {
"resource": ""
} |
q178233 | removeClosedConn | test | func (ch *Channel) removeClosedConn(c *Connection) {
if c.readState() != connectionClosed {
return
}
ch.mutable.Lock()
delete(ch.mutable.conns, c.connID)
ch.mutable.Unlock()
} | go | {
"resource": ""
} |
q178234 | connectionCloseStateChange | test | func (ch *Channel) connectionCloseStateChange(c *Connection) {
ch.removeClosedConn(c)
if peer, ok := ch.RootPeers().Get(c.remotePeerInfo.HostPort); ok {
peer.connectionCloseStateChange(c)
ch.updatePeer(peer)
}
if c.outboundHP != "" && c.outboundHP != c.remotePeerInfo.HostPort {
// Outbound connections may be ... | go | {
"resource": ""
} |
q178235 | State | test | func (ch *Channel) State() ChannelState {
ch.mutable.RLock()
state := ch.mutable.state
ch.mutable.RUnlock()
return state
} | go | {
"resource": ""
} |
q178236 | NewReader | test | func NewReader(reader io.Reader) *Reader {
r := readerPool.Get().(*Reader)
r.reader = reader
r.err = nil
return r
} | go | {
"resource": ""
} |
q178237 | ReadUint16 | test | func (r *Reader) ReadUint16() uint16 {
if r.err != nil {
return 0
}
buf := r.buf[:2]
var readN int
readN, r.err = io.ReadFull(r.reader, buf)
if readN < 2 {
return 0
}
return binary.BigEndian.Uint16(buf)
} | go | {
"resource": ""
} |
q178238 | ReadString | test | func (r *Reader) ReadString(n int) string {
if r.err != nil {
return ""
}
var buf []byte
if n <= maxPoolStringLen {
buf = r.buf[:n]
} else {
buf = make([]byte, n)
}
var readN int
readN, r.err = io.ReadFull(r.reader, buf)
if readN < n {
return ""
}
s := string(buf)
return s
} | go | {
"resource": ""
} |
q178239 | ReadLen16String | test | func (r *Reader) ReadLen16String() string {
len := r.ReadUint16()
return r.ReadString(int(len))
} | go | {
"resource": ""
} |
q178240 | Register | test | func (b *Behavior) Register(ch *tchannel.Channel) {
b.registerThrift(ch)
b.registerJSON(ch)
} | go | {
"resource": ""
} |
q178241 | Run | test | func (b *Behavior) Run(t crossdock.T) {
logParams(t)
sampled, err := strconv.ParseBool(t.Param(sampledParam))
if err != nil {
t.Fatalf("Malformed param %s: %s", sampledParam, err)
}
baggage := randomBaggage()
level1 := &Request{
ServerRole: RoleS1,
}
server1 := t.Param(server1NameParam)
level2 := &Downst... | go | {
"resource": ""
} |
q178242 | Get | test | func (tp *relayTimerPool) Get() *relayTimer {
timer, ok := tp.pool.Get().(*relayTimer)
if ok {
timer.released = false
return timer
}
rt := &relayTimer{
pool: tp,
}
// Go timers are started by default. However, we need to separate creating
// the timer and starting the timer for use in the relay code paths... | go | {
"resource": ""
} |
q178243 | Put | test | func (tp *relayTimerPool) Put(rt *relayTimer) {
if tp.verify {
// If we are trying to verify correct pool behavior, then we don't release
// the timer, and instead ensure no methods are called after being released.
return
}
tp.pool.Put(rt)
} | go | {
"resource": ""
} |
q178244 | Start | test | func (rt *relayTimer) Start(d time.Duration, items *relayItems, id uint32, isOriginator bool) {
rt.verifyNotReleased()
if rt.active {
panic("Tried to start an already-active timer")
}
rt.active = true
rt.items = items
rt.id = id
rt.isOriginator = isOriginator
if wasActive := rt.timer.Reset(d); wasActive {
... | go | {
"resource": ""
} |
q178245 | Release | test | func (rt *relayTimer) Release() {
rt.verifyNotReleased()
if rt.active {
panic("only stopped or completed timers can be released")
}
rt.released = true
rt.pool.Put(rt)
} | go | {
"resource": ""
} |
q178246 | NewLogger | test | func NewLogger(writer io.Writer, fields ...LogField) Logger {
return &writerLogger{writer, fields}
} | go | {
"resource": ""
} |
q178247 | NewTCPFrameRelay | test | func NewTCPFrameRelay(dests []string, modifier func(bool, *tchannel.Frame) *tchannel.Frame) (Relay, error) {
var err error
r := &tcpFrameRelay{modifier: modifier}
r.tcpRelay, err = newTCPRelay(dests, r.handleConnFrameRelay)
if err != nil {
return nil, err
}
return r, nil
} | go | {
"resource": ""
} |
q178248 | tallyTags | test | func (kt knownTags) tallyTags() map[string]string {
tallyTags := make(map[string]string, 5)
if kt.dest != "" {
tallyTags["dest"] = kt.dest
}
if kt.source != "" {
tallyTags["source"] = kt.source
}
if kt.procedure != "" {
tallyTags["procedure"] = kt.procedure
}
if kt.retryCount != "" {
tallyTags["retry-c... | go | {
"resource": ""
} |
q178249 | Isolated | test | func Isolated(s *SubChannel) {
s.Lock()
s.peers = s.topChannel.peers.newSibling()
s.peers.SetStrategy(newLeastPendingCalculator())
s.Unlock()
} | go | {
"resource": ""
} |
q178250 | Isolated | test | func (c *SubChannel) Isolated() bool {
c.RLock()
defer c.RUnlock()
return c.topChannel.Peers() != c.peers
} | go | {
"resource": ""
} |
q178251 | Register | test | func (c *SubChannel) Register(h Handler, methodName string) {
handlers, ok := c.handler.(*handlerMap)
if !ok {
panic(fmt.Sprintf(
"handler for SubChannel(%v) was changed to disallow method registration",
c.ServiceName(),
))
}
handlers.register(h, methodName)
} | go | {
"resource": ""
} |
q178252 | GetHandlers | test | func (c *SubChannel) GetHandlers() map[string]Handler {
handlers, ok := c.handler.(*handlerMap)
if !ok {
panic(fmt.Sprintf(
"handler for SubChannel(%v) was changed to disallow method registration",
c.ServiceName(),
))
}
handlers.RLock()
handlersMap := make(map[string]Handler, len(handlers.handlers))
fo... | go | {
"resource": ""
} |
q178253 | StatsTags | test | func (c *SubChannel) StatsTags() map[string]string {
tags := c.topChannel.StatsTags()
tags["subchannel"] = c.serviceName
return tags
} | go | {
"resource": ""
} |
q178254 | registerNewSubChannel | test | func (subChMap *subChannelMap) registerNewSubChannel(serviceName string, ch *Channel) (_ *SubChannel, added bool) {
subChMap.Lock()
defer subChMap.Unlock()
if subChMap.subchannels == nil {
subChMap.subchannels = make(map[string]*SubChannel)
}
if sc, ok := subChMap.subchannels[serviceName]; ok {
return sc, fa... | go | {
"resource": ""
} |
q178255 | get | test | func (subChMap *subChannelMap) get(serviceName string) (*SubChannel, bool) {
subChMap.RLock()
sc, ok := subChMap.subchannels[serviceName]
subChMap.RUnlock()
return sc, ok
} | go | {
"resource": ""
} |
q178256 | getOrAdd | test | func (subChMap *subChannelMap) getOrAdd(serviceName string, ch *Channel) (_ *SubChannel, added bool) {
if sc, ok := subChMap.get(serviceName); ok {
return sc, false
}
return subChMap.registerNewSubChannel(serviceName, ch)
} | go | {
"resource": ""
} |
q178257 | Discover | test | func (c *Client) Discover(serviceName string) ([]string, error) {
ctx, cancel := thrift.NewContext(time.Second)
defer cancel()
result, err := c.hyperbahnClient.Discover(ctx, &hyperbahn.DiscoveryQuery{ServiceName: serviceName})
if err != nil {
return nil, err
}
var hostPorts []string
for _, peer := range resu... | go | {
"resource": ""
} |
q178258 | Start | test | func (c *Client) Start() error {
if err := c.listen(); err != nil {
return err
}
go func() {
http.Serve(c.listener, c.mux)
}()
return nil
} | go | {
"resource": ""
} |
q178259 | listen | test | func (c *Client) listen() error {
c.setDefaultPort(&c.ClientHostPort, ":"+common.DefaultClientPortHTTP)
c.setDefaultPort(&c.ServerPort, common.DefaultServerPort)
c.mux = http.NewServeMux() // Using default mux creates problem in unit tests
c.mux.Handle("/", crossdock.Handler(c.Behaviors, true))
listener, err := ... | go | {
"resource": ""
} |
q178260 | WriteRequest | test | func WriteRequest(call tchannel.ArgWritable, req *http.Request) error {
// TODO(prashant): Allow creating write buffers that let you grow the buffer underneath.
wb := typed.NewWriteBufferWithSize(10000)
wb.WriteLen8String(req.Method)
writeVarintString(wb, req.URL.String())
writeHeaders(wb, req.Header)
arg2Writer... | go | {
"resource": ""
} |
q178261 | ReadRequest | test | func ReadRequest(call tchannel.ArgReadable) (*http.Request, error) {
var arg2 []byte
if err := tchannel.NewArgReader(call.Arg2Reader()).Read(&arg2); err != nil {
return nil, err
}
rb := typed.NewReadBuffer(arg2)
method := rb.ReadLen8String()
url := readVarintString(rb)
r, err := http.NewRequest(method, url, n... | go | {
"resource": ""
} |
q178262 | NewReadBufferWithSize | test | func NewReadBufferWithSize(size int) *ReadBuffer {
return &ReadBuffer{buffer: make([]byte, size), remaining: nil}
} | go | {
"resource": ""
} |
q178263 | ReadByte | test | func (r *ReadBuffer) ReadByte() (byte, error) {
if r.err != nil {
return 0, r.err
}
if len(r.remaining) < 1 {
r.err = ErrEOF
return 0, r.err
}
b := r.remaining[0]
r.remaining = r.remaining[1:]
return b, nil
} | go | {
"resource": ""
} |
q178264 | ReadBytes | test | func (r *ReadBuffer) ReadBytes(n int) []byte {
if r.err != nil {
return nil
}
if len(r.remaining) < n {
r.err = ErrEOF
return nil
}
b := r.remaining[0:n]
r.remaining = r.remaining[n:]
return b
} | go | {
"resource": ""
} |
q178265 | ReadString | test | func (r *ReadBuffer) ReadString(n int) string {
if b := r.ReadBytes(n); b != nil {
// TODO(mmihic): This creates a copy, which sucks
return string(b)
}
return ""
} | go | {
"resource": ""
} |
q178266 | ReadUint16 | test | func (r *ReadBuffer) ReadUint16() uint16 {
if b := r.ReadBytes(2); b != nil {
return binary.BigEndian.Uint16(b)
}
return 0
} | go | {
"resource": ""
} |
q178267 | ReadUint32 | test | func (r *ReadBuffer) ReadUint32() uint32 {
if b := r.ReadBytes(4); b != nil {
return binary.BigEndian.Uint32(b)
}
return 0
} | go | {
"resource": ""
} |
q178268 | ReadUint64 | test | func (r *ReadBuffer) ReadUint64() uint64 {
if b := r.ReadBytes(8); b != nil {
return binary.BigEndian.Uint64(b)
}
return 0
} | go | {
"resource": ""
} |
q178269 | ReadUvarint | test | func (r *ReadBuffer) ReadUvarint() uint64 {
v, _ := binary.ReadUvarint(r)
return v
} | go | {
"resource": ""
} |
q178270 | ReadLen8String | test | func (r *ReadBuffer) ReadLen8String() string {
n := r.ReadSingleByte()
return r.ReadString(int(n))
} | go | {
"resource": ""
} |
q178271 | ReadLen16String | test | func (r *ReadBuffer) ReadLen16String() string {
n := r.ReadUint16()
return r.ReadString(int(n))
} | go | {
"resource": ""
} |
q178272 | FillFrom | test | func (r *ReadBuffer) FillFrom(ior io.Reader, n int) (int, error) {
if len(r.buffer) < n {
return 0, ErrEOF
}
r.err = nil
r.remaining = r.buffer[:n]
return io.ReadFull(ior, r.remaining)
} | go | {
"resource": ""
} |
q178273 | Wrap | test | func (r *ReadBuffer) Wrap(b []byte) {
r.buffer = b
r.remaining = b
r.err = nil
} | go | {
"resource": ""
} |
q178274 | WriteSingleByte | test | func (w *WriteBuffer) WriteSingleByte(n byte) {
if w.err != nil {
return
}
if len(w.remaining) == 0 {
w.setErr(ErrBufferFull)
return
}
w.remaining[0] = n
w.remaining = w.remaining[1:]
} | go | {
"resource": ""
} |
q178275 | WriteBytes | test | func (w *WriteBuffer) WriteBytes(in []byte) {
if b := w.reserve(len(in)); b != nil {
copy(b, in)
}
} | go | {
"resource": ""
} |
q178276 | WriteUint16 | test | func (w *WriteBuffer) WriteUint16(n uint16) {
if b := w.reserve(2); b != nil {
binary.BigEndian.PutUint16(b, n)
}
} | go | {
"resource": ""
} |
q178277 | WriteUint32 | test | func (w *WriteBuffer) WriteUint32(n uint32) {
if b := w.reserve(4); b != nil {
binary.BigEndian.PutUint32(b, n)
}
} | go | {
"resource": ""
} |
q178278 | WriteUint64 | test | func (w *WriteBuffer) WriteUint64(n uint64) {
if b := w.reserve(8); b != nil {
binary.BigEndian.PutUint64(b, n)
}
} | go | {
"resource": ""
} |
q178279 | WriteUvarint | test | func (w *WriteBuffer) WriteUvarint(n uint64) {
// A uvarint could be up to 10 bytes long.
buf := make([]byte, 10)
varBytes := binary.PutUvarint(buf, n)
if b := w.reserve(varBytes); b != nil {
copy(b, buf[0:varBytes])
}
} | go | {
"resource": ""
} |
q178280 | WriteString | test | func (w *WriteBuffer) WriteString(s string) {
// NB(mmihic): Don't just call WriteBytes; that will make a double copy
// of the string due to the cast
if b := w.reserve(len(s)); b != nil {
copy(b, s)
}
} | go | {
"resource": ""
} |
q178281 | WriteLen8String | test | func (w *WriteBuffer) WriteLen8String(s string) {
if int(byte(len(s))) != len(s) {
w.setErr(errStringTooLong)
}
w.WriteSingleByte(byte(len(s)))
w.WriteString(s)
} | go | {
"resource": ""
} |
q178282 | WriteLen16String | test | func (w *WriteBuffer) WriteLen16String(s string) {
if int(uint16(len(s))) != len(s) {
w.setErr(errStringTooLong)
}
w.WriteUint16(uint16(len(s)))
w.WriteString(s)
} | go | {
"resource": ""
} |
q178283 | DeferByte | test | func (w *WriteBuffer) DeferByte() ByteRef {
if len(w.remaining) == 0 {
w.setErr(ErrBufferFull)
return ByteRef(nil)
}
// Always zero out references, since the caller expects the default to be 0.
w.remaining[0] = 0
bufRef := ByteRef(w.remaining[0:])
w.remaining = w.remaining[1:]
return bufRef
} | go | {
"resource": ""
} |
q178284 | DeferBytes | test | func (w *WriteBuffer) DeferBytes(n int) BytesRef {
return BytesRef(w.deferred(n))
} | go | {
"resource": ""
} |
q178285 | FlushTo | test | func (w *WriteBuffer) FlushTo(iow io.Writer) (int, error) {
dirty := w.buffer[0:w.BytesWritten()]
return iow.Write(dirty)
} | go | {
"resource": ""
} |
q178286 | Reset | test | func (w *WriteBuffer) Reset() {
w.remaining = w.buffer
w.err = nil
} | go | {
"resource": ""
} |
q178287 | Wrap | test | func (w *WriteBuffer) Wrap(b []byte) {
w.buffer = b
w.remaining = b
} | go | {
"resource": ""
} |
q178288 | Update | test | func (ref Uint16Ref) Update(n uint16) {
if ref != nil {
binary.BigEndian.PutUint16(ref, n)
}
} | go | {
"resource": ""
} |
q178289 | Update | test | func (ref Uint32Ref) Update(n uint32) {
if ref != nil {
binary.BigEndian.PutUint32(ref, n)
}
} | go | {
"resource": ""
} |
q178290 | Update | test | func (ref Uint64Ref) Update(n uint64) {
if ref != nil {
binary.BigEndian.PutUint64(ref, n)
}
} | go | {
"resource": ""
} |
q178291 | Update | test | func (ref BytesRef) Update(b []byte) {
if ref != nil {
copy(ref, b)
}
} | go | {
"resource": ""
} |
q178292 | UpdateString | test | func (ref BytesRef) UpdateString(s string) {
if ref != nil {
copy(ref, s)
}
} | go | {
"resource": ""
} |
q178293 | ArgReader | test | func (r *fragmentingReader) ArgReader(last bool) (ArgReader, error) {
if err := r.BeginArgument(last); err != nil {
return nil, err
}
return r, nil
} | go | {
"resource": ""
} |
q178294 | finish | test | func (f *writableFragment) finish(hasMoreFragments bool) {
f.checksumRef.Update(f.checksum.Sum())
if hasMoreFragments {
f.flagsRef.Update(hasMoreFragmentsFlag)
} else {
f.checksum.Release()
}
} | go | {
"resource": ""
} |
q178295 | newWritableChunk | test | func newWritableChunk(checksum Checksum, contents *typed.WriteBuffer) *writableChunk {
return &writableChunk{
size: 0,
sizeRef: contents.DeferUint16(),
checksum: checksum,
contents: contents,
}
} | go | {
"resource": ""
} |
q178296 | writeAsFits | test | func (c *writableChunk) writeAsFits(b []byte) int {
if len(b) > c.contents.BytesRemaining() {
b = b[:c.contents.BytesRemaining()]
}
c.checksum.Add(b)
c.contents.WriteBytes(b)
written := len(b)
c.size += uint16(written)
return written
} | go | {
"resource": ""
} |
q178297 | newFragmentingWriter | test | func newFragmentingWriter(logger Logger, sender fragmentSender, checksum Checksum) *fragmentingWriter {
return &fragmentingWriter{
logger: logger,
sender: sender,
checksum: checksum,
state: fragmentingWriteStart,
}
} | go | {
"resource": ""
} |
q178298 | ArgWriter | test | func (w *fragmentingWriter) ArgWriter(last bool) (ArgWriter, error) {
if err := w.BeginArgument(last); err != nil {
return nil, err
}
return w, nil
} | go | {
"resource": ""
} |
q178299 | BeginArgument | test | func (w *fragmentingWriter) BeginArgument(last bool) error {
if w.err != nil {
return w.err
}
switch {
case w.state == fragmentingWriteComplete:
w.err = errComplete
return w.err
case w.state.isWritingArgument():
w.err = errAlreadyWritingArgument
return w.err
}
// If we don't have a fragment, request ... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.