_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... | 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
}
... | 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... | 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... | 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... | 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, 1... | 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 com... | 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
}
}
... | 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
}
e... | 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 tr... | 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
}
... | 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... | 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) ... | 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 fun... | 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 ... | 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 supporte... | 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.Error... | 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
}
}
//... | 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... | 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"... | 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... | 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 = len... | 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 = runti... | 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)... | 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", defaultRetryAtte... | 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... | 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,
C... | 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 {... | 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
re... | 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()
}
re... | 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.... | 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:... | 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.... | 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.Han... | 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 {
... | 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 = Loca... | 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 !... | 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.