_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3 values | text stringlengths 52 85.5k | language stringclasses 1 value | meta_information dict |
|---|---|---|---|---|---|
q14800 | OnSplitWithBits | train | func (rs *RollSum) OnSplitWithBits(n uint32) bool {
mask := (uint32(1) << n) - 1
return rs.s2&mask == (^uint32(0))&mask
} | go | {
"resource": ""
} |
q14801 | MakeInterface | train | func MakeInterface(length int, swap func(i, j int), less func(i, j int) bool) Interface {
return &funcs{length, lessSwap{less, swap}}
} | go | {
"resource": ""
} |
q14802 | SliceSorter | train | func SliceSorter(slice interface{}, less func(i, j int) bool) Interface {
return MakeInterface(reflect.ValueOf(slice).Len(), reflectutil.Swapper(slice), less)
} | go | {
"resource": ""
} |
q14803 | Slice | train | func Slice(slice interface{}, less func(i, j int) bool) {
Sort(SliceSorter(slice, less))
} | go | {
"resource": ""
} |
q14804 | With | train | func With(length int, swap func(i, j int), less func(i, j int) bool) {
quickSort_func(lessSwap{less, swap}, 0, length, maxDepth(length))
} | go | {
"resource": ""
} |
q14805 | Less | train | func (r reverse) Less(i, j int) bool {
return r.Interface.Less(j, i)
} | go | {
"resource": ""
} |
q14806 | IsSorted | train | func IsSorted(data Interface) bool {
n := data.Len()
for i := n - 1; i > 0; i-- {
if data.Less(i, i-1) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q14807 | EXIFItemID | train | func (m *BoxMeta) EXIFItemID() uint32 {
if m.ItemInfo == nil {
return 0
}
for _, ife := range m.ItemInfo.ItemInfos {
if ife.ItemType == "Exif" {
return uint32(ife.ItemID)
}
}
return 0
} | go | {
"resource": ""
} |
q14808 | SpatialExtents | train | func (it *Item) SpatialExtents() (width, height int, ok bool) {
for _, p := range it.Properties {
if p, ok := p.(*bmff.ImageSpatialExtentsProperty); ok {
return int(p.ImageWidth), int(p.ImageHeight), true
}
}
return
} | go | {
"resource": ""
} |
q14809 | VisualDimensions | train | func (it *Item) VisualDimensions() (width, height int, ok bool) {
width, height, ok = it.SpatialExtents()
for i := 0; i < it.Rotations(); i++ {
width, height = height, width
}
return
} | go | {
"resource": ""
} |
q14810 | PrimaryItem | train | func (f *File) PrimaryItem() (*Item, error) {
meta, err := f.getMeta()
if err != nil {
return nil, err
}
if meta.PrimaryItem == nil {
return nil, errors.New("heif: HEIF file lacks primary item box")
}
return f.ItemByID(uint32(meta.PrimaryItem.ItemID))
} | go | {
"resource": ""
} |
q14811 | ItemByID | train | func (f *File) ItemByID(id uint32) (*Item, error) {
meta, err := f.getMeta()
if err != nil {
return nil, err
}
it := &Item{
f: f,
ID: id,
}
if meta.ItemLocation != nil {
for _, ilbe := range meta.ItemLocation.Items {
if uint32(ilbe.ItemID) == id {
shallowCopy := ilbe
it.Location = &shallowCopy
}
}
}
if meta.ItemInfo != nil {
for _, iie := range meta.ItemInfo.ItemInfos {
if uint32(iie.ItemID) == id {
it.Info = iie
}
}
}
if it.Info == nil {
return nil, ErrUnknownItem
}
if meta.Properties != nil {
allProps := meta.Properties.PropertyContainer.Properties
for _, ipa := range meta.Properties.Associations {
// TODO: I've never seen a file with more than
// top-level ItemPropertyAssociation box, but
// apparently they can exist with different
// versions/flags. For now we just merge them
// all together, but that's not really right.
// So for now, just bail once a 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, err := box.Parse()
if err == nil {
box = boxp
}
it.Properties = append(it.Properties, box)
}
}
}
}
}
return it, nil
} | go | {
"resource": ""
} |
q14812 | NewSem | train | func NewSem(max int64) *Sem {
return &Sem{
c: sync.NewCond(new(sync.Mutex)),
free: max,
max: max,
}
} | go | {
"resource": ""
} |
q14813 | Acquire | train | func (s *Sem) Acquire(n int64) error {
if n > s.max {
return fmt.Errorf("sem: attempt to acquire more units than semaphore size %d > %d", n, s.max)
}
s.c.L.Lock()
defer s.c.L.Unlock()
for {
debug.Printf("Acquire check max %d free %d, n %d", s.max, s.free, 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()
}
} | go | {
"resource": ""
} |
q14814 | Release | train | func (s *Sem) Release(n int64) {
s.c.L.Lock()
defer s.c.L.Unlock()
debug.Printf("Release max %d free %d, n %d", s.max, s.free, n)
s.free += n
s.c.Broadcast()
} | go | {
"resource": ""
} |
q14815 | Path | train | func (d Dir) Path() string {
if d.env == "" {
panic("xdgdir.Dir.Path() on zero Dir")
}
p := d.path()
if p != "" && d.userOwned {
info, err := os.Stat(p)
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
} | go | {
"resource": ""
} |
q14816 | Open | train | func (d Dir) Open(name string) (*os.File, error) {
if d.env == "" {
return nil, errors.New("xdgdir: Open on zero Dir")
}
paths := d.SearchPaths()
if len(paths) == 0 {
return nil, fmt.Errorf("xdgdir: open %s: %s is invalid or not set", name, d.env)
}
var firstErr error
for _, p := range paths {
f, err := os.Open(filepath.Join(p, name))
if err == nil {
return f, nil
} 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,
}
} | go | {
"resource": ""
} |
q14817 | NewStatsReader | train | func NewStatsReader(v *expvar.Int, r io.Reader) io.Reader {
return &varStatReader{v, r}
} | go | {
"resource": ""
} |
q14818 | NewStatsReadSeeker | train | func NewStatsReadSeeker(v *expvar.Int, rs io.ReadSeeker) io.ReadSeeker {
return &varStatReadSeeker{v, rs}
} | go | {
"resource": ""
} |
q14819 | Bytes | train | func (w *PrefixSuffixSaver) Bytes() []byte {
if w.suffix == nil {
return w.prefix
}
if w.skipped == 0 {
return append(w.prefix, w.suffix...)
}
var buf bytes.Buffer
buf.Grow(len(w.prefix) + len(w.suffix) + 50)
buf.Write(w.prefix)
buf.WriteString("\n... omitting ")
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()
} | go | {
"resource": ""
} |
q14820 | GoroutineID | train | func GoroutineID() int64 {
b := getBuf()
defer putBuf(b)
b = b[:runtime.Stack(b, false)]
// Parse the 4707 out of "goroutine 4707 ["
b = bytes.TrimPrefix(b, goroutineSpace)
i := bytes.IndexByte(b, ' ')
if i < 0 {
panic(fmt.Sprintf("No space found in %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)
} | go | {
"resource": ""
} |
q14821 | ShouldFail | train | func (in *Injector) ShouldFail() bool {
return in.failPercent > 0 && in.failPercent > rand.Intn(100)
} | go | {
"resource": ""
} |
q14822 | FailErr | train | func (in *Injector) FailErr(err *error) bool {
if !in.ShouldFail() {
return false
}
*err = fakeErr
return true
} | go | {
"resource": ""
} |
q14823 | UnknownKeys | train | func (jc Obj) UnknownKeys() []string {
ei, ok := jc["_knownkeys"]
var known map[string]bool
if ok {
known = ei.(map[string]bool)
}
var unknown []string
for k, _ := 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
} | go | {
"resource": ""
} |
q14824 | Err | train | func (g *Group) Err() error {
g.wg.Wait()
if len(g.errs) > 0 {
return g.errs[0]
}
return nil
} | go | {
"resource": ""
} |
q14825 | New | train | func New(oldnew ...string) *Replacer {
if len(oldnew)%2 == 1 {
panic("bytes.NewReplacer: odd argument count")
}
allNewBytes := true
for i := 0; i < len(oldnew); i += 2 {
if len(oldnew[i]) != 1 {
return &Replacer{r: makeGenericReplacer(oldnew)}
}
if len(oldnew[i+1]) != 1 {
allNewBytes = false
}
}
if allNewBytes {
r := byteReplacer{}
for i := range r {
r[i] = 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)}
} | go | {
"resource": ""
} |
q14826 | Replace | train | func (r *Replacer) Replace(s []byte) []byte {
return r.r.Replace(s)
} | go | {
"resource": ""
} |
q14827 | Size | train | func Size(r io.Reader) (size int64, ok bool) {
switch rt := r.(type) {
case *bytes.Buffer:
return int64(rt.Len()), true
case *bytes.Reader:
return int64(rt.Len()), true
case *strings.Reader:
return int64(rt.Len()), true
case io.Seeker:
pos, err := rt.Seek(0, os.SEEK_CUR)
if err != nil {
return
}
end, err := rt.Seek(0, os.SEEK_END)
if err != nil {
return
}
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
} | go | {
"resource": ""
} |
q14828 | equalFoldRune | train | func equalFoldRune(sr, tr rune) bool {
if sr == tr {
return true
}
// Make sr < tr to simplify what follows.
if tr < sr {
sr, tr = tr, sr
}
// Fast check for ASCII.
if tr < utf8.RuneSelf && 'A' <= sr && sr <= 'Z' {
// ASCII, and sr is upper case. tr must be lower case.
if tr == sr+'a'-'A' {
return true
}
return false
}
// General 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
} | go | {
"resource": ""
} |
q14829 | HasPrefixFold | train | func HasPrefixFold(s, prefix string) bool {
if prefix == "" {
return true
}
for _, pr := range prefix {
if s == "" {
return false
}
// step with s, too
sr, size := utf8.DecodeRuneInString(s)
if sr == utf8.RuneError {
return false
}
s = s[size:]
if !equalFoldRune(sr, pr) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q14830 | HasSuffixFold | train | func HasSuffixFold(s, suffix string) bool {
if suffix == "" {
return true
}
// count the runes and bytes in s, but only till rune count of suffix
bo, so := len(s), len(suffix)
for bo > 0 && so > 0 {
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
} | go | {
"resource": ""
} |
q14831 | ContainsFold | train | func ContainsFold(s, substr string) bool {
if substr == "" {
return true
}
if s == "" {
return false
}
firstRune := rune(substr[0])
if firstRune >= utf8.RuneSelf {
firstRune, _ = utf8.DecodeRuneInString(substr)
}
for i, rune := range s {
if equalFoldRune(rune, firstRune) && HasPrefixFold(s[i:], substr) {
return true
}
}
return false
} | go | {
"resource": ""
} |
q14832 | Open | train | func Open(path string) (readerutil.ReaderAtCloser, error) {
openFileMu.Lock()
of := openFiles[path]
if of != nil {
of.refCount++
openFileMu.Unlock()
return &openFileHandle{false, of}, nil
}
openFileMu.Unlock() // release the lock while we call os.Open
winner := false // this goroutine made it into Do's func
// Returns an *openFile
resi, err := openerGroup.Do(path, func() (interface{}, error) {
winner = true
f, err := wkfs.Open(path)
if err != nil {
return nil, err
}
of := &openFile{
File: f,
path: path,
refCount: 1,
}
openFileMu.Lock()
openFiles[path] = of
openFileMu.Unlock()
return of, nil
})
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++
openFileMu.Unlock()
}
return &openFileHandle{false, of}, nil
} | go | {
"resource": ""
} |
q14833 | CoreOSImageURL | train | func CoreOSImageURL(cl *http.Client) (string, error) {
resp, err := cl.Get("https://www.googleapis.com/compute/v1/projects/coreos-cloud/global/images")
if err != nil {
return "", err
}
defer resp.Body.Close()
type coreOSImage struct {
SelfLink string
CreationTimestamp time.Time
Name string
}
type coreOSImageList struct {
Items []coreOSImage
}
imageList := &coreOSImageList{}
if err := json.NewDecoder(resp.Body).Decode(imageList); err != nil {
return "", err
}
if imageList == nil || len(imageList.Items) == 0 {
return "", errors.New("no images list in response")
}
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.New("no stable coreOS image found")
}
return imageURL, nil
} | go | {
"resource": ""
} |
q14834 | InstanceGroups | train | func InstanceGroups(svc *compute.Service, proj, zone string) (map[string]InstanceGroupAndManager, error) {
managerList, err := svc.InstanceGroupManagers.List(proj, zone).Do()
if err != nil {
return nil, err
}
if managerList.NextPageToken != "" {
return nil, errors.New("too many managers; pagination not supported")
}
managedBy := make(map[string]*compute.InstanceGroupManager) // instance group URL -> its manager
for _, it := range managerList.Items {
managedBy[it.InstanceGroup] = it
}
groupList, err := svc.InstanceGroups.List(proj, zone).Do()
if err != nil {
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
} | go | {
"resource": ""
} |
q14835 | Open | train | func (fs *gcsFS) Open(name string) (wkfs.File, error) {
bucket, fileName, err := fs.parseName(name)
if err != nil {
return nil, err
}
obj := fs.sc.Bucket(bucket).Object(fileName)
attrs, err := obj.Attrs(fs.ctx)
if err != nil {
return nil, err
}
size := attrs.Size
if size > maxSize {
return nil, fmt.Errorf("file %s too large (%d bytes) for /gcs/ filesystem", name, size)
}
rc, err := obj.NewReader(fs.ctx)
if err != nil {
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
} | go | {
"resource": ""
} |
q14836 | IFFT | train | func IFFT(x []complex128) []complex128 {
lx := len(x)
r := make([]complex128, lx)
// Reverse inputs, which is calculated with modulo N, hence x[0] as an outlier
r[0] = x[0]
for i := 1; i < lx; i++ {
r[i] = x[lx-i]
}
r = FFT(r)
N := complex(float64(lx), 0)
for n := range r {
r[n] /= N
}
return r
} | go | {
"resource": ""
} |
q14837 | FFT | train | func FFT(x []complex128) []complex128 {
lx := len(x)
// todo: non-hack handling length <= 1 cases
if lx <= 1 {
r := make([]complex128, lx)
copy(r, x)
return r
}
if dsputils.IsPowerOf2(lx) {
return radix2FFT(x)
}
return bluesteinFFT(x)
} | go | {
"resource": ""
} |
q14838 | decrDim | train | func decrDim(x, d []int) bool {
for n, v := range x {
if v == -1 {
continue
} else if v == 0 {
i := n
// find the next element to decrement
for ; i < len(x); i++ {
if x[i] == -1 {
continue
} else if x[i] == 0 {
x[i] = d[i]
} else {
x[i] -= 1
return true
}
}
// no decrement
return false
} else {
x[n] -= 1
return true
}
}
return false
} | go | {
"resource": ""
} |
q14839 | bluesteinFFT | train | func bluesteinFFT(x []complex128) []complex128 {
lx := len(x)
a := dsputils.ZeroPad(x, dsputils.NextPowerOf2(lx*2-1))
la := len(a)
factors, invFactors := getBluesteinFactors(lx)
for n, v := range x {
a[n] = v * invFactors[n]
}
b := make([]complex128, la)
for i := 0; i < lx; i++ {
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]
} | go | {
"resource": ""
} |
q14840 | New | train | func New(r io.Reader) (*Wav, error) {
var w Wav
header := make([]byte, 16)
if _, err := io.ReadFull(r, header[:12]); err != nil {
return nil, err
}
if string(header[0:4]) != "RIFF" {
return nil, fmt.Errorf("wav: missing RIFF")
}
if string(header[8:12]) != "WAVE" {
return nil, fmt.Errorf("wav: missing WAVE")
}
hasFmt := false
for {
if _, err := io.ReadFull(r, header[:8]); err != nil {
return nil, err
}
sz := binary.LittleEndian.Uint32(header[4:])
switch typ := string(header[:4]); typ {
case "fmt ":
if sz < 16 {
return nil, fmt.Errorf("wav: bad fmt size")
}
f := make([]byte, sz)
if _, err := io.ReadFull(r, f); err != nil {
return nil, err
}
if err := binary.Read(bytes.NewBuffer(f), binary.LittleEndian, &w.Header); err != nil {
return nil, err
}
switch w.AudioFormat {
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 = time.Duration(w.Samples) * time.Second / time.Duration(w.SampleRate) / time.Duration(w.NumChannels)
w.r = io.LimitReader(r, int64(sz))
return &w, nil
default:
io.CopyN(ioutil.Discard, r, int64(sz))
}
}
} | go | {
"resource": ""
} |
q14841 | ReadFloats | train | func (w *Wav) ReadFloats(n int) ([]float32, error) {
d, err := w.ReadSamples(n)
if err != nil {
return nil, err
}
var f []float32
switch d := d.(type) {
case []uint8:
f = make([]float32, len(d))
for i, v := range d {
f[i] = float32(v) / math.MaxUint8
}
case []int16:
f = make([]float32, len(d))
for i, v := range d {
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
} | go | {
"resource": ""
} |
q14842 | NextPowerOf2 | train | func NextPowerOf2(x int) int {
if IsPowerOf2(x) {
return x
}
return int(math.Pow(2, math.Ceil(math.Log2(float64(x)))))
} | go | {
"resource": ""
} |
q14843 | ToComplex2 | train | func ToComplex2(x [][]float64) [][]complex128 {
y := make([][]complex128, len(x))
for n, v := range x {
y[n] = ToComplex(v)
}
return y
} | go | {
"resource": ""
} |
q14844 | Segment | train | func Segment(x []complex128, segs int, noverlap float64) [][]complex128 {
lx := len(x)
// determine step, length, and overlap
var overlap, length, step, tot int
for length = lx; length > 0; length-- {
overlap = int(float64(length) * noverlap)
tot = segs*(length-overlap) + overlap
if tot <= lx {
step = length - overlap
break
}
}
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
} | go | {
"resource": ""
} |
q14845 | radix2FFT | train | func radix2FFT(x []complex128) []complex128 {
lx := len(x)
factors := getRadix2Factors(lx)
t := make([]complex128, lx) // temp
r := reorderData(x)
var blocks, stage, s_2 int
jobs := make(chan *fft_work, lx)
wg := sync.WaitGroup{}
num_workers := worker_pool_size
if (num_workers) == 0 {
num_workers = runtime.GOMAXPROCS(0)
}
idx_diff := lx / num_workers
if idx_diff < 2 {
idx_diff = 2
}
worker := func() {
for work := range jobs {
for nb := work.start; nb < work.end; nb += stage {
if stage != 2 {
for j := 0; j < s_2; j++ {
idx := j + nb
idx2 := idx + s_2
ridx := r[idx]
w_n := r[idx2] * factors[blocks*j]
t[idx] = ridx + w_n
t[idx2] = ridx - w_n
}
} else {
n1 := nb + 1
rn := r[nb]
rn1 := r[n1]
t[nb] = rn + rn1
t[n1] = rn - rn1
}
}
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}
if end == lx {
break
}
start = end
}
end += stage
}
wg.Wait()
r, t = t, r
}
return r
} | go | {
"resource": ""
} |
q14846 | reorderData | train | func reorderData(x []complex128) []complex128 {
lx := uint(len(x))
r := make([]complex128, lx)
s := log2(lx)
var n uint
for ; n < lx; n++ {
r[reverseBits(n, s)] = x[n]
}
return r
} | go | {
"resource": ""
} |
q14847 | Apply | train | func Apply(x []float64, windowFunction func(int) []float64) {
for i, w := range windowFunction(len(x)) {
x[i] *= w
}
} | go | {
"resource": ""
} |
q14848 | PrettyClose | train | func PrettyClose(a, b []float64) bool {
if len(a) != len(b) {
return false
}
for i, c := range a {
if !Float64Equal(c, b[i]) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q14849 | PrettyCloseC | train | func PrettyCloseC(a, b []complex128) bool {
if len(a) != len(b) {
return false
}
for i, c := range a {
if !ComplexEqual(c, b[i]) {
return false
}
}
return true
} | go | {
"resource": ""
} |
q14850 | ComplexEqual | train | func ComplexEqual(a, b complex128) bool {
r_a := real(a)
r_b := real(b)
i_a := imag(a)
i_b := imag(b)
return Float64Equal(r_a, r_b) && Float64Equal(i_a, i_b)
} | go | {
"resource": ""
} |
q14851 | Float64Equal | train | func Float64Equal(a, b float64) bool {
return math.Abs(a-b) <= closeFactor || math.Abs(1-a/b) <= closeFactor
} | go | {
"resource": ""
} |
q14852 | MakeMatrix2 | train | func MakeMatrix2(x [][]complex128) *Matrix {
dims := []int{len(x), len(x[0])}
r := make([]complex128, dims[0]*dims[1])
for n, v := range x {
if len(v) != dims[1] {
panic("ragged array")
}
copy(r[n*dims[1]:(n+1)*dims[1]], v)
}
return MakeMatrix(r, dims)
} | go | {
"resource": ""
} |
q14853 | Copy | train | func (m *Matrix) Copy() *Matrix {
r := &Matrix{m.list, m.dims, m.offsets}
r.list = make([]complex128, len(m.list))
copy(r.list, m.list)
return r
} | go | {
"resource": ""
} |
q14854 | MakeEmptyMatrix | train | func MakeEmptyMatrix(dims []int) *Matrix {
x := 1
for _, v := range dims {
x *= v
}
return MakeMatrix(make([]complex128, x), dims)
} | go | {
"resource": ""
} |
q14855 | offset | train | func (s *Matrix) offset(dims []int) int {
if len(dims) != len(s.dims) {
panic("incorrect dimensions")
}
i := 0
for n, v := range dims {
if v > s.dims[n] {
panic("incorrect dimensions")
}
i += v * s.offsets[n]
}
return i
} | go | {
"resource": ""
} |
q14856 | Dimensions | train | func (m *Matrix) Dimensions() []int {
r := make([]int, len(m.dims))
copy(r, m.dims)
return r
} | go | {
"resource": ""
} |
q14857 | To2D | train | func (m *Matrix) To2D() [][]complex128 {
if len(m.dims) != 2 {
panic("can only convert 2-D Matrixes")
}
r := make([][]complex128, 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
} | go | {
"resource": ""
} |
q14858 | Authenticator | train | func Authenticator(next http.Handler) http.Handler {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
token, _, err := FromContext(r.Context())
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)
})
} | go | {
"resource": ""
} |
q14859 | TokenFromCookie | train | func TokenFromCookie(r *http.Request) string {
cookie, err := r.Cookie("jwt")
if err != nil {
return ""
}
return cookie.Value
} | go | {
"resource": ""
} |
q14860 | NewLocker | train | func NewLocker(lockerConfig config.Locker) (*lock, error) {
c, _, err := zk.Connect(lockerConfig.Address, time.Millisecond*100)
if err != nil {
return nil, err
}
return &lock{c}, nil
} | go | {
"resource": ""
} |
q14861 | NewLocker | train | func NewLocker(lockerConfig config.Locker) (*locker, error) {
if len(lockerConfig.Address) < 1 {
return nil, errors.New("No redis address provided")
}
p := newPool(lockerConfig.Address[0], "")
return &locker{p}, nil
} | go | {
"resource": ""
} |
q14862 | ReadMethods | train | func ReadMethods() []*regexp.Regexp {
return []*regexp.Regexp{
regexp.MustCompile(baseMethod + "Get"),
regexp.MustCompile(baseMethod + "List"),
}
} | go | {
"resource": ""
} |
q14863 | NewProvider | train | func NewProvider(paymentConfig *config.PaymentProvider) (*provider, error) {
stripe.Key = paymentConfig.Secret
stripe.Logger = logrus.New()
return &provider{}, nil
} | go | {
"resource": ""
} |
q14864 | getAccessMap | train | func getAccessMap(c *client.Client) [][]*regexp.Regexp {
var m [][]*regexp.Regexp
// append public scope
m = append(m, accessMap[client.PublicScope]...)
if c == nil {
return m
}
for _, v := range c.Scopes {
if methods, ok := accessMap[v]; ok {
m = append(m, methods...)
}
}
return m
} | go | {
"resource": ""
} |
q14865 | CanAccessMethod | train | func CanAccessMethod(ctx context.Context, fullMethod string) bool {
u, _ := client.FromContext(ctx)
for _, v := range getAccessMap(u) {
for _, r := range v {
if r.MatchString(fullMethod) {
return true
}
}
}
return false
} | go | {
"resource": ""
} |
q14866 | RecoveryHandlerFunc | train | func RecoveryHandlerFunc(p interface{}) (err error) {
// print stack to stderr
debug.PrintStack()
// return grpc error
switch x := p.(type) {
case *logrus.Entry:
return status.Errorf(codes.Internal, "%s", x.Message)
}
return status.Errorf(codes.Internal, "%s", p)
} | go | {
"resource": ""
} |
q14867 | Retry | train | func Retry(callback func() error) (err error) {
for i := 0; ; i++ {
if err = callback(); err == nil {
return
}
if i >= (defaultRetryAttempts - 1) {
break
}
time.Sleep(defaultRetrySleep)
log.Error("retrying after error:", err)
}
return fmt.Errorf("after %d attempts, last error: %s", defaultRetryAttempts, err)
} | go | {
"resource": ""
} |
q14868 | NewHandler | train | func NewHandler(s config.Storage) *handler {
if s.Database == "" {
s.Database = object.DefaultDatabase
}
h := &handler{
dailInfo: &mgo.DialInfo{
PoolLimit: 4096,
Timeout: time.Second,
FailFast: true,
Username: s.Username,
Password: s.Password,
Addrs: s.Address,
Database: s.Database,
},
database: s.Database,
}
return h
} | go | {
"resource": ""
} |
q14869 | NewClient | train | func NewClient(addr string, opt *ClientOpt) (*grpc.ClientConn, error) {
if opt == nil {
return nil, fmt.Errorf("Empty ClientOpt")
}
// Load key pair
certificate, err := tls.LoadX509KeyPair(opt.Crt, opt.Key)
if err != nil {
return nil, err
}
tlsConf := &tls.Config{
ServerName: opt.ServerName,
Certificates: []tls.Certificate{certificate},
InsecureSkipVerify: opt.InsecureSkipVerify,
}
// Mutual handshake with private ca
if 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 := []grpc.DialOption{
grpc.WithTransportCredentials(credentials.NewTLS(tlsConf)),
}
if opt.WithBlock {
dailOpts = append(dailOpts, grpc.WithBlock(), grpc.WithTimeout(5*time.Second))
}
// Dail and return connection
conn, err := grpc.Dial(addr, dailOpts...)
if err != nil {
return nil, err
}
return conn, nil
} | go | {
"resource": ""
} |
q14870 | New | train | func New(conf *config.AppConfig) *server {
if conf.Insecure {
acl.SetSkipAuth()
}
// create new storage handler
if err := storage.New(conf.Storage); err != nil {
log.Fatalf("Could not create storage handler => %s", err.Error())
}
// create new locker handler
if err := locker.New(conf.Locker); 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 &server{
listener: lis,
grpcServer: newGRPCServer(conf),
}
} | go | {
"resource": ""
} |
q14871 | Provider | train | func Provider(p paymentpb.PaymentProviderId) Interface {
mtx.Lock()
defer mtx.Unlock()
if v, ok := providers[p]; ok {
return v
}
log.Panicf("payment provider %s isn't registered", p.String())
return nil
} | go | {
"resource": ""
} |
q14872 | NewContext | train | func NewContext(ctx context.Context, serialId *big.Int) context.Context {
var c *Client
var err error
if c, err = GetClient(util.BigIntToHex(serialId)); err != nil {
return ctx
}
return context.WithValue(ctx, clientKey{}, c)
} | go | {
"resource": ""
} |
q14873 | FromContext | train | func FromContext(ctx context.Context) (*Client, bool) {
u, ok := ctx.Value(clientKey{}).(*Client)
return u, ok
} | go | {
"resource": ""
} |
q14874 | GetClient | train | func GetClient(serialId string) (*Client, error) {
// search for user
for _, c := range clients {
if c.Serial == serialId {
return &c, nil
}
}
return nil, errors.New("Cant find client.")
} | go | {
"resource": ""
} |
q14875 | Validate | train | func Validate(req interface{}) error {
// validate req message
if err := v.Struct(req); err != nil {
if v, ok := err.(validator.ValidationErrors); ok {
err = v
}
return status.Errorf(codes.InvalidArgument, "Request validation failed: %s", err)
}
return nil
} | go | {
"resource": ""
} |
q14876 | New | train | func New(storageConfig config.Storage) error {
// create handler based on the storage config
switch handlerName(storageConfig.Handler) {
case mongodbHandler:
handler = mongo.NewHandler(storageConfig)
default:
return errors.New("Invalid storage handler `" + storageConfig.Handler + "`")
}
// prepare handler
return handler.Prepare()
} | go | {
"resource": ""
} |
q14877 | New | train | func New(lockerConfig config.Locker) error {
var err error
switch handlerName(lockerConfig.Handler) {
case zookeeperHandler:
handler, err = zookeeper.NewLocker(lockerConfig)
return err
case redisHandler:
handler, err = redis.NewLocker(lockerConfig)
return err
default:
handler = memlock.NewLocker()
}
return nil
} | go | {
"resource": ""
} |
q14878 | IsReturnable | train | func (o *order) IsReturnable(amount int64) error {
if o.Status != orderpb.Order_Paid && o.Status != orderpb.Order_Fulfilled && o.Status != orderpb.Order_Canceled {
return status.Error(codes.Internal, "Order is not paid or fulfilled.")
}
// if refund amount is bigger than the order amount return err
if amount > o.GetAmount() {
return status.Error(codes.Internal, "Refund amount is greater then order amount.")
}
return nil
} | go | {
"resource": ""
} |
q14879 | New | train | func (s *orderService) New(ctx context.Context, req *orderpb.NewRequest) (*orderpb.Order, error) {
// validate input
if err := validation.Validate(req); err != nil {
return nil, err
}
// order wrapper
o := &order{
Order: orderpb.Order{
Email: req.GetEmail(),
Status: orderpb.Order_Created,
Amount: 0,
Currency: req.GetCurrency(),
Shipping: req.GetShipping(),
},
}
// get relevant order items
orderItems, err := getUpdatedOrderItems(req.GetItems())
if err != nil {
return nil, 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)
} | go | {
"resource": ""
} |
q14880 | Get | train | func (s *orderService) Get(ctx context.Context, req *orderpb.GetRequest) (*orderpb.Order, error) {
// validate input
if err := validation.Validate(req); err != nil {
return nil, err
}
// order wrapper
o := &order{
Order: orderpb.Order{
Id: req.GetId(),
},
}
// 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)
} | go | {
"resource": ""
} |
q14881 | Return | train | func (s *orderService) Return(ctx context.Context, req *orderpb.ReturnRequest) (*orderpb.Order, error) {
// validate input
if err := validation.Validate(req); err != nil {
return nil, err
}
// order wrapper
o := &order{
Order: orderpb.Order{
Id: req.GetId(),
},
}
// lock order
unlock, err := locker.Handler().TryLock(o, locker.DefaultTimeout)
if err != nil {
return nil, err
}
defer unlock()
// get order
if err := storage.Handler().One(o); err != nil {
return nil, status.Error(codes.Internal, err.Error())
}
// calculate returns amount
amount, err := calculateTotal(o.GetCurrency(), o.GetItems())
if err != nil {
return nil, err
}
// check if order can be refunded
if err := o.IsReturnable(amount); err != nil {
return nil, err
}
// lock all inventory order items (inventory objects)
lockedItems := getLockedOrderItems(ctx, &o.Order)
// Free all locks at func return
defer func() {
for _, item := range lockedItems {
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 from paid into canceled
// inventory item will get updated since the sku is in
// stock again
case orderpb.Order_Paid:
o.Status = orderpb.Order_Canceled
// notify listeners we want to return the items back in inventory
// update inventories
for _, item := range lockedItems {
if item.Sku.Inventory.Type == skupb.Inventory_Finite {
// update inventory Quantity
item.Sku.Inventory.Quantity += item.OrderItem.Quantity
item.Update()
}
}
// if the order has been fulfilled
// order status turns from fulfilled into returned
// inventory will not get updated since we still got no
// item to sell again
case orderpb.Order_Fulfilled:
o.Status = orderpb.Order_Returned
}
// update order with retries
updateErr := util.Retry(func() error {
return storage.Handler().Update(o)
})
// return err
if updateErr != nil {
return nil, status.Error(codes.DataLoss, fmt.Sprintf("could not update order {%s} object, order has been refunded {%s}!", o.Id, o.ChargeId))
}
// return order
return &o.Order, nil
} | go | {
"resource": ""
} |
q14882 | calculateTotal | train | func calculateTotal(currency paymentpb.Currency, orderItems []*orderpb.OrderItem) (int64, error) {
var err error
m := money.New(0, currency.String())
for _, v := range orderItems {
if v.Quantity <= 0 {
v.Quantity = 1
}
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
} | go | {
"resource": ""
} |
q14883 | WriteMethods | train | func WriteMethods() []*regexp.Regexp {
return []*regexp.Regexp{
regexp.MustCompile(baseMethod + "NewCharge"),
regexp.MustCompile(baseMethod + "RefundCharge"),
}
} | go | {
"resource": ""
} |
q14884 | WithLocation | train | func WithLocation(loc *time.Location) Option {
return option.New(optkeyClock, clockFn(func() time.Time {
return time.Now().In(loc)
}))
} | go | {
"resource": ""
} |
q14885 | New | train | func New(p string, options ...Option) (*RotateLogs, error) {
globPattern := p
for _, re := range patternConversionRegexps {
globPattern = re.ReplaceAllString(globPattern, "*")
}
pattern, err := strftime.New(p)
if err != nil {
return nil, errors.Wrap(err, `invalid strftime pattern`)
}
var clock Clock = Local
rotationTime := 24 * time.Hour
var rotationCount uint
var linkName string
var maxAge time.Duration
var handler Handler
for _, o := range options {
switch o.Name() {
case optkeyClock:
clock = o.Value().(Clock)
case optkeyLinkName:
linkName = o.Value().(string)
case optkeyMaxAge:
maxAge = o.Value().(time.Duration)
if maxAge < 0 {
maxAge = 0
}
case optkeyRotationTime:
rotationTime = o.Value().(time.Duration)
if rotationTime < 0 {
rotationTime = 0
}
case optkeyRotationCount:
rotationCount = o.Value().(uint)
case 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{
clock: clock,
eventHandler: handler,
globPattern: globPattern,
linkName: linkName,
maxAge: maxAge,
pattern: pattern,
rotationTime: rotationTime,
rotationCount: rotationCount,
}, nil
} | go | {
"resource": ""
} |
q14886 | Write | train | func (rl *RotateLogs) Write(p []byte) (n int, err error) {
// Guard against concurrent writes
rl.mutex.Lock()
defer rl.mutex.Unlock()
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)
} | go | {
"resource": ""
} |
q14887 | getWriter_nolock | train | func (rl *RotateLogs) getWriter_nolock(bailOnRotateFail, useGenerationalNames bool) (io.Writer, error) {
generation := rl.generation
previousFn := rl.curFn
// This filename contains the name of the "NEW" filename
// to log to, which may be newer than rl.currentFilename
filename := rl.genFilename()
if previousFn != filename {
generation = 0
} else {
if !useGenerationalNames {
// nothing to do
return rl.outFh, nil
}
// This is used when we *REALLY* want to rotate a log.
// instead of just using the regular strftime pattern, we
// create a new file name using generational names such as
// "foo.1", "foo.2", "foo.3", etc
for {
generation++
name := fmt.Sprintf("%s.%d", filename, generation)
if _, err := os.Stat(name); err != nil {
filename = name
break
}
}
}
// make sure the dir is existed, eg:
// ./foo/bar/baz/hello.log must make sure ./foo/bar/baz is existed
dirname := filepath.Dir(filename)
if err := os.MkdirAll(dirname, 0755); err != nil {
return nil, errors.Wrapf(err, "failed to create directory %s", dirname)
}
// if we got here, then we need to create a file
fh, err := os.OpenFile(filename, os.O_CREATE|os.O_APPEND|os.O_WRONLY, 0644)
if err != nil {
return nil, errors.Errorf("failed to open file %s: %s", 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 this error when explicitly needed (as specified by bailOnRotateFail)
//
// However, we *NEED* to close `fh` here
if fh != nil { // probably can't happen, but being paranoid
fh.Close()
}
return nil, err
}
fmt.Fprintf(os.Stderr, "%s\n", err.Error())
}
rl.outFh.Close()
rl.outFh = fh
rl.curFn = filename
rl.generation = generation
if h := rl.eventHandler; h != nil {
go h.Handle(&FileRotatedEvent{
prev: previousFn,
current: filename,
})
}
return fh, nil
} | go | {
"resource": ""
} |
q14888 | CurrentFileName | train | func (rl *RotateLogs) CurrentFileName() string {
rl.mutex.RLock()
defer rl.mutex.RUnlock()
return rl.curFn
} | go | {
"resource": ""
} |
q14889 | Rotate | train | func (rl *RotateLogs) Rotate() error {
rl.mutex.Lock()
defer rl.mutex.Unlock()
if _, err := rl.getWriter_nolock(true, true); err != nil {
return err
}
return nil
} | go | {
"resource": ""
} |
q14890 | Close | train | func (rl *RotateLogs) Close() error {
rl.mutex.Lock()
defer rl.mutex.Unlock()
if rl.outFh == nil {
return nil
}
rl.outFh.Close()
rl.outFh = nil
return nil
} | go | {
"resource": ""
} |
q14891 | Text | train | func (m *LevelMetadata) Text(enableColor bool) string {
if enableColor {
return m.ColorfulText
}
return m.RawText
} | go | {
"resource": ""
} |
q14892 | New | train | func New() *Logger {
return &Logger{
Level: InfoLevel,
TimeFormat: "2006/01/02 15:04",
NewLine: true,
Printer: pio.NewPrinter("", os.Stdout).EnableDirectOutput().Hijack(logHijacker),
children: newLoggerMap(),
}
} | go | {
"resource": ""
} |
q14893 | acquireLog | train | func (l *Logger) acquireLog(level Level, msg string, withPrintln bool) *Log {
log, ok := l.logs.Get().(*Log)
if !ok {
log = &Log{
Logger: l,
}
}
log.NewLine = withPrintln
log.Time = time.Now()
log.Level = level
log.Message = msg
return log
} | go | {
"resource": ""
} |
q14894 | SetOutput | train | func (l *Logger) SetOutput(w io.Writer) *Logger {
l.Printer.SetOutput(w)
return l
} | go | {
"resource": ""
} |
q14895 | SetPrefix | train | func (l *Logger) SetPrefix(s string) *Logger {
l.mu.Lock()
l.Prefix = []byte(s)
l.mu.Unlock()
return l
} | go | {
"resource": ""
} |
q14896 | SetTimeFormat | train | func (l *Logger) SetTimeFormat(s string) *Logger {
l.mu.Lock()
l.TimeFormat = s
l.mu.Unlock()
return l
} | go | {
"resource": ""
} |
q14897 | DisableNewLine | train | func (l *Logger) DisableNewLine() *Logger {
l.mu.Lock()
l.NewLine = false
l.mu.Unlock()
return l
} | go | {
"resource": ""
} |
q14898 | Print | train | func (l *Logger) Print(v ...interface{}) {
l.print(DisableLevel, fmt.Sprint(v...), l.NewLine)
} | go | {
"resource": ""
} |
q14899 | Println | train | func (l *Logger) Println(v ...interface{}) {
l.print(DisableLevel, fmt.Sprint(v...), true)
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.