_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q15900 | Identifier | train | func (s *String) Identifier() string {
return C.GoString(C.string_identifier(s.cptr))
} | go | {
"resource": ""
} |
q15901 | Matches | train | func (s *String) Matches() (matches []Match) {
var size C.int
C.string_matches(s.cptr, nil, &size)
ptrs := make([]*C.YR_MATCH, int(size))
if size == 0 {
return
}
C.string_matches(s.cptr, &ptrs[0], &size)
for _, ptr := range ptrs {
matches = append(matches, Match{ptr})
}
return
} | go | {
"resource": ""
} |
q15902 | FromBytes | train | func FromBytes(buffer []byte) (*Reader, error) {
metadataStart := bytes.LastIndex(buffer, metadataStartMarker)
if metadataStart == -1 {
return nil, newInvalidDatabaseError("error opening database: invalid MaxMind DB file")
}
metadataStart += len(metadataStartMarker)
metadataDecoder := decoder{buffer[metadataSt... | go | {
"resource": ""
} |
q15903 | Lookup | train | func (r *Reader) Lookup(ipAddress net.IP, result interface{}) error {
if r.buffer == nil {
return errors.New("cannot call Lookup on a closed database")
}
pointer, err := r.lookupPointer(ipAddress)
if pointer == 0 || err != nil {
return err
}
return r.retrieveData(pointer, result)
} | go | {
"resource": ""
} |
q15904 | LookupOffset | train | func (r *Reader) LookupOffset(ipAddress net.IP) (uintptr, error) {
if r.buffer == nil {
return 0, errors.New("cannot call LookupOffset on a closed database")
}
pointer, err := r.lookupPointer(ipAddress)
if pointer == 0 || err != nil {
return NotFound, err
}
return r.resolveDataPointer(pointer)
} | go | {
"resource": ""
} |
q15905 | Networks | train | func (r *Reader) Networks() *Networks {
s := 4
if r.Metadata.IPVersion == 6 {
s = 16
}
return &Networks{
reader: r,
nodes: []netNode{
{
ip: make(net.IP, s),
},
},
}
} | go | {
"resource": ""
} |
q15906 | Next | train | func (n *Networks) Next() bool {
for len(n.nodes) > 0 {
node := n.nodes[len(n.nodes)-1]
n.nodes = n.nodes[:len(n.nodes)-1]
for {
if node.pointer < n.reader.Metadata.NodeCount {
ipRight := make(net.IP, len(node.ip))
copy(ipRight, node.ip)
if len(ipRight) <= int(node.bit>>3) {
n.err = newInval... | go | {
"resource": ""
} |
q15907 | Network | train | func (n *Networks) Network(result interface{}) (*net.IPNet, error) {
if err := n.reader.retrieveData(n.lastNode.pointer, result); err != nil {
return nil, err
}
return &net.IPNet{
IP: n.lastNode.ip,
Mask: net.CIDRMask(int(n.lastNode.bit), len(n.lastNode.ip)*8),
}, nil
} | go | {
"resource": ""
} |
q15908 | nextValueOffset | train | func (d *decoder) nextValueOffset(offset uint, numberToSkip uint) (uint, error) {
if numberToSkip == 0 {
return offset, nil
}
typeNum, size, offset, err := d.decodeCtrlData(offset)
if err != nil {
return 0, err
}
switch typeNum {
case _Pointer:
_, offset, err = d.decodePointer(size, offset)
if err != nil... | go | {
"resource": ""
} |
q15909 | Verify | train | func (r *Reader) Verify() error {
v := verifier{r}
if err := v.verifyMetadata(); err != nil {
return err
}
return v.verifyDatabase()
} | go | {
"resource": ""
} |
q15910 | Close | train | func (r *Reader) Close() error {
var err error
if r.hasMappedFile {
runtime.SetFinalizer(r, nil)
r.hasMappedFile = false
err = munmap(r.buffer)
}
r.buffer = nil
return err
} | go | {
"resource": ""
} |
q15911 | TarballDirectory | train | func TarballDirectory(dirname, rootdir, tarname string) (string, error) {
f, err := os.OpenFile(tarname, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0666)
if err != nil {
return "", err
}
h := sha1.New()
gw := gzip.NewWriter(io.MultiWriter(f, h))
tw := tar.NewWriter(gw)
w := TarWalker{
tw: tw,
root: rootdir,
}... | go | {
"resource": ""
} |
q15912 | GetSettings | train | func (s *settingsService) GetSettings() Settings {
s.settingsMutex.Lock()
settingsCopy := s.settings
if s.settings.Networks != nil {
settingsCopy.Networks = make(map[string]Network)
}
for networkName, network := range s.settings.Networks {
settingsCopy.Networks[networkName] = network
}
s.settingsMutex.Unl... | go | {
"resource": ""
} |
q15913 | NewMockAgentClientFactory | train | func NewMockAgentClientFactory(ctrl *gomock.Controller) *MockAgentClientFactory {
mock := &MockAgentClientFactory{ctrl: ctrl}
mock.recorder = &MockAgentClientFactoryMockRecorder{mock}
return mock
} | go | {
"resource": ""
} |
q15914 | NewAgentClient | train | func (m *MockAgentClientFactory) NewAgentClient(directorID, mbusURL, caCert string) (agentclient.AgentClient, error) {
m.ctrl.T.Helper()
ret := m.ctrl.Call(m, "NewAgentClient", directorID, mbusURL, caCert)
ret0, _ := ret[0].(agentclient.AgentClient)
ret1, _ := ret[1].(error)
return ret0, ret1
} | go | {
"resource": ""
} |
q15915 | NewAgentClient | train | func (mr *MockAgentClientFactoryMockRecorder) NewAgentClient(directorID, mbusURL, caCert interface{}) *gomock.Call {
mr.mock.ctrl.T.Helper()
return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewAgentClient", reflect.TypeOf((*MockAgentClientFactory)(nil).NewAgentClient), directorID, mbusURL, caCert)
} | go | {
"resource": ""
} |
q15916 | Jobs | train | func (s V1ApplySpec) Jobs() []models.Job {
jobsWithSource := []models.Job{}
if s.RenderedTemplatesArchiveSpec != nil {
for _, j := range s.JobSpec.JobTemplateSpecsAsJobs() {
j.Source = s.RenderedTemplatesArchiveSpec.AsSource(j)
j.Packages = s.Packages()
jobsWithSource = append(jobsWithSource, j)
}
}
... | go | {
"resource": ""
} |
q15917 | toInterfaceAddresses | train | func toInterfaceAddresses(networks []customNetwork) (addresses []boship.InterfaceAddress) {
for _, network := range networks {
addresses = append(addresses, network.ToInterfaceAddress())
}
return
} | go | {
"resource": ""
} |
q15918 | condMonitor | train | func condMonitor(freq time.Duration, cond *sync.Cond) (*Monitor, error) {
m := &Monitor{
tick: time.NewTicker(freq),
inited: true,
cond: cond,
}
m.state.Set(stateRunning)
if err := m.monitorLoop(); err != nil {
return nil, err
}
return m, nil
} | go | {
"resource": ""
} |
q15919 | createProfile | train | func createProfile(sid, username string) (string, error) {
const S_OK = 0x00000000
if err := procCreateProfile.Find(); err != nil {
return "", err
}
psid, err := syscall.UTF16PtrFromString(sid)
if err != nil {
return "", err
}
pusername, err := syscall.UTF16PtrFromString(username)
if err != nil {
return "... | go | {
"resource": ""
} |
q15920 | deleteProfile | train | func deleteProfile(sid string) error {
if err := procDeleteProfile.Find(); err != nil {
return err
}
psid, err := syscall.UTF16PtrFromString(sid)
if err != nil {
return err
}
r1, _, e1 := syscall.Syscall(procDeleteProfile.Addr(), 3,
uintptr(unsafe.Pointer(psid)), // _In_ LPCTSTR lpSidString,
0, ... | go | {
"resource": ""
} |
q15921 | generatePassword | train | func generatePassword() (string, error) {
const Length = 14
in := make([]byte, ascii85.MaxEncodedLen(Length))
if _, err := io.ReadFull(rand.Reader, in); err != nil {
return "", err
}
out := make([]byte, ascii85.MaxEncodedLen(len(in)))
if n := ascii85.Encode(out, in); n < Length {
return "", errors.New("short... | go | {
"resource": ""
} |
q15922 | randomPassword | train | func randomPassword() (string, error) {
limit := 100
for ; limit >= 0; limit-- {
s, err := generatePassword()
if err != nil {
return "", err
}
if validPassword(s) {
return s, nil
}
}
return "", errors.New("failed to generate valid Windows password")
} | go | {
"resource": ""
} |
q15923 | Dial | train | func Dial(network, raddr string, priority Priority, tag string) (*Writer, error) {
hostname, _ := os.Hostname()
return DialHostname(network, raddr, priority, tag, hostname)
} | go | {
"resource": ""
} |
q15924 | Err | train | func (w *Writer) Err(m string) error {
_, err := w.writeAndRetry(LOG_ERR, m)
return err
} | go | {
"resource": ""
} |
q15925 | Warning | train | func (w *Writer) Warning(m string) error {
_, err := w.writeAndRetry(LOG_WARNING, m)
return err
} | go | {
"resource": ""
} |
q15926 | Notice | train | func (w *Writer) Notice(m string) error {
_, err := w.writeAndRetry(LOG_NOTICE, m)
return err
} | go | {
"resource": ""
} |
q15927 | itoa | train | func itoa(dst []byte, n int) []byte {
var a [20]byte
i := len(a)
us := uintptr(n)
for us >= 10 {
i--
q := us / 10
a[i] = byte(us - q*10 + '0')
us = q
}
i--
a[i] = byte(us + '0')
return append(dst, a[i:]...)
} | go | {
"resource": ""
} |
q15928 | NewHTTPClient | train | func NewHTTPClient(
host, username, password string,
shortClient HTTPClient,
longClient HTTPClient,
logger boshlog.Logger,
) Client {
return httpClient{
host: host,
username: username,
password: password,
startClient: shortClient,
stopClient: longClient,
unmonitorClien... | go | {
"resource": ""
} |
q15929 | Environ | train | func Environ() []string {
e := os.Environ()
for i, n := 0, 0; i < len(e); i++ {
if !strings.HasPrefix(e[i], EnvPrefix) {
e[n] = e[i]
n++
}
}
return e
} | go | {
"resource": ""
} |
q15930 | Get | train | func (s concreteV1Service) Get() (V1ApplySpec, error) {
var spec V1ApplySpec
if !s.fs.FileExists(s.specFilePath) {
return spec, nil
}
contents, err := s.fs.ReadFile(s.specFilePath)
if err != nil {
return spec, bosherr.WrapError(err, "Reading json spec file")
}
err = json.Unmarshal([]byte(contents), &spec)... | go | {
"resource": ""
} |
q15931 | Set | train | func (s concreteV1Service) Set(spec V1ApplySpec) error {
specBytes, err := json.Marshal(spec)
if err != nil {
return bosherr.WrapError(err, "Marshalling apply spec")
}
err = s.fs.WriteFile(s.specFilePath, specBytes)
if err != nil {
return bosherr.WrapError(err, "Writing spec to disk")
}
return nil
} | go | {
"resource": ""
} |
q15932 | Connect | train | func Connect(match func(description string) bool) (*Mgr, error) {
m, err := mgr.Connect()
if err != nil {
return nil, err
}
if match == nil {
match = func(_ string) bool { return true }
}
return &Mgr{m: m, match: match}, nil
} | go | {
"resource": ""
} |
q15933 | serviceDescription | train | func serviceDescription(s *mgr.Service) (string, error) {
var p *windows.SERVICE_DESCRIPTION
n := uint32(1024)
for {
b := make([]byte, n)
p = (*windows.SERVICE_DESCRIPTION)(unsafe.Pointer(&b[0]))
err := windows.QueryServiceConfig2(s.Handle,
windows.SERVICE_CONFIG_DESCRIPTION, &b[0], n, &n)
if err == nil {... | go | {
"resource": ""
} |
q15934 | services | train | func (m *Mgr) services() ([]*mgr.Service, error) {
names, err := m.m.ListServices()
if err != nil {
return nil, fmt.Errorf("winsvc: listing services: %s", err)
}
var svcs []*mgr.Service
for _, name := range names {
s, err := m.m.OpenService(name)
if err != nil {
continue // ignore - likely access denied
... | go | {
"resource": ""
} |
q15935 | iter | train | func (m *Mgr) iter(fn func(*mgr.Service) error) (first error) {
svcs, err := m.services()
if err != nil {
return err
}
var mu sync.Mutex
var wg sync.WaitGroup
wg.Add(len(svcs))
for _, s := range svcs {
go func(s *mgr.Service) {
defer wg.Done()
defer s.Close()
if err := fn(s); err != nil {
mu.Loc... | go | {
"resource": ""
} |
q15936 | querySvc | train | func querySvc(s *mgr.Service) (svc.Status, error) {
status, err := s.Query()
if err != nil {
err = &ServiceError{"querying status of service", s.Name, err}
}
return status, err
} | go | {
"resource": ""
} |
q15937 | calculateWaitHint | train | func calculateWaitHint(status svc.Status) (waitHint, interval time.Duration) {
//
// This is all a little confusing, so I included the definition of WaitHint
// and Microsoft's guidelines on how to use below:
//
//
// Definition of WaitHint:
//
// The estimated time required for a pending start, stop, pause, ... | go | {
"resource": ""
} |
q15938 | waitPending | train | func waitPending(s *mgr.Service, pendingState svc.State) (svc.Status, error) {
// Arbitrary timeout to prevent misbehaving
// services from triggering an infinite loop.
const Timeout = time.Minute * 20
if pendingState != svc.StartPending && pendingState != svc.StopPending {
// This is a programming error and rea... | go | {
"resource": ""
} |
q15939 | Status | train | func (m *Mgr) Status() ([]ServiceStatus, error) {
svcs, err := m.services()
if err != nil {
return nil, err
}
defer closeServices(svcs)
sts := make([]ServiceStatus, len(svcs))
for i, s := range svcs {
status, err := querySvc(s)
if err != nil {
return nil, err
}
sts[i] = ServiceStatus{Name: s.Name, S... | go | {
"resource": ""
} |
q15940 | Unmonitor | train | func (m *Mgr) Unmonitor() error {
return m.iter(func(s *mgr.Service) error {
return SetStartType(s, mgr.StartDisabled)
})
} | go | {
"resource": ""
} |
q15941 | DisableAgentAutoStart | train | func (m *Mgr) DisableAgentAutoStart() error {
const name = "bosh-agent"
s, err := m.m.OpenService("bosh-agent")
if err != nil {
return &ServiceError{"opening service", name, err}
}
defer s.Close()
return SetStartType(s, mgr.StartManual)
} | go | {
"resource": ""
} |
q15942 | NewChannel | train | func (buf *SharedBuffer) NewChannel() SimpleChannel {
ch := &sharedBufferChannel{
in: make(chan interface{}),
out: make(chan interface{}),
buf: queue.New(),
}
buf.in <- ch
return ch
} | go | {
"resource": ""
} |
q15943 | ringBuffer | train | func (ch *RingChannel) ringBuffer() {
var input, output chan interface{}
var next interface{}
input = ch.input
for input != nil || output != nil {
select {
// Prefer to write if possible, which is surprisingly effective in reducing
// dropped elements due to overflow. The naive read/write select chooses rand... | go | {
"resource": ""
} |
q15944 | Compile | train | func Compile(dst io.Writer, src io.Reader) (int, error) {
data, err := ioutil.ReadAll(src)
if err != nil {
return 0, err
}
bc, berrc := compileBytes(data)
bf := new(bytes.Buffer)
BufWriteLoop:
for {
select {
case b, ok := <-bc:
if !ok {
break BufWriteLoop
}
bf.Write(b)
case err := <-berr... | go | {
"resource": ""
} |
q15945 | CompileFile | train | func CompileFile(path string) (string, error) {
data, err := ioutil.ReadFile(path)
if err != nil {
return "", err
}
cssPath := cssFilePath(path)
bc, berrc := compileBytes(data)
done, werrc := write(cssPath, bc, berrc)
select {
case <-done:
case err := <-werrc:
return "", err
}
return cssPath, nil
} | go | {
"resource": ""
} |
q15946 | convertExt | train | func convertExt(path string, ext string) string {
return strings.TrimSuffix(path, filepath.Ext(path)) + ext
} | go | {
"resource": ""
} |
q15947 | WriteTo | train | func (v *variable) WriteTo(w io.Writer) (int64, error) {
n, err := w.Write([]byte(v.value))
return int64(n), err
} | go | {
"resource": ""
} |
q15948 | variableNV | train | func variableNV(ln *line) (string, string, error) {
s := strings.TrimSpace(ln.s)
if !strings.HasPrefix(s, dollarMark) {
return "", "", fmt.Errorf("variable must start with %q [line: %d]", dollarMark, ln.no)
}
nv := strings.SplitN(s, space, 2)
if len(nv) < 2 {
return "", "", fmt.Errorf("variable's name and v... | go | {
"resource": ""
} |
q15949 | newVariable | train | func newVariable(ln *line, parent element) (*variable, error) {
name, value, err := variableNV(ln)
if err != nil {
return nil, err
}
if strings.HasSuffix(value, semicolon) {
return nil, fmt.Errorf("variable must not end with %q", semicolon)
}
return &variable{
elementBase: newElementBase(ln, parent),
n... | go | {
"resource": ""
} |
q15950 | mixinNP | train | func mixinNP(ln *line, isDeclaration bool) (string, []string, error) {
s := strings.TrimSpace(ln.s)
if !strings.HasPrefix(s, dollarMark) {
return "", nil, fmt.Errorf("mixin must start with %q [line: %d]", dollarMark, ln.no)
}
s = strings.TrimPrefix(s, dollarMark)
np := strings.Split(s, openParenthesis)
if l... | go | {
"resource": ""
} |
q15951 | newMixinDeclaration | train | func newMixinDeclaration(ln *line, parent element) (*mixinDeclaration, error) {
name, paramNames, err := mixinNP(ln, true)
if err != nil {
return nil, err
}
return &mixinDeclaration{
elementBase: newElementBase(ln, parent),
name: name,
paramNames: paramNames,
}, nil
} | go | {
"resource": ""
} |
q15952 | newElement | train | func newElement(ln *line, parent element) (element, error) {
var e element
var err error
switch {
case ln.isComment():
e = newComment(ln, parent)
case ln.isAtRule():
e = newAtRule(ln, parent)
case ln.isMixinDeclaration():
// error can be ignored becuase the line is checked beforehand
// by calling `ln.is... | go | {
"resource": ""
} |
q15953 | WriteTo | train | func (dec *declaration) WriteTo(w io.Writer) (int64, error) {
return dec.writeTo(w, nil)
} | go | {
"resource": ""
} |
q15954 | writeTo | train | func (dec *declaration) writeTo(w io.Writer, params map[string]string) (int64, error) {
bf := new(bytes.Buffer)
bf.WriteString(dec.property)
bf.WriteString(colon)
for i, v := range strings.Split(dec.value, space) {
if i > 0 {
bf.WriteString(space)
}
for j, w := range strings.Split(v, comma) {
if j > ... | go | {
"resource": ""
} |
q15955 | writeParamTo | train | func (dec *declaration) writeParamTo(w io.Writer, name string, params map[string]string) (int64, error) {
if s, ok := params[name]; ok {
if strings.HasPrefix(s, dollarMark) {
if v, ok := dec.Context().vars[strings.TrimPrefix(s, dollarMark)]; ok {
return v.WriteTo(w)
}
return 0, nil
}
n, err := w.Wr... | go | {
"resource": ""
} |
q15956 | declarationPV | train | func declarationPV(ln *line) (string, string, error) {
pv := strings.SplitN(strings.TrimSpace(ln.s), space, 2)
if len(pv) < 2 {
return "", "", fmt.Errorf("declaration's property and value should be divided by a space [line: %d]", ln.no)
}
if !strings.HasSuffix(pv[0], colon) {
return "", "", fmt.Errorf("proper... | go | {
"resource": ""
} |
q15957 | newDeclaration | train | func newDeclaration(ln *line, parent element) (*declaration, error) {
property, value, err := declarationPV(ln)
if err != nil {
return nil, err
}
if strings.HasSuffix(value, semicolon) {
return nil, fmt.Errorf("declaration must not end with %q [line: %d]", semicolon, ln.no)
}
return &declaration{
element... | go | {
"resource": ""
} |
q15958 | AppendChild | train | func (eBase *elementBase) AppendChild(child element) {
switch c := child.(type) {
case *mixinInvocation:
eBase.mixins = append(eBase.mixins, c)
case *declaration:
eBase.decs = append(eBase.decs, c)
case *selector:
eBase.sels = append(eBase.sels, c)
}
} | go | {
"resource": ""
} |
q15959 | Context | train | func (eBase *elementBase) Context() *context {
if eBase.parent != nil {
return eBase.parent.Context()
}
return eBase.ctx
} | go | {
"resource": ""
} |
q15960 | hasMixinDecs | train | func (eBase *elementBase) hasMixinDecs() bool {
for _, mi := range eBase.mixins {
if decs, _ := mi.decsParams(); len(decs) > 0 {
return true
}
}
return false
} | go | {
"resource": ""
} |
q15961 | hasMixinSels | train | func (eBase *elementBase) hasMixinSels() bool {
for _, mi := range eBase.mixins {
if sels, _ := mi.selsParams(); len(sels) > 0 {
return true
}
}
return false
} | go | {
"resource": ""
} |
q15962 | writeDecsTo | train | func (eBase *elementBase) writeDecsTo(w io.Writer, params map[string]string) (int64, error) {
bf := new(bytes.Buffer)
// Write the declarations.
for _, dec := range eBase.decs {
// Writing to the bytes.Buffer never returns an error.
dec.writeTo(bf, params)
}
// Write the mixin's declarations.
for _, mi := r... | go | {
"resource": ""
} |
q15963 | newElementBase | train | func newElementBase(ln *line, parent element) elementBase {
return elementBase{
ln: ln,
parent: parent,
}
} | go | {
"resource": ""
} |
q15964 | writeTo | train | func writeTo(w io.Writer, s string) {
w.Write([]byte(s + "\n"))
} | go | {
"resource": ""
} |
q15965 | write | train | func write(path string, bc <-chan []byte, berrc <-chan error) (<-chan struct{}, <-chan error) {
done := make(chan struct{})
errc := make(chan error)
go func() {
f, err := os.Create(path)
if err != nil {
errc <- err
return
}
defer f.Close()
w := newBufWriter(f)
for {
select {
case b, ok :... | go | {
"resource": ""
} |
q15966 | decsParams | train | func (mi *mixinInvocation) decsParams() ([]*declaration, map[string]string) {
md, ok := mi.Context().mixins[mi.name]
if !ok {
return nil, nil
}
params := make(map[string]string)
l := len(mi.paramValues)
for i, name := range md.paramNames {
if i < l {
params[name] = mi.paramValues[i]
}
}
return md.... | go | {
"resource": ""
} |
q15967 | selsParams | train | func (mi *mixinInvocation) selsParams() ([]*selector, map[string]string) {
md, ok := mi.Context().mixins[mi.name]
if !ok {
return nil, nil
}
params := make(map[string]string)
l := len(mi.paramValues)
for i, name := range md.paramNames {
if i < l {
params[name] = mi.paramValues[i]
}
}
return md.sel... | go | {
"resource": ""
} |
q15968 | newMixinInvocation | train | func newMixinInvocation(ln *line, parent element) (*mixinInvocation, error) {
name, paramValues, err := mixinNP(ln, false)
if err != nil {
return nil, err
}
return &mixinInvocation{
elementBase: newElementBase(ln, parent),
name: name,
paramValues: paramValues,
}, nil
} | go | {
"resource": ""
} |
q15969 | childOf | train | func (ln *line) childOf(parent element) (bool, error) {
var ok bool
var err error
switch pIndent := parent.Base().ln.indent; {
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
} | go | {
"resource": ""
} |
q15970 | isDeclaration | train | func (ln *line) isDeclaration() bool {
_, _, err := declarationPV(ln)
return err == nil
} | go | {
"resource": ""
} |
q15971 | isAtRule | train | func (ln *line) isAtRule() bool {
return strings.HasPrefix(strings.TrimSpace(ln.s), atMark)
} | go | {
"resource": ""
} |
q15972 | isVariable | train | func (ln *line) isVariable() bool {
if !ln.isTopIndent() {
return false
}
_, _, err := variableNV(ln)
return err == nil
} | go | {
"resource": ""
} |
q15973 | isMixinDeclaration | train | func (ln *line) isMixinDeclaration() bool {
if !ln.isTopIndent() {
return false
}
_, _, err := mixinNP(ln, true)
return err == nil
} | go | {
"resource": ""
} |
q15974 | isMixinInvocation | train | func (ln *line) isMixinInvocation() bool {
if ln.isTopIndent() {
return false
}
_, _, err := mixinNP(ln, false)
return err == nil
} | go | {
"resource": ""
} |
q15975 | isComment | train | func (ln *line) isComment() bool {
return strings.HasPrefix(strings.TrimSpace(ln.s), doubleSlash)
} | go | {
"resource": ""
} |
q15976 | newLine | train | func newLine(no int, s string) *line {
return &line{
no: no,
s: s,
indent: indent(s),
}
} | go | {
"resource": ""
} |
q15977 | indent | train | func indent(s string) int {
var i int
for _, b := range s {
if b != unicodeSpace {
break
}
i++
}
return i / 2
} | go | {
"resource": ""
} |
q15978 | WriteTo | train | func (ar *atRule) WriteTo(w io.Writer) (int64, error) {
bf := new(bytes.Buffer)
bf.WriteString(strings.TrimSpace(ar.ln.s))
if len(ar.sels) == 0 && len(ar.decs) == 0 && !ar.hasMixinDecs() && !ar.hasMixinSels() {
bf.WriteString(semicolon)
n, err := w.Write(bf.Bytes())
return int64(n), err
}
bf.WriteString(o... | go | {
"resource": ""
} |
q15979 | newAtRule | train | func newAtRule(ln *line, parent element) *atRule {
return &atRule{
elementBase: newElementBase(ln, parent),
}
} | go | {
"resource": ""
} |
q15980 | WriteTo | train | func (sel *selector) WriteTo(w io.Writer) (int64, error) {
return sel.writeTo(w, nil)
} | go | {
"resource": ""
} |
q15981 | writeTo | train | func (sel *selector) writeTo(w io.Writer, params map[string]string) (int64, error) {
bf := new(bytes.Buffer)
// Write the declarations.
if len(sel.decs) > 0 || sel.hasMixinDecs() {
bf.WriteString(sel.names())
bf.WriteString(openBrace)
// Writing to the bytes.Buffer never returns an error.
sel.writeDecsTo(b... | go | {
"resource": ""
} |
q15982 | names | train | func (sel *selector) names() string {
bf := new(bytes.Buffer)
switch parent := sel.parent.(type) {
case nil, *atRule:
for _, name := range strings.Split(sel.name, comma) {
if bf.Len() > 0 {
bf.WriteString(comma)
}
bf.WriteString(strings.TrimSpace(name))
}
case *selector:
for _, parentS := range... | go | {
"resource": ""
} |
q15983 | newSelector | train | func newSelector(ln *line, parent element) (*selector, error) {
name := strings.TrimSpace(ln.s)
if strings.HasSuffix(name, openBrace) {
return nil, fmt.Errorf("selector must not end with %q [line: %d]", openBrace, ln.no)
}
if strings.HasSuffix(name, closeBrace) {
return nil, fmt.Errorf("selector must not end ... | go | {
"resource": ""
} |
q15984 | newContext | train | func newContext() *context {
return &context{
vars: make(map[string]*variable),
mixins: make(map[string]*mixinDeclaration),
}
} | go | {
"resource": ""
} |
q15985 | newComment | train | func newComment(ln *line, parent element) *comment {
return &comment{
elementBase: newElementBase(ln, parent),
}
} | go | {
"resource": ""
} |
q15986 | appendChildren | train | func appendChildren(parent element, lines []string, i *int, l int) error {
for *i < l {
// Fetch a line.
ln := newLine(*i+1, lines[*i])
// Ignore the empty line.
if ln.isEmpty() {
*i++
return nil
}
ok, err := ln.childOf(parent)
if err != nil {
return err
}
if !ok {
return nil
}
c... | go | {
"resource": ""
} |
q15987 | formatLF | train | func formatLF(s string) string {
return strings.Replace(strings.Replace(s, crlf, lf, -1), cr, lf, -1)
} | go | {
"resource": ""
} |
q15988 | Unmarshal | train | func Unmarshal(params *fastjson.RawMessage, dst interface{}) *Error {
if params == nil {
return ErrInvalidParams()
}
if err := fastjson.Unmarshal(*params, dst); err != nil {
return ErrInvalidParams()
}
return nil
} | go | {
"resource": ""
} |
q15989 | RequestID | train | func RequestID(c context.Context) *fastjson.RawMessage {
return c.Value(requestIDKey{}).(*fastjson.RawMessage)
} | go | {
"resource": ""
} |
q15990 | WithRequestID | train | func WithRequestID(c context.Context, id *fastjson.RawMessage) context.Context {
return context.WithValue(c, requestIDKey{}, id)
} | go | {
"resource": ""
} |
q15991 | ServeHTTP | train | func (mr *MethodRepository) ServeHTTP(w http.ResponseWriter, r *http.Request) {
rs, batch, err := ParseRequest(r)
if err != nil {
err := SendResponse(w, []*Response{
{
Version: Version,
Error: err,
},
}, false)
if err != nil {
fmt.Fprint(w, "Failed to encode error objects")
w.WriteHeader(... | go | {
"resource": ""
} |
q15992 | InvokeMethod | train | func (mr *MethodRepository) InvokeMethod(c context.Context, r *Request) *Response {
var h Handler
res := NewResponse(r)
h, res.Error = mr.TakeMethod(r)
if res.Error != nil {
return res
}
res.Result, res.Error = h.ServeJSONRPC(WithRequestID(c, r.ID), r.Params)
if res.Error != nil {
res.Result = nil
}
return... | go | {
"resource": ""
} |
q15993 | TakeMethod | train | func (mr *MethodRepository) TakeMethod(r *Request) (Handler, *Error) {
if r.Method == "" || r.Version != Version {
return nil, ErrInvalidParams()
}
mr.m.RLock()
md, ok := mr.r[r.Method]
mr.m.RUnlock()
if !ok {
return nil, ErrMethodNotFound()
}
return md.Handler, nil
} | go | {
"resource": ""
} |
q15994 | RegisterMethod | train | func (mr *MethodRepository) RegisterMethod(method string, h Handler, params, result interface{}) error {
if method == "" || h == nil {
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.Unlo... | go | {
"resource": ""
} |
q15995 | Methods | train | func (mr *MethodRepository) Methods() map[string]Metadata {
mr.m.RLock()
ml := make(map[string]Metadata, len(mr.r))
for k, md := range mr.r {
ml[k] = md
}
mr.m.RUnlock()
return ml
} | go | {
"resource": ""
} |
q15996 | ParseRequest | train | func ParseRequest(r *http.Request) ([]*Request, bool, *Error) {
var rerr *Error
if !strings.HasPrefix(r.Header.Get(contentTypeKey), contentTypeValue) {
return nil, false, ErrInvalidRequest()
}
buf := bytes.NewBuffer(make([]byte, 0, r.ContentLength))
if _, err := buf.ReadFrom(r.Body); err != nil {
return nil... | go | {
"resource": ""
} |
q15997 | NewResponse | train | func NewResponse(r *Request) *Response {
return &Response{
Version: r.Version,
ID: r.ID,
}
} | go | {
"resource": ""
} |
q15998 | SendResponse | train | func SendResponse(w http.ResponseWriter, resp []*Response, batch bool) error {
w.Header().Set(contentTypeKey, contentTypeValue)
if batch || len(resp) > 1 {
return fastjson.NewEncoder(w).Encode(resp)
} else if len(resp) == 1 {
return fastjson.NewEncoder(w).Encode(resp[0])
}
return nil
} | go | {
"resource": ""
} |
q15999 | ServeDebug | train | func (mr *MethodRepository) ServeDebug(w http.ResponseWriter, r *http.Request) { // nolint: unparam
ms := mr.Methods()
if len(ms) == 0 {
w.WriteHeader(http.StatusNotFound)
return
}
l := make([]*MethodReference, 0, len(ms))
for k, md := range ms {
l = append(l, makeMethodReference(k, md))
}
w.Header().Set(c... | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.