id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c24800 |
data: data,
length: length,
}
} | |
c24801 | := vector.length - 1
lastByteIndex := lastBitIndex >> 3
return lastByteIndex + 1
} | |
c24802 | || i >= vector.length {
panic("Attempted to access element outside buffer")
}
} | |
c24803 | 3
byteOffset := index % 8
oldByte := vector.data[byteIndex]
var newByte byte
if bit == 1 {
newByte = oldByte | 1<<byteOffset
} else {
// Set all bits except the byteOffset
mask := byte(^(1 << byteOffset))
newByte = oldByte & mask
}
vector.data[byteIndex] = newByte
} | |
c24804 |
b := vector.data[byteIndex]
// Check the offset bit
return (b >> byteOffset) & 1
} | |
c24805 | var newByte byte
if bit == 1 {
// turn on the byteOffset'th bit
newByte = oldByte | 1<<byteOffset
} else {
// turn off the byteOffset'th bit
removeMask := byte(^(1 << byteOffset))
newByte = oldByte & removeMask
}
vector.data[byteIndex] = newByte
} | |
c24806 | will need to be shifted into the next byte
leftoverBit := (oldByte & 0x80) >> 7
// Make masks to pull off the bits below and above byteOffset
// This mask has the byteOffset lowest bits set.
bottomMask := byte((1 << byteOffset) - 1)
// This mask has the 8 - byteOffset top bits set.
topMask := ^bottomMask
top :=... | |
c24807 | bottom bits and combines with the new top.
newByte := (bottomMask & oldByte) | newTop
vector.data[byteIndex] = newByte
// The desired length is the byte index of the last element plus one,
// where the byte index of the last element is the bit index of the last
// element divided by 8.
byteLength := vector.byte... | |
c24808 |
return s[i] < s[j]
} | |
c24809 | s[i], s[j] = s[j], s[i]
} | |
c24810 |
return s[i] < s[j]
} | |
c24811 | s[i], s[j] = s[j], s[i]
} | |
c24812 |
return s[i] < s[j]
} | |
c24813 | s[i], s[j] = s[j], s[i]
} | |
c24814 |
return s[i] < s[j]
} | |
c24815 | s[i], s[j] = s[j], s[i]
} | |
c24816 |
return s[i] < s[j]
} | |
c24817 | s[i], s[j] = s[j], s[i]
} | |
c24818 |
return s[i] < s[j]
} | |
c24819 | s[i], s[j] = s[j], s[i]
} | |
c24820 |
return s[i] < s[j]
} | |
c24821 | s[i], s[j] = s[j], s[i]
} | |
c24822 |
return s[i] < s[j]
} | |
c24823 | s[i], s[j] = s[j], s[i]
} | |
c24824 |
return s[i] < s[j]
} | |
c24825 | s[i], s[j] = s[j], s[i]
} | |
c24826 | s[i], s[j] = s[j], s[i]
} | |
c24827 | return s[i].Before(s[j])
} | |
c24828 | s[i], s[j] = s[j], s[i]
} | |
c24829 | ComputeMd5Checksum(data)
return bytes.Equal(ourSum, sum)
} | |
c24830 |
err: err,
allowNotFound: true,
}
resp.item.Key = key
return resp
} | |
c24831 | if value == nil {
resp.item.Value = []byte{}
} else {
resp.item.Value = value
}
resp.item.Flags = flags
resp.item.DataVersionId = version
}
return resp
} | |
c24832 | {
resp := &genericResponse{
err: err,
}
resp.item.Key = key
return resp
} | |
c24833 | resp.item.Key = key
if status == StatusNoError {
resp.item.DataVersionId = version
}
return resp
} | |
c24834 | {
resp := &genericResponse{
err: err,
}
resp.item.Key = key
return resp
} | |
c24835 | }
resp.item.Key = key
if status == StatusNoError {
resp.count = count
}
return resp
} | |
c24836 | &genericResponse{
err: err,
versions: versions,
}
} | |
c24837 | status: status,
versions: versions,
}
return resp
} | |
c24838 | &genericResponse{
err: err,
statEntries: entries,
}
} | |
c24839 | status: status,
statEntries: entries,
}
return resp
} | |
c24840 |
m.InitWithPool(
shardFunc,
logError,
logInfo,
net2.NewMultiConnectionPool(options))
} | |
c24841 | err := m.pool.Register("tcp", address.(string)); err != nil {
m.logError(err)
}
}
for address := range set.Subtract(oldAddrs, newAddrs).Iter() {
if err := m.pool.Unregister("tcp", address.(string)); err != nil {
m.logError(err)
}
}
m.shardStates = shardStates
} | |
c24842 | WriteOnlyServer ||
state.State == WarmUpServer {
m.fillEntryWithConnection(state.Address, entry)
// During WARM_UP state, we do try to write sentinels to
// memcache but any failures are ignored. We run memcache
// server in this mode for sometime to prime our memcache
// and warm up me... | |
c24843 | if size > 0 {
if err != nil && workSize != 0 {
size -= (size % workSize)
}
copyTo <- batch[:size]
}
if err != nil {
if err != io.EOF {
log.Print("Error encountered in readBuffer:", err)
}
return
}
}
} | |
c24844 | return
} else if size != len(buf) {
panic(errors.New("Short Write: io.Writer not compliant"))
}
}
}
} | |
c24845 | return float64(t.Unix()) + (float64(t.Nanosecond()) / 1e9)
} | |
c24846 | rw.writeLocked {
panic("nosync: mutex is already locked")
}
rw.writeLocked = true
} | |
c24847 | panic("sync: negative WaitGroup counter")
}
} | |
c24848 | js.Global.Get("Date").New().Call("getTime").Int64() * millisecond
} | |
c24849 | value, ok = m.m[key]
return value, ok
} | |
c24850 | == nil {
m.m = make(map[interface{}]interface{})
}
m.m[key] = value
} | |
c24851 | m.m = make(map[interface{}]interface{})
}
m.m[key] = value
return value, false
} | |
c24852 | return Global.Call("$makeFunc", InternalObject(fn))
} | |
c24853 | := 0; i < a.Length(); i++ {
s[i] = a.Index(i).String()
}
return s
} | |
c24854 | continue
}
o.Set(m.Get("name").String(), func(args ...*Object) *Object {
return Global.Call("$externalizeFunction", v.Get(m.Get("prop").String()), m.Get("typ"), true).Call("apply", v, args)
})
}
return o
} | |
c24855 |
return slice.Get("$array").Get("buffer").Call("slice", offset, offset+length)
} | |
c24856 | := make(chan bool)
semWaiters[s] = append(semWaiters[s], ch)
<-ch
}
*s--
} | |
c24857 | w
if len(w) == 0 {
delete(semWaiters, s)
}
ch <- true
} | |
c24858 | "executable_") {
continue
}
s = append(s, f)
}
return s
} | |
c24859 | if f == e {
continue Outer
}
}
s = append(s, f)
}
return s
} | |
c24860 | }
jsFiles, err := jsFilesFromDir(bctx, pkg.Dir)
if err != nil {
return nil, err
}
return &PackageData{Package: pkg, JSFiles: jsFiles}, nil
} | |
c24861 | filepath.Clean(gopathWorkspace)
if strings.HasPrefix(file, gopathWorkspace) {
return true, len(gopathWorkspace)
}
}
return false, 0
} | |
c24862 | &r)
return uint64(r.Cur), err // Type conversion because Cur is one of uint64, int64 depending on unix flavor.
} | |
c24863 | for _, arg := range args {
v := ValueOf(arg)
newArgs = append(newArgs, v.internal())
}
return newArgs
} | |
c24864 |
}
for i, b := range x {
if b != y[i] {
return false
}
}
return true
} | |
c24865 | if b == c {
return i
}
}
return -1
} | |
c24866 |
return 1
case *exec.ExitError:
return err.Sys().(syscall.WaitStatus).ExitStatus()
default:
printError(err, options, browserErrors)
return 1
}
} | |
c24867 |
fmt.Fprintln(browserErrors, `console.error("`+template.JSEscapeString(e)+`");`)
}
} | |
c24868 | pos := e.Fset.Position(e.Pos)
return fmt.Sprintf("%s:%d:%d: %s", makeRel(pos.Filename), pos.Line, pos.Column, e.Msg)
default:
return fmt.Sprintf("%s", e)
}
} | |
c24869 | sync
// and can be controlled by setting OS process limit. E.g.:
//
// ulimit -s 10000 && gopherjs test
//
cur, err := sysutil.RlimitStack()
if err != nil {
return fmt.Errorf("failed to get stack size limit: %v", err)
}
allArgs = append(allArgs, fmt.Sprintf("--stack_size=%v", cur/1000)) // Convert ... | |
c24870 |
return &image.NRGBA{
Pix: bytes.Repeat([]byte{c.R, c.G, c.B, c.A}, width*height),
Stride: 4 * width,
Rect: image.Rect(0, 0, width, height),
}
} | |
c24871 | range ys {
i := y * dst.Stride
src.scan(0, y, src.w, y+1, dst.Pix[i:i+size])
}
})
return dst
} | |
c24872 | int) {
for y := range ys {
i := (y - r.Min.Y) * dst.Stride
src.scan(r.Min.X, y, r.Max.X, y+1, dst.Pix[i:i+rowSize])
}
})
return dst
} | |
c24873 | := image.Rect(0, 0, width, height).Add(pt)
b := srcBounds.Intersect(r)
return Crop(img, b)
} | |
c24874 | return CropAnchor(img, width, height, Center)
} | |
c24875 | x2 := interRect.Max.X - pasteRect.Min.X
y1 := y - pasteRect.Min.Y
y2 := y1 + 1
i1 := y*dst.Stride + interRect.Min.X*4
i2 := i1 + interRect.Dx()*4
src.scan(x1, y1, x2, y2, dst.Pix[i1:i2])
}
})
return dst
} | |
c24876 |
x0 := centerX - img.Bounds().Dx()/2
y0 := centerY - img.Bounds().Dy()/2
return Paste(background, img, image.Pt(x0, y0))
} | |
c24877 | bgH/2
x0 := centerX - img.Bounds().Dx()/2
y0 := centerY - img.Bounds().Dy()/2
return Overlay(background, img, image.Point{x0, y0}, opacity)
} | |
c24878 | float64(dstW)/2 - 0.5
dstYOff := float64(dstH)/2 - 0.5
bgColorNRGBA := color.NRGBAModel.Convert(bgColor).(color.NRGBA)
sin, cos := math.Sincos(math.Pi * angle / 180)
parallel(0, dstH, func(ys <-chan int) {
for dstY := range ys {
for dstX := 0; dstX < dstW; dstX++ {
xf, yf := rotatePoint(float64(dstX)-ds... | |
c24879 | wg sync.WaitGroup
for i := 0; i < procs; i++ {
wg.Add(1)
go func() {
defer wg.Done()
fn(c)
}()
}
wg.Wait()
} | |
c24880 | if v > 255 {
return 255
}
if v > 0 {
return uint8(v)
}
return 0
} | |
c24881 | 2
if max == min {
return 0, 0, l
}
var h, s float64
d := max - min
if l > 0.5 {
s = d / (2 - max - min)
} else {
s = d / (max + min)
}
switch max {
case rr:
h = (gg - bb) / d
if g < b {
h += 6
}
case gg:
h = (bb-rr)/d + 2
case bb:
h = (rr-gg)/d + 4
}
h /= 6
return h, s, l
} | |
c24882 |
r = hueToRGB(p, q, h+1/3.0)
g = hueToRGB(p, q, h)
b = hueToRGB(p, q, h-1/3.0)
return clamp(r * 255), clamp(g * 255), clamp(b * 255)
} | |
c24883 | for y := range ys {
srcY := int((float64(y) + 0.5) * dy)
srcOff0 := srcY * src.Stride
dstOff := y * dst.Stride
for x := 0; x < width; x++ {
srcX := int((float64(x) + 0.5) * dx)
srcOff := srcOff0 + srcX*4
copy(dst.Pix[dstOff:dstOff+4], src.Pix[srcOff:srcOff+4])
dstOff += 4
}
... | |
c24884 | := float64(srcW) * float64(dstH) / float64(dstW)
tmp = CropAnchor(img, srcW, int(math.Max(1, cropH)+0.5), anchor)
} else {
cropW := float64(srcH) * float64(dstW) / float64(dstH)
tmp = CropAnchor(img, int(math.Max(1, cropW)+0.5), srcH, anchor)
}
return Resize(tmp, dstW, dstH, filter)
} | |
c24885 | if srcAspectRatio < dstAspectRatio {
tmp = Resize(img, dstW, 0, filter)
} else {
tmp = Resize(img, 0, dstH, filter)
}
return CropAnchor(tmp, dstW, dstH, anchor)
} | |
c24886 |
g := d[1]
b := d[2]
f := 0.299*float64(r) + 0.587*float64(g) + 0.114*float64(b)
y := uint8(f + 0.5)
d[0] = y
d[1] = y
d[2] = y
i += 4
}
}
})
return dst
} | |
c24887 | io.Copy(ioutil.Discard, pr)
}()
img, _, err := image.Decode(r)
pw.Close()
<-done
if err != nil {
return nil, err
}
return fixOrientation(img, orient), nil
} | |
c24888 | *encodeConfig) {
c.gifQuantizer = quantizer
}
} | |
c24889 | *encodeConfig) {
c.gifDrawer = drawer
}
} | |
c24890 | *encodeConfig) {
c.pngCompressionLevel = level
}
} | |
c24891 | orientationRotate270:
img = Rotate270(img)
case orientationTranspose:
img = Transpose(img)
case orientationTransverse:
img = Transverse(img)
}
return img
} | |
c24892 | keyPath,
remoteEncrypted: true,
skipVerify: skipVerify,
}
} | |
c24893 | != "" {
config, err := createTLSConfig(t.certFile, t.certKey)
if err != nil {
return err
}
ln = tls.NewListener(ln, config)
}
t.ln = ln
return nil
} | |
c24894 | TLS dial")
conn, err = tls.DialWithDialer(dialer, "tcp", addr, conf)
} else {
conn, err = dialer.Dial("tcp", addr)
}
return conn, err
} | |
c24895 | != nil {
return err
}
h.br = bytes.NewReader(b)
if tx {
h.url = h.url + "?transaction"
}
return nil
} | |
c24896 |
if resp.StatusCode != http.StatusOK {
return 0, fmt.Errorf("received %s", resp.Status)
}
dur := time.Since(start)
return dur, nil
} | |
c24897 | := json.NewDecoder(bytes.NewReader(buf))
if err := dec.Decode(&peerSet); err != nil {
return 0, err
}
return len(peerSet), nil
} | |
c24898 | return false, err
}
return n <= 1, nil
} | |
c24899 | make(map[uint64]*Connection),
done: make(chan struct{}, 1),
meta: make(map[string]map[string]string),
logger: logger,
ApplyTimeout: applyTimeout,
connPollPeriod: connectionPollPeriod,
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.