id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c14800 |
return rs.s2&mask == (^uint32(0))&mask
} | |
c14801 | func(i, j int) bool) Interface {
return &funcs{length, lessSwap{less, swap}}
} | |
c14802 | {
return MakeInterface(reflect.ValueOf(slice).Len(), reflectutil.Swapper(slice), less)
} | |
c14803 |
Sort(SliceSorter(slice, less))
} | |
c14804 |
quickSort_func(lessSwap{less, swap}, 0, length, maxDepth(length))
} | |
c14805 | r.Interface.Less(j, i)
} | |
c14806 | {
if data.Less(i, i-1) {
return false
}
}
return true
} | |
c14807 | ife.ItemType == "Exif" {
return uint32(ife.ItemID)
}
}
return 0
} | |
c14808 | {
return int(p.ImageWidth), int(p.ImageHeight), true
}
}
return
} | |
c14809 | < it.Rotations(); i++ {
width, height = height, width
}
return
} | |
c14810 | }
if meta.PrimaryItem == nil {
return nil, errors.New("heif: HEIF file lacks primary item box")
}
return f.ItemByID(uint32(meta.PrimaryItem.ItemID))
} | |
c14811 | previous loop
// found anything.
if len(it.Properties) > 0 {
break
}
for _, ipai := range ipa.Entries {
if ipai.ItemID != id {
continue
}
for _, ass := range ipai.Associations {
if ass.Index != 0 && int(ass.Index) <= len(allProps) {
box := allProps[ass.Index-1]
boxp, ... | |
c14812 | sync.NewCond(new(sync.Mutex)),
free: max,
max: max,
}
} | |
c14813 | n)
if s.free >= n {
s.free -= n
return nil
}
debug.Printf("Acquire Wait max %d free %d, n %d", s.max, s.free, n)
s.c.Wait()
}
} | |
c14814 |
debug.Printf("Release max %d free %d, n %d", s.max, s.free, n)
s.free += n
s.c.Broadcast()
} | |
c14815 | if err != nil {
return ""
}
if !info.IsDir() || info.Mode().Perm() != 0700 {
return ""
}
st, ok := info.Sys().(*syscall.Stat_t)
if !ok || int(st.Uid) != geteuid() {
return ""
}
}
return p
} | |
c14816 |
} else if !os.IsNotExist(err) {
firstErr = err
}
}
if firstErr != nil {
return nil, firstErr
}
return nil, &os.PathError{
Op: "Open",
Path: filepath.Join("$"+d.env, name),
Err: os.ErrNotExist,
}
} | |
c14817 | return &varStatReader{v, r}
} | |
c14818 | io.ReadSeeker {
return &varStatReadSeeker{v, rs}
} | |
c14819 | ")
buf.WriteString(strconv.FormatInt(w.skipped, 10))
buf.WriteString(" bytes ...\n")
buf.Write(w.suffix[w.suffixOff:])
buf.Write(w.suffix[:w.suffixOff])
return buf.Bytes()
} | |
c14820 | %q", b))
}
b = b[:i]
n, err := strutil.ParseUintBytes(b, 10, 64)
if err != nil {
panic(fmt.Sprintf("Failed to parse goroutine ID out of %q: %v", b, err))
}
return int64(n)
} | |
c14821 | in.failPercent > rand.Intn(100)
} | |
c14822 | return false
}
*err = fakeErr
return true
} | |
c14823 | range jc {
if ok && known[k] {
continue
}
if strings.HasPrefix(k, "_") {
// Permit keys with a leading underscore as a
// form of comments.
continue
}
unknown = append(unknown, k)
}
sort.Strings(unknown)
return unknown
} | |
c14824 |
if len(g.errs) > 0 {
return g.errs[0]
}
return nil
} | |
c14825 | = byte(i)
}
// The first occurrence of old->new map takes precedence
// over the others with the same old string.
for i := len(oldnew) - 2; i >= 0; i -= 2 {
o := oldnew[i][0]
n := oldnew[i+1][0]
r[o] = n
}
return &Replacer{r: &r}
}
return &Replacer{r: makeGenericReplacer(oldnew)}
} | |
c14826 | return r.r.Replace(s)
} | |
c14827 | }
size = end - pos
pos1, err := rt.Seek(pos, os.SEEK_SET)
if err != nil || pos1 != pos {
msg := "failed to restore seek position"
if err != nil {
msg += ": " + err.Error()
}
panic(msg)
}
return size, true
}
return 0, false
} | |
c14828 | case. SimpleFold(x) returns the next equivalent rune > x
// or wraps around to smaller values.
r := unicode.SimpleFold(sr)
for r != sr && r < tr {
r = unicode.SimpleFold(r)
}
if r == tr {
return true
}
return false
} | |
c14829 | if sr == utf8.RuneError {
return false
}
s = s[size:]
if !equalFoldRune(sr, pr) {
return false
}
}
return true
} | |
c14830 |
r, size := utf8.DecodeLastRuneInString(s[:bo])
if r == utf8.RuneError {
return false
}
bo -= size
sr, size := utf8.DecodeLastRuneInString(suffix[:so])
if sr == utf8.RuneError {
return false
}
so -= size
if !equalFoldRune(r, sr) {
return false
}
}
return so == 0
} | |
c14831 | s {
if equalFoldRune(rune, firstRune) && HasPrefixFold(s[i:], substr) {
return true
}
}
return false
} | |
c14832 |
if err != nil {
return nil, err
}
of = resi.(*openFile)
// If our os.Open was dup-suppressed, we have to increment our
// reference count.
if !winner {
openFileMu.Lock()
if of.refCount == 0 {
// Winner already closed it. Try again (rare).
openFileMu.Unlock()
return Open(path)
}
of.refCount++
... | |
c14833 |
}
imageURL := ""
var max time.Time // latest stable image creation time
for _, v := range imageList.Items {
if !strings.HasPrefix(v.Name, "coreos-stable") {
continue
}
if v.CreationTimestamp.After(max) {
max = v.CreationTimestamp
imageURL = v.SelfLink
}
}
if imageURL == "" {
return "", errors... | |
c14834 | return nil, err
}
if groupList.NextPageToken != "" {
return nil, errors.New("too many instance groups; pagination not supported")
}
ret := make(map[string]InstanceGroupAndManager)
for _, it := range groupList.Items {
ret[it.SelfLink] = InstanceGroupAndManager{it, managedBy[it.SelfLink]}
}
return ret, nil
} | |
c14835 |
return nil, err
}
defer rc.Close()
slurp, err := ioutil.ReadAll(io.LimitReader(rc, size))
if err != nil {
return nil, err
}
return &file{
name: name,
Reader: bytes.NewReader(slurp),
}, nil
} | |
c14836 | lx; i++ {
r[i] = x[lx-i]
}
r = FFT(r)
N := complex(float64(lx), 0)
for n := range r {
r[n] /= N
}
return r
} | |
c14837 | r
}
if dsputils.IsPowerOf2(lx) {
return radix2FFT(x)
}
return bluesteinFFT(x)
} | |
c14838 | = d[i]
} else {
x[i] -= 1
return true
}
}
// no decrement
return false
} else {
x[n] -= 1
return true
}
}
return false
} | |
c14839 | b[i] = factors[i]
if i != 0 {
b[la-i] = factors[i]
}
}
r := Convolve(a, b)
for i := 0; i < lx; i++ {
r[i] *= invFactors[i]
}
return r[:lx]
} | |
c14840 | case wavFormatPCM:
case wavFormatIEEEFloat:
default:
return nil, fmt.Errorf("wav: unknown audio format: %02x", w.AudioFormat)
}
hasFmt = true
case "data":
if !hasFmt {
return nil, fmt.Errorf("wav: unexpected fmt chunk")
}
w.Samples = int(sz) / int(w.BitsPerSample) * 8
w.Duration = t... | |
c14841 | f[i] = (float32(v) - math.MinInt16) / (math.MaxInt16 - math.MinInt16)
}
case []float32:
f = d
default:
return nil, fmt.Errorf("wav: unknown type: %T", d)
}
return f, nil
} | |
c14842 | int(math.Pow(2, math.Ceil(math.Log2(float64(x)))))
} | |
c14843 | v := range x {
y[n] = ToComplex(v)
}
return y
} | |
c14844 | }
if length == 0 {
panic("too many segments")
}
r := make([][]complex128, segs)
s := 0
for n := range r {
r[n] = x[s : s+length]
s += step
}
return r
} | |
c14845 |
}
}
wg.Done()
}
}
for i := 0; i < num_workers; i++ {
go worker()
}
defer close(jobs)
for stage = 2; stage <= lx; stage <<= 1 {
blocks = lx / stage
s_2 = stage / 2
for start, end := 0, stage; ; {
if end-start >= idx_diff || end == lx {
wg.Add(1)
jobs <- &fft_work{start, end}
... | |
c14846 | uint
for ; n < lx; n++ {
r[reverseBits(n, s)] = x[n]
}
return r
} | |
c14847 | []float64) {
for i, w := range windowFunction(len(x)) {
x[i] *= w
}
} | |
c14848 |
}
for i, c := range a {
if !Float64Equal(c, b[i]) {
return false
}
}
return true
} | |
c14849 |
}
for i, c := range a {
if !ComplexEqual(c, b[i]) {
return false
}
}
return true
} | |
c14850 |
return Float64Equal(r_a, r_b) && Float64Equal(i_a, i_b)
} | |
c14851 | math.Abs(a-b) <= closeFactor || math.Abs(1-a/b) <= closeFactor
} | |
c14852 | panic("ragged array")
}
copy(r[n*dims[1]:(n+1)*dims[1]], v)
}
return MakeMatrix(r, dims)
} | |
c14853 | make([]complex128, len(m.list))
copy(r.list, m.list)
return r
} | |
c14854 | v := range dims {
x *= v
}
return MakeMatrix(make([]complex128, x), dims)
} | |
c14855 | v > s.dims[n] {
panic("incorrect dimensions")
}
i += v * s.offsets[n]
}
return i
} | |
c14856 | r := make([]int, len(m.dims))
copy(r, m.dims)
return r
} | |
c14857 | m.dims[0])
for i := 0; i < m.dims[0]; i++ {
r[i] = make([]complex128, m.dims[1])
copy(r[i], m.list[i*m.dims[1]:(i+1)*m.dims[1]])
}
return r
} | |
c14858 | if err != nil {
http.Error(w, http.StatusText(401), 401)
return
}
if token == nil || !token.Valid {
http.Error(w, http.StatusText(401), 401)
return
}
// Token is authenticated, pass it through
next.ServeHTTP(w, r)
})
} | |
c14859 | err := r.Cookie("jwt")
if err != nil {
return ""
}
return cookie.Value
} | |
c14860 | time.Millisecond*100)
if err != nil {
return nil, err
}
return &lock{c}, nil
} | |
c14861 | address provided")
}
p := newPool(lockerConfig.Address[0], "")
return &locker{p}, nil
} | |
c14862 |
regexp.MustCompile(baseMethod + "Get"),
regexp.MustCompile(baseMethod + "List"),
}
} | |
c14863 | error) {
stripe.Key = paymentConfig.Secret
stripe.Logger = logrus.New()
return &provider{}, nil
} | |
c14864 | range c.Scopes {
if methods, ok := accessMap[v]; ok {
m = append(m, methods...)
}
}
return m
} | |
c14865 | if r.MatchString(fullMethod) {
return true
}
}
}
return false
} | |
c14866 | error
switch x := p.(type) {
case *logrus.Entry:
return status.Errorf(codes.Internal, "%s", x.Message)
}
return status.Errorf(codes.Internal, "%s", p)
} | |
c14867 | 1) {
break
}
time.Sleep(defaultRetrySleep)
log.Error("retrying after error:", err)
}
return fmt.Errorf("after %d attempts, last error: %s", defaultRetryAttempts, err)
} | |
c14868 |
Username: s.Username,
Password: s.Password,
Addrs: s.Address,
Database: s.Database,
},
database: s.Database,
}
return h
} | |
c14869 | opt.CaCrt != "" {
certPool := x509.NewCertPool()
bs, err := ioutil.ReadFile(opt.CaCrt)
if err != nil {
return nil, err
}
ok := certPool.AppendCertsFromPEM(bs)
if !ok {
return nil, fmt.Errorf("failed to append certs")
}
tlsConf.InsecureSkipVerify = false
tlsConf.RootCAs = certPool
}
dailOpts ... | |
c14870 | err != nil {
log.Fatalf("Could not create locker handler => %s", err.Error())
}
// load ca clients
client.New(conf.Clients)
providers.New(conf.Payment)
lis, err := net.Listen("tcp", conf.Address)
if err != nil {
log.Fatalf("failed to listen: %v", err)
}
log.Infof("Listening on %s", conf.Address)
return ... | |
c14871 | if v, ok := providers[p]; ok {
return v
}
log.Panicf("payment provider %s isn't registered", p.String())
return nil
} | |
c14872 | != nil {
return ctx
}
return context.WithValue(ctx, clientKey{}, c)
} | |
c14873 | ok := ctx.Value(clientKey{}).(*Client)
return u, ok
} | |
c14874 | range clients {
if c.Serial == serialId {
return &c, nil
}
}
return nil, errors.New("Cant find client.")
} | |
c14875 | := err.(validator.ValidationErrors); ok {
err = v
}
return status.Errorf(codes.InvalidArgument, "Request validation failed: %s", err)
}
return nil
} | |
c14876 | default:
return errors.New("Invalid storage handler `" + storageConfig.Handler + "`")
}
// prepare handler
return handler.Prepare()
} | |
c14877 | = zookeeper.NewLocker(lockerConfig)
return err
case redisHandler:
handler, err = redis.NewLocker(lockerConfig)
return err
default:
handler = memlock.NewLocker()
}
return nil
} | |
c14878 | amount return err
if amount > o.GetAmount() {
return status.Error(codes.Internal, "Refund amount is greater then order amount.")
}
return nil
} | |
c14879 | err
}
// update order items
o.Items = orderItems
// calculate final amount
amount, err := calculateTotal(o.GetCurrency(), orderItems)
if err != nil {
return nil, err
}
// update order amount
o.Amount = amount
// Insert and return order
return &o.Order, storage.Handler().Insert(o)
} | |
c14880 | }
// acquire order lock
unlock, err := locker.Handler().TryLock(o, locker.DefaultTimeout)
if err != nil {
return nil, err
}
defer unlock()
// get and return order
return &o.Order, storage.Handler().One(o)
} | |
c14881 | item.Unlock()
}
}()
// refund the order
if _, err := payment.Service().RefundCharge(ctx, &paymentpb.RefundRequest{Id: o.GetChargeId(), Amount: uint64(amount)}); err != nil {
return nil, err
}
// update order status
switch o.Status {
// if the order has been paid but never fulfilled
// order status turns f... | |
c14882 | }
m, err = m.Add(money.New(v.Quantity*v.Amount, v.Currency.String()))
if err != nil {
return 0, status.Error(codes.Internal, err.Error())
}
}
return m.Amount(), nil
} | |
c14883 | regexp.MustCompile(baseMethod + "RefundCharge"),
}
} | |
c14884 | clockFn(func() time.Time {
return time.Now().In(loc)
}))
} | |
c14885 | optkeyHandler:
handler = o.Value().(Handler)
}
}
if maxAge > 0 && rotationCount > 0 {
return nil, errors.New("options MaxAge and RotationCount cannot be both set")
}
if maxAge == 0 && rotationCount == 0 {
// if both are 0, give maxAge a sane default
maxAge = 7 * 24 * time.Hour
}
return &RotateLogs{... | |
c14886 |
out, err := rl.getWriter_nolock(false, false)
if err != nil {
return 0, errors.Wrap(err, `failed to acquite target io.Writer`)
}
return out.Write(p)
} | |
c14887 | rl.pattern, err)
}
if err := rl.rotate_nolock(filename); err != nil {
err = errors.Wrap(err, "failed to rotate")
if bailOnRotateFail {
// Failure to rotate is a problem, but it's really not a great
// idea to stop your application just because you couldn't rename
// your log.
//
// We only return... | |
c14888 | defer rl.mutex.RUnlock()
return rl.curFn
} | |
c14889 | := rl.getWriter_nolock(true, true); err != nil {
return err
}
return nil
} | |
c14890 | return nil
}
rl.outFh.Close()
rl.outFh = nil
return nil
} | |
c14891 | {
if enableColor {
return m.ColorfulText
}
return m.RawText
} | |
c14892 | Printer: pio.NewPrinter("", os.Stdout).EnableDirectOutput().Hijack(logHijacker),
children: newLoggerMap(),
}
} | |
c14893 | }
log.NewLine = withPrintln
log.Time = time.Now()
log.Level = level
log.Message = msg
return log
} | |
c14894 | *Logger {
l.Printer.SetOutput(w)
return l
} | |
c14895 | l.Prefix = []byte(s)
l.mu.Unlock()
return l
} | |
c14896 | l.TimeFormat = s
l.mu.Unlock()
return l
} | |
c14897 | l.NewLine = false
l.mu.Unlock()
return l
} | |
c14898 | {
l.print(DisableLevel, fmt.Sprint(v...), l.NewLine)
} | |
c14899 | l.print(DisableLevel, fmt.Sprint(v...), true)
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.