_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q24800 | NewBitVector | train | func NewBitVector(data []byte, length int) *BitVector {
return &BitVector{
data: data,
length: length,
}
} | go | {
"resource": ""
} |
q24801 | bytesLength | train | func (vector *BitVector) bytesLength() int {
lastBitIndex := vector.length - 1
lastByteIndex := lastBitIndex >> 3
return lastByteIndex + 1
} | go | {
"resource": ""
} |
q24802 | indexAssert | train | func (vector *BitVector) indexAssert(i int) {
if i < 0 || i >= vector.length {
panic("Attempted to access element outside buffer")
}
} | go | {
"resource": ""
} |
q24803 | Append | train | func (vector *BitVector) Append(bit byte) {
index := uint32(vector.length)
vector.length++
if vector.bytesLength() > len(vector.data) {
vector.data = append(vector.data, 0)
}
byteIndex := index >> 3
byteOffset := index % 8
oldByte := vector.data[byteIndex]
var newByte byte
if bit == 1 {
newByte = oldByte... | go | {
"resource": ""
} |
q24804 | Element | train | func (vector *BitVector) Element(i int) byte {
vector.indexAssert(i)
byteIndex := i >> 3
byteOffset := uint32(i % 8)
b := vector.data[byteIndex]
// Check the offset bit
return (b >> byteOffset) & 1
} | go | {
"resource": ""
} |
q24805 | Set | train | func (vector *BitVector) Set(bit byte, index int) {
vector.indexAssert(index)
byteIndex := uint32(index >> 3)
byteOffset := uint32(index % 8)
oldByte := vector.data[byteIndex]
var newByte byte
if bit == 1 {
// turn on the byteOffset'th bit
newByte = oldByte | 1<<byteOffset
} else {
// turn off the byteOf... | go | {
"resource": ""
} |
q24806 | Insert | train | func (vector *BitVector) Insert(bit byte, index int) {
vector.indexAssert(index)
vector.length++
// Append an additional byte if necessary.
if vector.bytesLength() > len(vector.data) {
vector.data = append(vector.data, 0)
}
byteIndex := uint32(index >> 3)
byteOffset := uint32(index % 8)
var bitToInsert byte... | go | {
"resource": ""
} |
q24807 | Delete | train | func (vector *BitVector) Delete(index int) {
vector.indexAssert(index)
vector.length--
byteIndex := uint32(index >> 3)
byteOffset := uint32(index % 8)
oldByte := vector.data[byteIndex]
// Shift all the bytes above the byte we're modifying, return the
// leftover bit to include in the byte we're modifying.
bit... | go | {
"resource": ""
} |
q24808 | Less | train | func (s UintSlice) Less(i, j int) bool {
return s[i] < s[j]
} | go | {
"resource": ""
} |
q24809 | Swap | train | func (s UintSlice) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
} | go | {
"resource": ""
} |
q24810 | Less | train | func (s Uint32Slice) Less(i, j int) bool {
return s[i] < s[j]
} | go | {
"resource": ""
} |
q24811 | Swap | train | func (s Uint32Slice) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
} | go | {
"resource": ""
} |
q24812 | Less | train | func (s Uint16Slice) Less(i, j int) bool {
return s[i] < s[j]
} | go | {
"resource": ""
} |
q24813 | Swap | train | func (s Uint16Slice) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
} | go | {
"resource": ""
} |
q24814 | Less | train | func (s Uint8Slice) Less(i, j int) bool {
return s[i] < s[j]
} | go | {
"resource": ""
} |
q24815 | Swap | train | func (s Uint8Slice) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
} | go | {
"resource": ""
} |
q24816 | Less | train | func (s Int32Slice) Less(i, j int) bool {
return s[i] < s[j]
} | go | {
"resource": ""
} |
q24817 | Swap | train | func (s Int32Slice) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
} | go | {
"resource": ""
} |
q24818 | Less | train | func (s Int16Slice) Less(i, j int) bool {
return s[i] < s[j]
} | go | {
"resource": ""
} |
q24819 | Swap | train | func (s Int16Slice) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
} | go | {
"resource": ""
} |
q24820 | Less | train | func (s Int8Slice) Less(i, j int) bool {
return s[i] < s[j]
} | go | {
"resource": ""
} |
q24821 | Swap | train | func (s Int8Slice) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
} | go | {
"resource": ""
} |
q24822 | Less | train | func (s Float32Slice) Less(i, j int) bool {
return s[i] < s[j]
} | go | {
"resource": ""
} |
q24823 | Swap | train | func (s Float32Slice) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
} | go | {
"resource": ""
} |
q24824 | Less | train | func (s Float64Slice) Less(i, j int) bool {
return s[i] < s[j]
} | go | {
"resource": ""
} |
q24825 | Swap | train | func (s Float64Slice) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
} | go | {
"resource": ""
} |
q24826 | Swap | train | func (s ByteArraySlice) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
} | go | {
"resource": ""
} |
q24827 | Less | train | func (s TimeSlice) Less(i, j int) bool {
return s[i].Before(s[j])
} | go | {
"resource": ""
} |
q24828 | Swap | train | func (s TimeSlice) Swap(i, j int) {
s[i], s[j] = s[j], s[i]
} | go | {
"resource": ""
} |
q24829 | ValidateMd5Checksum | train | func ValidateMd5Checksum(data []byte, sum []byte) bool {
ourSum := ComputeMd5Checksum(data)
return bytes.Equal(ourSum, sum)
} | go | {
"resource": ""
} |
q24830 | NewGetErrorResponse | train | func NewGetErrorResponse(key string, err error) GetResponse {
resp := &genericResponse{
err: err,
allowNotFound: true,
}
resp.item.Key = key
return resp
} | go | {
"resource": ""
} |
q24831 | NewGetResponse | train | func NewGetResponse(
key string,
status ResponseStatus,
flags uint32,
value []byte,
version uint64) GetResponse {
resp := &genericResponse{
status: status,
allowNotFound: true,
}
resp.item.Key = key
if status == StatusNoError {
if value == nil {
resp.item.Value = []byte{}
} else {
resp.it... | go | {
"resource": ""
} |
q24832 | NewMutateErrorResponse | train | func NewMutateErrorResponse(key string, err error) MutateResponse {
resp := &genericResponse{
err: err,
}
resp.item.Key = key
return resp
} | go | {
"resource": ""
} |
q24833 | NewMutateResponse | train | func NewMutateResponse(
key string,
status ResponseStatus,
version uint64) MutateResponse {
resp := &genericResponse{
status: status,
}
resp.item.Key = key
if status == StatusNoError {
resp.item.DataVersionId = version
}
return resp
} | go | {
"resource": ""
} |
q24834 | NewCountErrorResponse | train | func NewCountErrorResponse(key string, err error) CountResponse {
resp := &genericResponse{
err: err,
}
resp.item.Key = key
return resp
} | go | {
"resource": ""
} |
q24835 | NewCountResponse | train | func NewCountResponse(
key string,
status ResponseStatus,
count uint64) CountResponse {
resp := &genericResponse{
status: status,
}
resp.item.Key = key
if status == StatusNoError {
resp.count = count
}
return resp
} | go | {
"resource": ""
} |
q24836 | NewVersionErrorResponse | train | func NewVersionErrorResponse(
err error,
versions map[int]string) VersionResponse {
return &genericResponse{
err: err,
versions: versions,
}
} | go | {
"resource": ""
} |
q24837 | NewVersionResponse | train | func NewVersionResponse(
status ResponseStatus,
versions map[int]string) VersionResponse {
resp := &genericResponse{
status: status,
versions: versions,
}
return resp
} | go | {
"resource": ""
} |
q24838 | NewStatErrorResponse | train | func NewStatErrorResponse(
err error,
entries map[int](map[string]string)) StatResponse {
return &genericResponse{
err: err,
statEntries: entries,
}
} | go | {
"resource": ""
} |
q24839 | NewStatResponse | train | func NewStatResponse(
status ResponseStatus,
entries map[int](map[string]string)) StatResponse {
resp := &genericResponse{
status: status,
statEntries: entries,
}
return resp
} | go | {
"resource": ""
} |
q24840 | Init | train | func (m *BaseShardManager) Init(
shardFunc func(key string, numShard int) (shard int),
logError func(err error),
logInfo func(v ...interface{}),
options net2.ConnectionOptions) {
m.InitWithPool(
shardFunc,
logError,
logInfo,
net2.NewMultiConnectionPool(options))
} | go | {
"resource": ""
} |
q24841 | UpdateShardStates | train | func (m *BaseShardManager) UpdateShardStates(shardStates []ShardState) {
newAddrs := set.NewSet()
for _, state := range shardStates {
newAddrs.Add(state.Address)
}
m.rwMutex.Lock()
defer m.rwMutex.Unlock()
oldAddrs := set.NewSet()
for _, state := range m.shardStates {
oldAddrs.Add(state.Address)
}
for a... | go | {
"resource": ""
} |
q24842 | getShardsForSentinelsLocked | train | func (m *BaseShardManager) getShardsForSentinelsLocked(
keys []string) map[int]*ShardMapping {
numShards := len(m.shardStates)
results := make(map[int]*ShardMapping)
for _, key := range keys {
shardId := m.getShardId(key, numShards)
entry, inMap := results[shardId]
if !inMap {
entry = &ShardMapping{}
... | go | {
"resource": ""
} |
q24843 | readBuffer | train | func readBuffer(copyTo chan<- []byte, socketRead io.ReadCloser, batchSize int, workSize int) {
defer close(copyTo)
for {
batch := make([]byte, batchSize)
size, err := socketRead.Read(batch)
if err == nil && workSize != 0 && size%workSize != 0 {
var lsize int
lsize, err = io.ReadFull(
socketRead,
b... | go | {
"resource": ""
} |
q24844 | writeBuffer | train | func writeBuffer(copyFrom <-chan []byte, socketWrite io.Writer) {
for buf := range copyFrom {
if len(buf) > 0 {
size, err := socketWrite.Write(buf)
if err != nil {
log.Print("Error encountered in writeBuffer:", err)
return
} else if size != len(buf) {
panic(errors.New("Short Write: io.Writer not... | go | {
"resource": ""
} |
q24845 | TimeToFloat | train | func TimeToFloat(t time.Time) float64 {
return float64(t.Unix()) + (float64(t.Nanosecond()) / 1e9)
} | go | {
"resource": ""
} |
q24846 | Lock | train | func (rw *RWMutex) Lock() {
if rw.readLockCounter != 0 || rw.writeLocked {
panic("nosync: mutex is already locked")
}
rw.writeLocked = true
} | go | {
"resource": ""
} |
q24847 | Add | train | func (wg *WaitGroup) Add(delta int) {
wg.counter += delta
if wg.counter < 0 {
panic("sync: negative WaitGroup counter")
}
} | go | {
"resource": ""
} |
q24848 | runtime_nanotime | train | func runtime_nanotime() int64 {
const millisecond = 1000000
return js.Global.Get("Date").New().Call("getTime").Int64() * millisecond
} | go | {
"resource": ""
} |
q24849 | Load | train | func (m *Map) Load(key interface{}) (value interface{}, ok bool) {
value, ok = m.m[key]
return value, ok
} | go | {
"resource": ""
} |
q24850 | Store | train | func (m *Map) Store(key, value interface{}) {
if m.m == nil {
m.m = make(map[interface{}]interface{})
}
m.m[key] = value
} | go | {
"resource": ""
} |
q24851 | LoadOrStore | train | func (m *Map) LoadOrStore(key, value interface{}) (actual interface{}, loaded bool) {
if value, ok := m.m[key]; ok {
return value, true
}
if m.m == nil {
m.m = make(map[interface{}]interface{})
}
m.m[key] = value
return value, false
} | go | {
"resource": ""
} |
q24852 | MakeFunc | train | func MakeFunc(fn func(this *Object, arguments []*Object) interface{}) *Object {
return Global.Call("$makeFunc", InternalObject(fn))
} | go | {
"resource": ""
} |
q24853 | Keys | train | func Keys(o *Object) []string {
if o == nil || o == Undefined {
return nil
}
a := Global.Get("Object").Call("keys", o)
s := make([]string, a.Length())
for i := 0; i < a.Length(); i++ {
s[i] = a.Index(i).String()
}
return s
} | go | {
"resource": ""
} |
q24854 | MakeWrapper | train | func MakeWrapper(i interface{}) *Object {
v := InternalObject(i)
o := Global.Get("Object").New()
o.Set("__internal_object__", v)
methods := v.Get("constructor").Get("methods")
for i := 0; i < methods.Length(); i++ {
m := methods.Index(i)
if m.Get("pkg").String() != "" { // not exported
continue
}
o.Set(... | go | {
"resource": ""
} |
q24855 | NewArrayBuffer | train | func NewArrayBuffer(b []byte) *Object {
slice := InternalObject(b)
offset := slice.Get("$offset").Int()
length := slice.Get("$length").Int()
return slice.Get("$array").Get("buffer").Call("slice", offset, offset+length)
} | go | {
"resource": ""
} |
q24856 | runtime_Semacquire | train | func runtime_Semacquire(s *uint32) {
if *s == 0 {
ch := make(chan bool)
semWaiters[s] = append(semWaiters[s], ch)
<-ch
}
*s--
} | go | {
"resource": ""
} |
q24857 | runtime_Semrelease | train | func runtime_Semrelease(s *uint32) {
*s++
w := semWaiters[s]
if len(w) == 0 {
return
}
ch := w[0]
w = w[1:]
semWaiters[s] = w
if len(w) == 0 {
delete(semWaiters, s)
}
ch <- true
} | go | {
"resource": ""
} |
q24858 | excludeExecutable | train | func excludeExecutable(goFiles []string) []string {
var s []string
for _, f := range goFiles {
if strings.HasPrefix(f, "executable_") {
continue
}
s = append(s, f)
}
return s
} | go | {
"resource": ""
} |
q24859 | exclude | train | func exclude(files []string, exclude ...string) []string {
var s []string
Outer:
for _, f := range files {
for _, e := range exclude {
if f == e {
continue Outer
}
}
s = append(s, f)
}
return s
} | go | {
"resource": ""
} |
q24860 | ImportDir | train | func ImportDir(dir string, mode build.ImportMode, installSuffix string, buildTags []string) (*PackageData, error) {
bctx := NewBuildContext(installSuffix, buildTags)
pkg, err := bctx.ImportDir(dir, mode)
if err != nil {
return nil, err
}
jsFiles, err := jsFilesFromDir(bctx, pkg.Dir)
if err != nil {
return ni... | go | {
"resource": ""
} |
q24861 | hasGopathPrefix | train | func hasGopathPrefix(file, gopath string) (hasGopathPrefix bool, prefixLen int) {
gopathWorkspaces := filepath.SplitList(gopath)
for _, gopathWorkspace := range gopathWorkspaces {
gopathWorkspace = filepath.Clean(gopathWorkspace)
if strings.HasPrefix(file, gopathWorkspace) {
return true, len(gopathWorkspace)
... | go | {
"resource": ""
} |
q24862 | RlimitStack | train | func RlimitStack() (cur uint64, err error) {
var r unix.Rlimit
err = unix.Getrlimit(unix.RLIMIT_STACK, &r)
return uint64(r.Cur), err // Type conversion because Cur is one of uint64, int64 depending on unix flavor.
} | go | {
"resource": ""
} |
q24863 | convertArgs | train | func convertArgs(args ...interface{}) []interface{} {
newArgs := []interface{}{}
for _, arg := range args {
v := ValueOf(arg)
newArgs = append(newArgs, v.internal())
}
return newArgs
} | go | {
"resource": ""
} |
q24864 | bytesEqual | train | func bytesEqual(x, y []byte) bool {
if len(x) != len(y) {
return false
}
for i, b := range x {
if b != y[i] {
return false
}
}
return true
} | go | {
"resource": ""
} |
q24865 | bytesIndexByte | train | func bytesIndexByte(s []byte, c byte) int {
for i, b := range s {
if b == c {
return i
}
}
return -1
} | go | {
"resource": ""
} |
q24866 | handleError | train | func handleError(err error, options *gbuild.Options, browserErrors *bytes.Buffer) int {
switch err := err.(type) {
case nil:
return 0
case compiler.ErrorList:
for _, entry := range err {
printError(entry, options, browserErrors)
}
return 1
case *exec.ExitError:
return err.Sys().(syscall.WaitStatus).Exi... | go | {
"resource": ""
} |
q24867 | printError | train | func printError(err error, options *gbuild.Options, browserErrors *bytes.Buffer) {
e := sprintError(err)
options.PrintError("%s\n", e)
if browserErrors != nil {
fmt.Fprintln(browserErrors, `console.error("`+template.JSEscapeString(e)+`");`)
}
} | go | {
"resource": ""
} |
q24868 | sprintError | train | func sprintError(err error) string {
makeRel := func(name string) string {
if relname, err := filepath.Rel(currentDirectory, name); err == nil {
return relname
}
return name
}
switch e := err.(type) {
case *scanner.Error:
return fmt.Sprintf("%s:%d:%d: %s", makeRel(e.Pos.Filename), e.Pos.Line, e.Pos.Colu... | go | {
"resource": ""
} |
q24869 | runNode | train | func runNode(script string, args []string, dir string, quiet bool) error {
var allArgs []string
if b, _ := strconv.ParseBool(os.Getenv("SOURCE_MAP_SUPPORT")); os.Getenv("SOURCE_MAP_SUPPORT") == "" || b {
allArgs = []string{"--require", "source-map-support/register"}
if err := exec.Command("node", "--require", "so... | go | {
"resource": ""
} |
q24870 | New | train | func New(width, height int, fillColor color.Color) *image.NRGBA {
if width <= 0 || height <= 0 {
return &image.NRGBA{}
}
c := color.NRGBAModel.Convert(fillColor).(color.NRGBA)
if (c == color.NRGBA{0, 0, 0, 0}) {
return image.NewNRGBA(image.Rect(0, 0, width, height))
}
return &image.NRGBA{
Pix: bytes.Re... | go | {
"resource": ""
} |
q24871 | Clone | train | func Clone(img image.Image) *image.NRGBA {
src := newScanner(img)
dst := image.NewNRGBA(image.Rect(0, 0, src.w, src.h))
size := src.w * 4
parallel(0, src.h, func(ys <-chan int) {
for y := range ys {
i := y * dst.Stride
src.scan(0, y, src.w, y+1, dst.Pix[i:i+size])
}
})
return dst
} | go | {
"resource": ""
} |
q24872 | Crop | train | func Crop(img image.Image, rect image.Rectangle) *image.NRGBA {
r := rect.Intersect(img.Bounds()).Sub(img.Bounds().Min)
if r.Empty() {
return &image.NRGBA{}
}
src := newScanner(img)
dst := image.NewNRGBA(image.Rect(0, 0, r.Dx(), r.Dy()))
rowSize := r.Dx() * 4
parallel(r.Min.Y, r.Max.Y, func(ys <-chan int) {
... | go | {
"resource": ""
} |
q24873 | CropAnchor | train | func CropAnchor(img image.Image, width, height int, anchor Anchor) *image.NRGBA {
srcBounds := img.Bounds()
pt := anchorPt(srcBounds, width, height, anchor)
r := image.Rect(0, 0, width, height).Add(pt)
b := srcBounds.Intersect(r)
return Crop(img, b)
} | go | {
"resource": ""
} |
q24874 | CropCenter | train | func CropCenter(img image.Image, width, height int) *image.NRGBA {
return CropAnchor(img, width, height, Center)
} | go | {
"resource": ""
} |
q24875 | Paste | train | func Paste(background, img image.Image, pos image.Point) *image.NRGBA {
dst := Clone(background)
pos = pos.Sub(background.Bounds().Min)
pasteRect := image.Rectangle{Min: pos, Max: pos.Add(img.Bounds().Size())}
interRect := pasteRect.Intersect(dst.Bounds())
if interRect.Empty() {
return dst
}
src := newScanner(... | go | {
"resource": ""
} |
q24876 | PasteCenter | train | func PasteCenter(background, img image.Image) *image.NRGBA {
bgBounds := background.Bounds()
bgW := bgBounds.Dx()
bgH := bgBounds.Dy()
bgMinX := bgBounds.Min.X
bgMinY := bgBounds.Min.Y
centerX := bgMinX + bgW/2
centerY := bgMinY + bgH/2
x0 := centerX - img.Bounds().Dx()/2
y0 := centerY - img.Bounds().Dy()/2
... | go | {
"resource": ""
} |
q24877 | OverlayCenter | train | func OverlayCenter(background, img image.Image, opacity float64) *image.NRGBA {
bgBounds := background.Bounds()
bgW := bgBounds.Dx()
bgH := bgBounds.Dy()
bgMinX := bgBounds.Min.X
bgMinY := bgBounds.Min.Y
centerX := bgMinX + bgW/2
centerY := bgMinY + bgH/2
x0 := centerX - img.Bounds().Dx()/2
y0 := centerY - i... | go | {
"resource": ""
} |
q24878 | Rotate | train | func Rotate(img image.Image, angle float64, bgColor color.Color) *image.NRGBA {
angle = angle - math.Floor(angle/360)*360
switch angle {
case 0:
return Clone(img)
case 90:
return Rotate90(img)
case 180:
return Rotate180(img)
case 270:
return Rotate270(img)
}
src := toNRGBA(img)
srcW := src.Bounds().M... | go | {
"resource": ""
} |
q24879 | parallel | train | func parallel(start, stop int, fn func(<-chan int)) {
count := stop - start
if count < 1 {
return
}
procs := runtime.GOMAXPROCS(0)
if procs > count {
procs = count
}
c := make(chan int, count)
for i := start; i < stop; i++ {
c <- i
}
close(c)
var wg sync.WaitGroup
for i := 0; i < procs; i++ {
wg.... | go | {
"resource": ""
} |
q24880 | clamp | train | func clamp(x float64) uint8 {
v := int64(x + 0.5)
if v > 255 {
return 255
}
if v > 0 {
return uint8(v)
}
return 0
} | go | {
"resource": ""
} |
q24881 | rgbToHSL | train | func rgbToHSL(r, g, b uint8) (float64, float64, float64) {
rr := float64(r) / 255
gg := float64(g) / 255
bb := float64(b) / 255
max := math.Max(rr, math.Max(gg, bb))
min := math.Min(rr, math.Min(gg, bb))
l := (max + min) / 2
if max == min {
return 0, 0, l
}
var h, s float64
d := max - min
if l > 0.5 {
... | go | {
"resource": ""
} |
q24882 | hslToRGB | train | func hslToRGB(h, s, l float64) (uint8, uint8, uint8) {
var r, g, b float64
if s == 0 {
v := clamp(l * 255)
return v, v, v
}
var q float64
if l < 0.5 {
q = l * (1 + s)
} else {
q = l + s - l*s
}
p := 2*l - q
r = hueToRGB(p, q, h+1/3.0)
g = hueToRGB(p, q, h)
b = hueToRGB(p, q, h-1/3.0)
return clamp... | go | {
"resource": ""
} |
q24883 | resizeNearest | train | func resizeNearest(img image.Image, width, height int) *image.NRGBA {
dst := image.NewNRGBA(image.Rect(0, 0, width, height))
dx := float64(img.Bounds().Dx()) / float64(width)
dy := float64(img.Bounds().Dy()) / float64(height)
if dx > 1 && dy > 1 {
src := newScanner(img)
parallel(0, height, func(ys <-chan int) ... | go | {
"resource": ""
} |
q24884 | cropAndResize | train | func cropAndResize(img image.Image, width, height int, anchor Anchor, filter ResampleFilter) *image.NRGBA {
dstW, dstH := width, height
srcBounds := img.Bounds()
srcW := srcBounds.Dx()
srcH := srcBounds.Dy()
srcAspectRatio := float64(srcW) / float64(srcH)
dstAspectRatio := float64(dstW) / float64(dstH)
var tmp... | go | {
"resource": ""
} |
q24885 | resizeAndCrop | train | func resizeAndCrop(img image.Image, width, height int, anchor Anchor, filter ResampleFilter) *image.NRGBA {
dstW, dstH := width, height
srcBounds := img.Bounds()
srcW := srcBounds.Dx()
srcH := srcBounds.Dy()
srcAspectRatio := float64(srcW) / float64(srcH)
dstAspectRatio := float64(dstW) / float64(dstH)
var tmp... | go | {
"resource": ""
} |
q24886 | Grayscale | train | func Grayscale(img image.Image) *image.NRGBA {
src := newScanner(img)
dst := image.NewNRGBA(image.Rect(0, 0, src.w, src.h))
parallel(0, src.h, func(ys <-chan int) {
for y := range ys {
i := y * dst.Stride
src.scan(0, y, src.w, y+1, dst.Pix[i:i+src.w*4])
for x := 0; x < src.w; x++ {
d := dst.Pix[i : i+... | go | {
"resource": ""
} |
q24887 | Decode | train | func Decode(r io.Reader, opts ...DecodeOption) (image.Image, error) {
cfg := defaultDecodeConfig
for _, option := range opts {
option(&cfg)
}
if !cfg.autoOrientation {
img, _, err := image.Decode(r)
return img, err
}
var orient orientation
pr, pw := io.Pipe()
r = io.TeeReader(r, pw)
done := make(chan s... | go | {
"resource": ""
} |
q24888 | GIFQuantizer | train | func GIFQuantizer(quantizer draw.Quantizer) EncodeOption {
return func(c *encodeConfig) {
c.gifQuantizer = quantizer
}
} | go | {
"resource": ""
} |
q24889 | GIFDrawer | train | func GIFDrawer(drawer draw.Drawer) EncodeOption {
return func(c *encodeConfig) {
c.gifDrawer = drawer
}
} | go | {
"resource": ""
} |
q24890 | PNGCompressionLevel | train | func PNGCompressionLevel(level png.CompressionLevel) EncodeOption {
return func(c *encodeConfig) {
c.pngCompressionLevel = level
}
} | go | {
"resource": ""
} |
q24891 | fixOrientation | train | func fixOrientation(img image.Image, o orientation) image.Image {
switch o {
case orientationNormal:
case orientationFlipH:
img = FlipH(img)
case orientationFlipV:
img = FlipV(img)
case orientationRotate90:
img = Rotate90(img)
case orientationRotate180:
img = Rotate180(img)
case orientationRotate270:
i... | go | {
"resource": ""
} |
q24892 | NewTLSTransport | train | func NewTLSTransport(certFile, keyPath string, skipVerify bool) *Transport {
return &Transport{
certFile: certFile,
certKey: keyPath,
remoteEncrypted: true,
skipVerify: skipVerify,
}
} | go | {
"resource": ""
} |
q24893 | Open | train | func (t *Transport) Open(addr string) error {
ln, err := net.Listen("tcp", addr)
if err != nil {
return err
}
if t.certFile != "" {
config, err := createTLSConfig(t.certFile, t.certKey)
if err != nil {
return err
}
ln = tls.NewListener(ln, config)
}
t.ln = ln
return nil
} | go | {
"resource": ""
} |
q24894 | Dial | train | func (t *Transport) Dial(addr string, timeout time.Duration) (net.Conn, error) {
dialer := &net.Dialer{Timeout: timeout}
var err error
var conn net.Conn
if t.remoteEncrypted {
conf := &tls.Config{
InsecureSkipVerify: t.skipVerify,
}
fmt.Println("doing a TLS dial")
conn, err = tls.DialWithDialer(dialer, ... | go | {
"resource": ""
} |
q24895 | Prepare | train | func (h *HTTPTester) Prepare(stmt string, bSz int, tx bool) error {
s := make([]string, bSz)
for i := 0; i < len(s); i++ {
s[i] = stmt
}
b, err := json.Marshal(s)
if err != nil {
return err
}
h.br = bytes.NewReader(b)
if tx {
h.url = h.url + "?transaction"
}
return nil
} | go | {
"resource": ""
} |
q24896 | Once | train | func (h *HTTPTester) Once() (time.Duration, error) {
h.br.Seek(0, io.SeekStart)
start := time.Now()
resp, err := h.client.Post(h.url, "application/json", h.br)
if err != nil {
return 0, err
}
defer resp.Body.Close()
if resp.StatusCode != http.StatusOK {
return 0, fmt.Errorf("received %s", resp.Status)
}
... | go | {
"resource": ""
} |
q24897 | NumPeers | train | func NumPeers(raftDir string) (int, error) {
// Read the file
buf, err := ioutil.ReadFile(filepath.Join(raftDir, jsonPeerPath))
if err != nil && !os.IsNotExist(err) {
return 0, err
}
// Check for no peers
if len(buf) == 0 {
return 0, nil
}
// Decode the peers
var peerSet []string
dec := json.NewDecoder(... | go | {
"resource": ""
} |
q24898 | JoinAllowed | train | func JoinAllowed(raftDir string) (bool, error) {
n, err := NumPeers(raftDir)
if err != nil {
return false, err
}
return n <= 1, nil
} | go | {
"resource": ""
} |
q24899 | New | train | func New(ln Listener, c *StoreConfig) *Store {
logger := c.Logger
if logger == nil {
logger = log.New(os.Stderr, "[store] ", log.LstdFlags)
}
return &Store{
ln: ln,
raftDir: c.Dir,
raftID: c.ID,
dbConf: c.DBConf,
dbPath: filepath.Join(c.Dir, sqliteFile),
ran... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.