id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c16000 | false
opt.IndentBy = " "
opt.AllowMinusZero = false
opt.UnknownAsNull = false
return opt
} | |
c16001 | for rv.Kind() == reflect.Ptr {
rv = rv.Elem()
}
defer func() {
if e := recover(); e != nil {
err = fmt.Errorf("%v", e)
}
}()
rv.Set(reflect.ValueOf(value))
return err
} | |
c16002 | new(bytes.Buffer)
cfg.fprint(buf, vals...)
return buf.String()
} | |
c16003 | (n int64, err error) {
return DefaultConfig.Fprint(w, vals...)
} | |
c16004 | err error) {
buf := new(bytes.Buffer)
cfg.fprint(buf, vals...)
return buf.WriteTo(w)
} | |
c16005 | := *cfg
diffCfg.Diffable = true
return diff.Diff(cfg.Sprint(a), cfg.Sprint(b))
} | |
c16006 |
for _, line := range c.Added {
fmt.Fprintf(buf, "+%s\n", line)
}
for _, line := range c.Deleted {
fmt.Fprintf(buf, "-%s\n", line)
}
for _, line := range c.Equal {
fmt.Fprintf(buf, " %s\n", line)
}
}
return strings.TrimRight(buf.String(), "\n")
} | |
c16007 | 5xx, returning internal server error: 500."))
}
return http.StatusInternalServerError
}
return f.statusCode
} | |
c16008 | f.statusCode,
loggerAction: f.loggerAction,
emptyResponse: f.emptyResponse,
errorKey: f.errorKey,
}
} | |
c16009 | statusCode: statusCode,
loggerAction: loggerAction,
emptyResponse: false,
}
} | |
c16010 | {
f.errorKey = errorKey
return f
} | |
c16011 | f.error,
statusCode: f.statusCode,
loggerAction: f.loggerAction,
emptyResponse: f.emptyResponse,
errorKey: f.errorKey,
}
} | |
c16012 |
return nil, ErrNegativeFrameSize
}
frame = make([]byte, size)
err = binary.Read(r, binary.LittleEndian, &frame)
return
} | |
c16013 | r: bufio.NewReader(r),
}
return decoder
} | |
c16014 | binary.Read(d.r, binary.LittleEndian, &metaLen)
if err != nil {
return err
}
// Read in the metadata itself
jsonBuf := make([]byte, metaLen)
err = binary.Read(d.r, binary.LittleEndian, &jsonBuf)
if err != nil {
return err
}
// And unmarshal it
var metadata *Metadata
err = json.Unmarshal(jsonBuf, &metad... | |
c16015 |
magic, err := d.r.Peek(3)
if err != nil {
return nil, err
}
if string(magic) == "DCA" {
err = d.ReadMetadata()
if err != nil {
return nil, err
}
}
}
frame, err = DecodeFrame(d.r)
return
} | |
c16016 | 20ms 1 channel audio
return time.Duration(((d.Metadata.Opus.FrameSize/d.Metadata.Opus.Channels)/960)*20) * time.Millisecond
} | |
c16017 | * s.source.FrameDuration()
s.Unlock()
return dur
} | |
c16018 | := s.finished
s.Unlock()
return fin, err
} | |
c16019 | p := s.paused
s.Unlock()
return p
} | |
c16020 |
return errors.New("Invalid packet loss percentage")
}
if opts.Application != AudioApplicationAudio && opts.Application != AudioApplicationVoip && opts.Application != AudioApplicationLowDelay {
return errors.New("Invalid audio application")
}
if opts.CompressionLevel < 0 || opts.CompressionLevel > 10 {
retu... | |
c16021 | options,
pipeReader: r,
frameChannel: make(chan *Frame, options.BufferedFrames),
}
go session.run()
return
} | |
c16022 | || e.process == nil {
return errors.New("Not running")
}
err := e.process.Kill()
return err
} | |
c16023 | return e.OpusFrame()
}
if len(f.data) < 2 {
return nil, ErrBadFrame
}
return f.data[2:], nil
} | |
c16024 | bool) {
e.Lock()
running = e.running
e.Unlock()
return
} | |
c16025 | {
return time.Duration(e.options.FrameDuration) * time.Millisecond
} | |
c16026 | defer e.Unlock()
return e.err
} | |
c16027 | output := e.ffmpegOutput
e.Unlock()
return output
} | |
c16028 | bytes)")
flag.StringVar(&Application, "aa", "audio", "audio application can be voip, audio, or lowdelay")
flag.StringVar(&CoverFormat, "cf", "jpeg", "format the cover art will be encoded with")
flag.StringVar(&Comment, "com", "", "leave a comment in the metadata")
flag.BoolVar(&Quiet, "quiet", false, "disable stat... | |
c16029 | return
}
}
if Bitrate < 1 || Bitrate > 512 {
Bitrate = 64 // Set to Discord default
}
//////////////////////////////////////////////////////////////////////////
// BLOCK : Start reader and writer workers
//////////////////////////////////////////////////////////////////////////
options := &dca.EncodeOp... | |
c16030 | if !ok {
reply(w, errMsg("Guest access is unavailable"), http.StatusUnauthorized)
} else {
handler(w, r)
}
} else {
//Run the handler using basic authentication
if fileExists(users) {
requireBasicAuth(authenticator, handler)(w, r)
} else {
handler(w, r)
}
}
}
} | |
c16031 | valid UUID sequence")
return
}
u = new(UUID)
copy(u[:], b)
return
} | |
c16032 | name.
u.setBytesFromHash(md5.New(), ns[:], name)
u.setVariant(ReservedRFC4122)
u.setVersion(3)
return
} | |
c16033 | err != nil {
return
}
u.setVariant(ReservedRFC4122)
u.setVersion(4)
return
} | |
c16034 |
u.setBytesFromHash(sha1.New(), ns[:], name)
u.setVariant(ReservedRFC4122)
u.setVersion(5)
return
} | |
c16035 |
hash.Write(name)
copy(u[:], hash.Sum([]byte{})[:16])
} | |
c16036 | != nil {
return []VhostInfo{}, err
}
if err = executeAndParseRequest(c, req, &rec); err != nil {
return []VhostInfo{}, err
}
return rec, nil
} | |
c16037 | != nil {
return nil, err
}
res, err = executeRequest(c, req)
if err != nil {
return nil, err
}
return res, nil
} | |
c16038 | err != nil {
return nil, err
}
me = &Client{
Endpoint: uri,
host: u.Host,
Username: username,
Password: password,
transport: transport,
}
return me, nil
} | |
c16039 | executeAndParseRequest(c, req, &rec); err != nil {
return []PermissionInfo{}, err
}
return rec, nil
} | |
c16040 |
return nil, err
}
req, err := newRequestWithBody(c, "PUT", "permissions/"+PathEscape(vhost)+"/"+PathEscape(username), body)
if err != nil {
return nil, err
}
res, err = executeRequest(c, req)
if err != nil {
return nil, err
}
return res, nil
} | |
c16041 | executeAndParseRequest(c, req, &rec); err != nil {
return []TopicPermissionInfo{}, err
}
return rec, nil
} | |
c16042 | nil {
return nil, err
}
req, err := newRequestWithBody(c, "PUT", "topic-permissions/"+PathEscape(vhost)+"/"+PathEscape(username), body)
if err != nil {
return nil, err
}
res, err = executeRequest(c, req)
if err != nil {
return nil, err
}
return res, nil
} | |
c16043 | err != nil {
return []BindingInfo{}, err
}
if err = executeAndParseRequest(c, req, &rec); err != nil {
return []BindingInfo{}, err
}
return rec, nil
} | |
c16044 |
buf: &bytes.Buffer{},
}
} | |
c16045 | d.readData(messageLen)
if err != nil {
return output, errors.Wrap(err, "An error occurred reading message data")
}
numWritten, err := output.Write(data)
if numWritten < len(data) {
return output, errors.New("Didn't write full data on output. Expected: %d Wrote: %d", len(data), numWritten)
} else if er... | |
c16046 |
return nil, err
}
return d.decode(data)
} | |
c16047 | &Error{
msg: fmt.Sprintf(msg, args...),
stack: debug.Stack(),
level: 0,
}
} | |
c16048 |
}
return &Error{
msg: fmt.Sprintf(msg, args...),
wrapped: err,
stack: debug.Stack(),
}
} | |
c16049 | e.wrapped.(*Error); ok {
return inner.InnerMost()
}
return e.wrapped
} | |
c16050 | if (i+1)%4 == 0 {
output += " "
} else {
output += " "
}
}
output += "\n"
return output
} | |
c16051 | }
m, err := encoding.Unmarshal(argBytes)
if err != nil {
return nil, err
}
for k, v := range m.(map[string]interface{}) {
output[k] = v
}
}
return output, nil
} | |
c16052 | committing transaction: %#v", success)
pull, ok := pullInt.(messages.SuccessMessage)
if !ok {
return errors.New("Unrecognized response type pulling transaction: %#v", pull)
}
log.Infof("Got success message pulling transaction: %#v", pull)
t.conn.transaction = nil
t.closed = true
return err
} | |
c16053 | d) // Never use pooling when using SQL driver
} | |
c16054 | return createDriverPool(connStr, max)
} | |
c16055 | return createDriverPool(connStr, max)
} | |
c16056 | connectionNilOrClosed(conn) {
if err := conn.initialize(); err != nil {
return nil, err
}
d.connRefs = append(d.connRefs, conn)
}
return conn, nil
}
return nil, errors.New("Driver pool has been closed")
} | |
c16057 | // Remove the reference to the pool, to allow a clean up of the connection
conn.poolDriver = nil
err := conn.Close()
if err != nil {
d.closed = true
return err
}
}
// Mark the pool as closed to stop any new connections
d.closed = true
return nil
} | |
c16058 | nil, errors.Wrap(err, "An error occurred initializing connection")
}
return c, nil
} | |
c16059 | c := createBoltConn(connStr)
c.poolDriver = driver
return c, nil
} | |
c16060 | log.Tracef("Read %d bytes from stream:\n\n%s\n", n, sprintByteHex(b))
}
if err != nil && err != io.EOF {
c.connErr = errors.Wrap(err, "An error occurred reading from stream")
err = driver.ErrBadConn
}
return n, err
} | |
c16061 | log.Tracef("Wrote %d of %d bytes to stream:\n\n%s\n", len(b), n, sprintByteHex(b[:n]))
}
if err != nil {
c.connErr = errors.Wrap(err, "An error occurred writing to stream")
err = driver.ErrBadConn
}
return n, err
} | |
c16062 | for pool: %s", err)
c.connErr = errors.Wrap(err, "An error occurred closing the connection")
return driver.ErrBadConn
}
return nil
}
err := c.conn.Close()
c.closed = true
if err != nil {
c.connErr = errors.Wrap(err, "An error occurred closing the connection")
return driver.ErrBadConn
}
return nil... | |
c16063 | {
return c.prepare(query)
} | |
c16064 | {
return nil, errors.New("Connection already closed")
}
c.statement = newPipelineStmt(queries, c)
return c.statement, nil
} | |
c16065 | beginning transaction: %#v", success)
}
log.Infof("Got success message beginning transaction: %#v", success)
success, ok = pullInt.(messages.SuccessMessage)
if !ok {
return nil, errors.New("Unrecognized response type pulling transaction: %#v", success)
}
log.Infof("Got success message pulling transaction: ... | |
c16066 | RunMessage {
return RunMessage{
statement: statement,
parameters: parameters,
}
} | |
c16067 | for i, f := range fields {
if fieldsStr[i], ok = f.(string); !ok {
log.Errorf("Unrecognized fields from success message: %#v", fieldsInt)
return []string{}
}
}
return fieldsStr
} | |
c16068 | clear out the
// rest of the messages on close by taking the current
// index * 2 but removing the first success
numConsume = ((numQueries - r.pipelineIndex) * 2) - 1
}
}
// Clear out all unconsumed messages if we
// never finished consuming them.
_, _, err := r.statement.conn.consumeAllMultipl... | |
c16069 | {
return err
}
default:
dest[i], err = driver.DefaultParameterConverter.ConvertValue(item)
if err != nil {
return err
}
}
}
return nil
} | |
c16070 | r.finishedConsume = true
return nil, resp.Metadata, io.EOF
case messages.RecordMessage:
log.Infof("Got record message: %#v", resp)
return resp.Fields, nil, nil
default:
return nil, nil, errors.New("Unrecognized response type getting next query row: %#v", resp)
}
} | |
c16071 | = newPipelineRows(r.statement, success.Metadata, r.pipelineIndex+1)
r.statement.rows.closeStatement = r.closeStatement
return nil, success.Metadata, r.statement.rows, nil
case messages.RecordMessage:
log.Infof("Got record message: %#v", resp)
return resp.Fields, nil, nil, nil
default:
return nil, nil, nil... | |
c16072 | "scheme": "basic",
"principal": user,
"credentials": password,
}
}
return InitMessage{
clientName: clientName,
authToken: authToken,
}
} | |
c16073 | level = TraceLevel
case "info":
level = InfoLevel
case "error":
level = ErrorLevel
default:
level = NoneLevel
}
} | |
c16074 | TraceLog.Printf(msg, args...)
}
} | |
c16075 | InfoLog.Printf(msg, args...)
}
} | |
c16076 | ErrorLog.Printf(msg, args...)
}
} | |
c16077 | &bytes.Buffer{},
chunkSize: chunkSize,
}
} | |
c16078 | math.MaxUint16).Encode(v)
return x.Bytes(), err
} | |
c16079 | if err := binary.Write(e.w, binary.BigEndian, e.chunkSize); err != nil {
return 0, errors.Wrap(err, "An error occured writing chunksize")
}
numWritten, err := e.w.Write(e.buf.Next(int(e.chunkSize)))
if err != nil {
err = errors.Wrap(err, "An error occured writing a chunk")
}
return numWritten, err
... | |
c16080 |
}
if _, err := e.buf.WriteTo(e.w); err != nil {
return errors.Wrap(err, "An error occured writing message bytes during flush")
}
}
_, err := e.w.Write(EndMessage)
if err != nil {
return errors.Wrap(err, "An error occurred ending encoding message")
}
e.buf.Reset()
return nil
} | |
c16081 | 0; i < len(b); i++ {
if len(event.Event) == 0 {
return i, errors.New("Attempted to read past current event in recorder! Bytes: %s. Recorder %#v, Event; %#v", b, r, event)
}
b[i] = event.Event[0]
event.Event = event.Event[1:]
}
if len(event.Event) == 0 {
r.currentEvent++
}
return len(b), nil
} | |
c16082 | %#v", r)
}
if len(r.events[len(r.events)-1].Event) != 0 {
return errors.New("Left data in an event in the recorder on close! %#v", r)
}
return nil
}
return nil
} | |
c16083 | }
for i := 0; i < len(b); i++ {
if len(event.Event) == 0 {
return i, errors.New("Attempted to write past current event in recorder! %#v, Event: %#v", r, event)
}
event.Event = event.Event[1:]
}
if len(event.Event) == 0 {
r.currentEvent++
}
return len(b), nil
} | |
c16084 | {
return &FastHTTPServer{}
})
revel.RegisterModuleInit(func(m *revel.Module) {
serverLog = m.Log
})
} | |
c16085 | sort.Sort(f.HttpMuxList)
f.HasAppMux = len(f.HttpMuxList) > 0
f.signalChan = make(chan os.Signal)
f.ServerInit = init
f.Server = &fasthttp.Server{
ReadTimeout: time.Duration(revel.Config.IntDefault("http.timeout.read", 0)) * time.Second,
WriteTimeout: time.Duration(revel.Config.IntDefault("http.timeout.writ... | |
c16086 | the app
if f.HasAppMux && f.handleAppMux(ctx) {
return
}
f.handleMux(ctx)
} | |
c16087 | case revel.ENGINE_SHUTDOWN_REQUEST:
if err := f.graceful.Close(); err != nil {
serverLog.Fatal("Failed to close fasthttp server gracefully, exiting using os.exit", "error", err)
}
default:
}
return 0
} | |
c16088 | Response: &FastHttpResponse{header: &FastHttpHeader{isResponse: true},
Engine: instance},
}
c.Response.header.Source = c.Response
c.Request.header.Source = c.Request
return c
} | |
c16089 | c.Response.SetContext(context)
c.Request.SetContext(context)
} | |
c16090 | revel.HTTP_REMOTE_ADDR:
value = r.Original.RemoteAddr().String()
case revel.HTTP_METHOD:
value = string(r.Original.Method())
case revel.HTTP_PATH:
value = string(r.Original.Path())
case revel.HTTP_HOST:
value = string(r.Original.Request.Host())
case revel.HTTP_URL:
if r.url == nil {
r.url, _ = url.Par... | |
c16091 | r.query.Set(string(key), string(value))
})
r.toQuery = true
}
return r.query
} | |
c16092 | = false
r.ParsedForm = nil
r.toQuery = false
} | |
c16093 | value = r.Header()
case revel.HTTP_STREAM_WRITER:
value = r
case revel.HTTP_WRITER:
value = r.Writer
default:
err = revel.ENGINE_UNKNOWN_GET
}
return
} | |
c16094 | case revel.HTTP_WRITER:
r.SetWriter(value.(io.Writer))
set = true
}
return
} | |
c16095 | mtime < t+1s instead of mtime <= t to check for unmodified.
if modtime.Before(t.Add(1 * time.Second)) {
h := r.Original.Response.Header
h.Del("Content-Type")
h.Del("Content-Length")
if h.Peek("Etag") != nil {
h.Del("Last-Modified")
}
h.SetStatusCode(http.StatusNotModified)
return nil
}
}
... | |
c16096 | c.Close()
}
r.Original = nil
r.Writer = nil
} | |
c16097 | w
r.Writer = w.Response.BodyWriter()
} | |
c16098 | {
r.Source.(*FastHttpResponse).Original.Response.Header.Add("Set-Cookie", cookie)
}
} | |
c16099 | {
r.Source.(*FastHttpResponse).Original.Response.Header.Del(key)
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.