id stringlengths 2 7 | text stringlengths 17 51.2k | title stringclasses 1
value |
|---|---|---|
c15900 | {
return C.GoString(C.string_identifier(s.cptr))
} | |
c15901 |
if size == 0 {
return
}
C.string_matches(s.cptr, &ptrs[0], &size)
for _, ptr := range ptrs {
matches = append(matches, Match{ptr})
}
return
} | |
c15902 | if dataSectionStart > dataSectionEnd {
return nil, newInvalidDatabaseError("the MaxMind DB contains invalid metadata")
}
d := decoder{
buffer[searchTreeSize+dataSectionSeparatorSize : metadataStart-len(metadataStartMarker)],
}
reader := &Reader{
buffer: buffer,
decoder: d,
Metadata: metadata,
ip... | |
c15903 | pointer, err := r.lookupPointer(ipAddress)
if pointer == 0 || err != nil {
return err
}
return r.retrieveData(pointer, result)
} | |
c15904 | err := r.lookupPointer(ipAddress)
if pointer == 0 || err != nil {
return NotFound, err
}
return r.resolveDataPointer(pointer)
} | |
c15905 | nodes: []netNode{
{
ip: make(net.IP, s),
},
},
}
} | |
c15906 | pointer: rightPointer,
ip: ipRight,
bit: node.bit,
})
node.pointer, err = n.reader.readNode(node.pointer, 0)
if err != nil {
n.err = err
return false
}
} else if node.pointer > n.reader.Metadata.NodeCount {
n.lastNode = node
return true
} else {
brea... | |
c15907 | IP: n.lastNode.ip,
Mask: net.CIDRMask(int(n.lastNode.bit), len(n.lastNode.ip)*8),
}, nil
} | |
c15908 | case _Map:
numberToSkip += 2 * size
case _Slice:
numberToSkip += size
case _Bool:
default:
offset += size
}
return d.nextValueOffset(offset, numberToSkip-1)
} | |
c15909 | := v.verifyMetadata(); err != nil {
return err
}
return v.verifyDatabase()
} | |
c15910 | nil)
r.hasMappedFile = false
err = munmap(r.buffer)
}
r.buffer = nil
return err
} | |
c15911 |
}
if err := tw.Close(); err != nil {
return "", err
}
if err := gw.Close(); err != nil {
return "", err
}
if err := f.Close(); err != nil {
return "", err
}
return fmt.Sprintf("%x", h.Sum(nil)), nil
} | |
c15912 | {
if !network.IsDHCP() {
continue
}
resolvedNetwork, err := s.resolveNetwork(network)
if err != nil {
break
}
settingsCopy.Networks[networkName] = resolvedNetwork
}
return settingsCopy
} | |
c15913 | ctrl}
mock.recorder = &MockAgentClientFactoryMockRecorder{mock}
return mock
} | |
c15914 | ret0, _ := ret[0].(agentclient.AgentClient)
ret1, _ := ret[1].(error)
return ret0, ret1
} | |
c15915 | reflect.TypeOf((*MockAgentClientFactory)(nil).NewAgentClient), directorID, mbusURL, caCert)
} | |
c15916 | j.Packages = s.Packages()
jobsWithSource = append(jobsWithSource, j)
}
}
return jobsWithSource
} | |
c15917 |
addresses = append(addresses, network.ToInterfaceAddress())
}
return
} | |
c15918 | cond,
}
m.state.Set(stateRunning)
if err := m.monitorLoop(); err != nil {
return nil, err
}
return m, nil
} | |
c15919 | // unused
0, // unused
)
if r1 != S_OK {
if e1 == 0 {
return "", os.NewSyscallError("CreateProfile", syscall.EINVAL)
}
return "", os.NewSyscallError("CreateProfile", e1)
}
profilePath := syscall.UTF16ToString(pathbuf[0:])
return profilePath, nil... | |
c15920 | // _In_opt_ LPCTSTR lpComputerName
)
if r1 == 0 {
if e1 == 0 {
return os.NewSyscallError("DeleteProfile", syscall.EINVAL)
}
return os.NewSyscallError("DeleteProfile", e1)
}
return nil
} | |
c15921 | // replacement char
for _, c := range out {
if c != '/' {
char = c
break
}
}
for i, c := range out {
if c == '/' {
out[i] = char
}
}
return string(out[:Length]), nil
} | |
c15922 | if validPassword(s) {
return s, nil
}
}
return "", errors.New("failed to generate valid Windows password")
} | |
c15923 | DialHostname(network, raddr, priority, tag, hostname)
} | |
c15924 | := w.writeAndRetry(LOG_ERR, m)
return err
} | |
c15925 | := w.writeAndRetry(LOG_WARNING, m)
return err
} | |
c15926 | := w.writeAndRetry(LOG_NOTICE, m)
return err
} | |
c15927 | byte(us - q*10 + '0')
us = q
}
i--
a[i] = byte(us + '0')
return append(dst, a[i:]...)
} | |
c15928 | startClient: shortClient,
stopClient: longClient,
unmonitorClient: longClient,
statusClient: shortClient,
logger: logger,
}
} | |
c15929 | len(e); i++ {
if !strings.HasPrefix(e[i], EnvPrefix) {
e[n] = e[i]
n++
}
}
return e
} | |
c15930 |
err = json.Unmarshal([]byte(contents), &spec)
if err != nil {
return spec, bosherr.WrapError(err, "Unmarshalling json spec file")
}
return spec, nil
} | |
c15931 | s.fs.WriteFile(s.specFilePath, specBytes)
if err != nil {
return bosherr.WrapError(err, "Writing spec to disk")
}
return nil
} | |
c15932 | match = func(_ string) bool { return true }
}
return &Mgr{m: m, match: match}, nil
} | |
c15933 | break
}
if err.(syscall.Errno) != syscall.ERROR_INSUFFICIENT_BUFFER {
return "", err
}
if n <= uint32(len(b)) {
return "", err
}
}
return toString(p.Description), nil
} | |
c15934 | err != nil {
s.Close()
continue // ignore - likely access denied
}
if m.match(desc) {
svcs = append(svcs, s)
} else {
s.Close()
}
}
return svcs, nil
} | |
c15935 | wg.Done()
defer s.Close()
if err := fn(s); err != nil {
mu.Lock()
if first == nil {
first = err
}
mu.Unlock()
}
}(s)
}
wg.Wait()
return
} | |
c15936 | = &ServiceError{"querying status of service", s.Name, err}
}
return status, err
} | |
c15937 | as well.
//
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms685996(v=vs.85).aspx
//
//
// Using the wait hint to check for state transition:
//
// Do not wait longer than the wait hint. A good interval is
// one-tenth of the wait hint but not less than 1 second
// and not more than 10 seco... | |
c15938 | > Timeout:
err := &TransitionError{
Msg: "timeout waiting for state transition",
Name: s.Name,
Status: status,
WaitHint: waitHint,
Duration: time.Since(start),
}
return status, err
}
}
if status.State == pendingState {
err := &TransitionError{
Msg: "failed to tran... | |
c15939 | if err != nil {
return nil, err
}
sts[i] = ServiceStatus{Name: s.Name, State: status.State}
}
return sts, nil
} | |
c15940 | return SetStartType(s, mgr.StartDisabled)
})
} | |
c15941 | &ServiceError{"opening service", name, err}
}
defer s.Close()
return SetStartType(s, mgr.StartManual)
} | |
c15942 | make(chan interface{}),
buf: queue.New(),
}
buf.in <- ch
return ch
} | |
c15943 | } else {
input = nil
}
case output <- next:
ch.buffer.Remove()
case ch.length <- ch.buffer.Length():
}
}
if ch.buffer.Length() > 0 {
output = ch.output
next = ch.buffer.Peek()
} else {
output = nil
next = nil
}
}
close(ch.output)
close(ch.length)
} | |
c15944 | bf := new(bytes.Buffer)
BufWriteLoop:
for {
select {
case b, ok := <-bc:
if !ok {
break BufWriteLoop
}
bf.Write(b)
case err := <-berrc:
return 0, err
}
}
return dst.Write(bf.Bytes())
} | |
c15945 | cssFilePath(path)
bc, berrc := compileBytes(data)
done, werrc := write(cssPath, bc, berrc)
select {
case <-done:
case err := <-werrc:
return "", err
}
return cssPath, nil
} | |
c15946 | {
return strings.TrimSuffix(path, filepath.Ext(path)) + ext
} | |
c15947 | err := w.Write([]byte(v.value))
return int64(n), err
} | |
c15948 | return "", "", fmt.Errorf("variable's name should end with a colon [line: %d]", ln.no)
}
return strings.TrimSuffix(strings.TrimPrefix(nv[0], dollarMark), colon), nv[1], nil
} | |
c15949 | {
return nil, fmt.Errorf("variable must not end with %q", semicolon)
}
return &variable{
elementBase: newElementBase(ln, parent),
name: name,
value: value,
}, nil
} | |
c15950 | nil, fmt.Errorf("mixin's format is invalid [line: %d]", ln.no)
}
var params []string
if paramsS != "" {
params = strings.Split(paramsS, comma)
}
for i, p := range params {
p = strings.TrimSpace(p)
if isDeclaration {
if !strings.HasPrefix(p, dollarMark) {
return "", nil, fmt.Errorf("mixin's parame... | |
c15951 | &mixinDeclaration{
elementBase: newElementBase(ln, parent),
name: name,
paramNames: paramNames,
}, nil
} | |
c15952 | e, _ = newMixinInvocation(ln, parent)
case ln.isVariable():
e, err = newVariable(ln, parent)
case ln.isDeclaration():
e, err = newDeclaration(ln, parent)
default:
e, err = newSelector(ln, parent)
}
return e, err
} | |
c15953 | return dec.writeTo(w, nil)
} | |
c15954 |
// Writing to the bytes.Buffer never returns an error.
dec.writeParamTo(bf, strings.TrimPrefix(w, dollarMark), params)
} else {
bf.WriteString(w)
}
}
}
bf.WriteString(semicolon)
n, err := w.Write(bf.Bytes())
return int64(n), err
} | |
c15955 | v, ok := dec.Context().vars[strings.TrimPrefix(s, dollarMark)]; ok {
return v.WriteTo(w)
}
return 0, nil
}
n, err := w.Write([]byte(s))
return int64(n), err
}
if v, ok := dec.Context().vars[name]; ok {
return v.WriteTo(w)
}
return 0, nil
} | |
c15956 | colon) {
return "", "", fmt.Errorf("property should end with a colon [line: %d]", ln.no)
}
return strings.TrimSuffix(pv[0], colon), pv[1], nil
} | |
c15957 |
return &declaration{
elementBase: newElementBase(ln, parent),
property: property,
value: value,
}, nil
} | |
c15958 |
eBase.decs = append(eBase.decs, c)
case *selector:
eBase.sels = append(eBase.sels, c)
}
} | |
c15959 | return eBase.parent.Context()
}
return eBase.ctx
} | |
c15960 | {
if decs, _ := mi.decsParams(); len(decs) > 0 {
return true
}
}
return false
} | |
c15961 | {
if sels, _ := mi.selsParams(); len(sels) > 0 {
return true
}
}
return false
} | |
c15962 | error.
dec.writeTo(bf, params)
}
// Write the mixin's declarations.
for _, mi := range eBase.mixins {
decs, prms := mi.decsParams()
for _, dec := range decs {
// Writing to the bytes.Buffer never returns an error.
dec.writeTo(bf, prms)
}
}
n, err := w.Write(bf.Bytes())
return int64(n), err
} | |
c15963 |
ln: ln,
parent: parent,
}
} | |
c15964 | string) {
w.Write([]byte(s + "\n"))
} | |
c15965 | <- struct{}{}
return
}
if _, err := w.Write(b); err != nil {
errc <- err
return
}
case err := <-berrc:
errc <- err
return
}
}
}()
return done, errc
} | |
c15966 | name := range md.paramNames {
if i < l {
params[name] = mi.paramValues[i]
}
}
return md.decs, params
} | |
c15967 | name := range md.paramNames {
if i < l {
params[name] = mi.paramValues[i]
}
}
return md.sels, params
} | |
c15968 | &mixinInvocation{
elementBase: newElementBase(ln, parent),
name: name,
paramValues: paramValues,
}, nil
} | |
c15969 |
case ln.indent == pIndent+1:
ok = true
case ln.indent > pIndent+1:
err = fmt.Errorf("indent is invalid [line: %d]", ln.no)
}
return ok, err
} | |
c15970 | err := declarationPV(ln)
return err == nil
} | |
c15971 | strings.HasPrefix(strings.TrimSpace(ln.s), atMark)
} | |
c15972 | _, _, err := variableNV(ln)
return err == nil
} | |
c15973 | _, _, err := mixinNP(ln, true)
return err == nil
} | |
c15974 | _, _, err := mixinNP(ln, false)
return err == nil
} | |
c15975 | strings.HasPrefix(strings.TrimSpace(ln.s), doubleSlash)
} | |
c15976 |
s: s,
indent: indent(s),
}
} | |
c15977 | {
break
}
i++
}
return i / 2
} | |
c15978 |
// Write the mixin's selectors.
for _, mi := range ar.mixins {
sels, prms := mi.selsParams()
for _, sl := range sels {
sl.parent = ar
// Writing to the bytes.Buffer never returns an error.
sl.writeTo(bf, prms)
}
}
bf.WriteString(closeBrace)
n, err := w.Write(bf.Bytes())
return int64(n), err
} | |
c15979 |
elementBase: newElementBase(ln, parent),
}
} | |
c15980 | return sel.writeTo(w, nil)
} | |
c15981 |
}
// Write the mixin's selectors.
for _, mi := range sel.mixins {
sels, prms := mi.selsParams()
for _, sl := range sels {
sl.parent = sel
// Writing to the bytes.Buffer never returns an error.
sl.writeTo(bf, prms)
}
}
n, err := w.Write(bf.Bytes())
return int64(n), err
} | |
c15982 | }
s = strings.TrimSpace(s)
if strings.Index(s, ampersand) != -1 {
bf.WriteString(strings.Replace(s, ampersand, parentS, -1))
} else {
bf.WriteString(parentS)
bf.WriteString(space)
bf.WriteString(s)
}
}
}
}
return bf.String()
} | |
c15983 | nil, fmt.Errorf("selector must not end with %q [line: %d]", closeBrace, ln.no)
}
return &selector{
elementBase: newElementBase(ln, parent),
name: name,
}, nil
} | |
c15984 | mixins: make(map[string]*mixinDeclaration),
}
} | |
c15985 |
elementBase: newElementBase(ln, parent),
}
} | |
c15986 | nil
}
child, err := newElement(ln, parent)
if err != nil {
return err
}
parent.AppendChild(child)
*i++
if err := appendChildren(child, lines, i, l); err != nil {
return err
}
}
return nil
} | |
c15987 | rings.Replace(strings.Replace(s, crlf, lf, -1), cr, lf, -1)
} | |
c15988 | := fastjson.Unmarshal(*params, dst); err != nil {
return ErrInvalidParams()
}
return nil
} | |
c15989 | {
return c.Value(requestIDKey{}).(*fastjson.RawMessage)
} | |
c15990 | context.WithValue(c, requestIDKey{}, id)
} | |
c15991 | to encode error objects")
w.WriteHeader(http.StatusInternalServerError)
}
return
}
resp := make([]*Response, len(rs))
for i := range rs {
resp[i] = mr.InvokeMethod(r.Context(), rs[i])
}
if err := SendResponse(w, resp, batch); err != nil {
fmt.Fprint(w, "Failed to encode result objects")
w.WriteHead... | |
c15992 | h.ServeJSONRPC(WithRequestID(c, r.ID), r.Params)
if res.Error != nil {
res.Result = nil
}
return res
} | |
c15993 |
return nil, ErrInvalidParams()
}
mr.m.RLock()
md, ok := mr.r[r.Method]
mr.m.RUnlock()
if !ok {
return nil, ErrMethodNotFound()
}
return md.Handler, nil
} | |
c15994 | return errors.New("jsonrpc: method name and function should not be empty")
}
mr.m.Lock()
mr.r[method] = Metadata{
Handler: h,
Params: params,
Result: result,
}
mr.m.Unlock()
return nil
} | |
c15995 | := make(map[string]Metadata, len(mr.r))
for k, md := range mr.r {
ml[k] = md
}
mr.m.RUnlock()
return ml
} | |
c15996 | if f != batchRequestKey {
var req *Request
if err := fastjson.NewDecoder(buf).Decode(&req); err != nil {
return nil, false, ErrParse()
}
return append(rs, req), false, nil
}
if err := fastjson.NewDecoder(buf).Decode(&rs); err != nil {
return nil, false, ErrParse()
}
return rs, true, rerr
} | |
c15997 | Version: r.Version,
ID: r.ID,
}
} | |
c15998 | return fastjson.NewEncoder(w).Encode(resp)
} else if len(resp) == 1 {
return fastjson.NewEncoder(w).Encode(resp[0])
}
return nil
} | |
c15999 | makeMethodReference(k, md))
}
w.Header().Set(contentTypeKey, contentTypeValue)
if err := fastjson.NewEncoder(w).Encode(l); err != nil {
w.WriteHeader(http.StatusInternalServerError)
return
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.