_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[metadataStart:]}
var metadata Metadata
rvMetdata := reflect.ValueOf(&metadata)
_, err := metadataDecoder.decode(0, rvMetdata, 0)
if err != nil {
return nil, err
}
searchTreeSize := metadata.NodeCount * metadata.RecordSize / 4
dataSectionStart := searchTreeSize + dataSectionSeparatorSize
dataSectionEnd := uint(metadataStart - len(metadataStartMarker))
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,
ipv4Start: 0,
}
reader.ipv4Start, err = reader.startNode()
return reader, err
} | 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 = newInvalidDatabaseError(
"invalid search tree at %v/%v", ipRight, node.bit)
return false
}
ipRight[node.bit>>3] |= 1 << (7 - (node.bit % 8))
rightPointer, err := n.reader.readNode(node.pointer, 1)
if err != nil {
n.err = err
return false
}
node.bit++
n.nodes = append(n.nodes, netNode{
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 {
break
}
}
}
return false
} | 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 {
return 0, err
}
case _Map:
numberToSkip += 2 * size
case _Slice:
numberToSkip += size
case _Bool:
default:
offset += size
}
return d.nextValueOffset(offset, numberToSkip-1)
} | 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,
}
if err := filepath.Walk(dirname, w.Walk); err != nil {
return "", err
}
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
} | 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.Unlock()
for networkName, network := range settingsCopy.Networks {
if !network.IsDHCP() {
continue
}
resolvedNetwork, err := s.resolveNetwork(network)
if err != nil {
break
}
settingsCopy.Networks[networkName] = resolvedNetwork
}
return settingsCopy
} | 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)
}
}
return jobsWithSource
} | 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 "", err
}
var pathbuf [260]uint16
r1, _, e1 := syscall.Syscall6(procCreateProfile.Addr(), 4,
uintptr(unsafe.Pointer(psid)), // _In_ LPCWSTR pszUserSid
uintptr(unsafe.Pointer(pusername)), // _In_ LPCWSTR pszUserName
uintptr(unsafe.Pointer(&pathbuf[0])), // _Out_ LPWSTR pszProfilePath
uintptr(len(pathbuf)), // _In_ DWORD cchProfilePath
0, // 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
} | 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, // _In_opt_ LPCTSTR lpProfilePath,
0, // _In_opt_ LPCTSTR lpComputerName
)
if r1 == 0 {
if e1 == 0 {
return os.NewSyscallError("DeleteProfile", syscall.EINVAL)
}
return os.NewSyscallError("DeleteProfile", e1)
}
return nil
} | 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 password")
}
// replace forward slashes as NET USER does not like them
var char byte // 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
} | 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,
unmonitorClient: longClient,
statusClient: shortClient,
logger: logger,
}
} | 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)
if err != nil {
return spec, bosherr.WrapError(err, "Unmarshalling json spec file")
}
return spec, nil
} | 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 {
break
}
if err.(syscall.Errno) != syscall.ERROR_INSUFFICIENT_BUFFER {
return "", err
}
if n <= uint32(len(b)) {
return "", err
}
}
return toString(p.Description), 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
}
desc, err := serviceDescription(s)
if err != nil {
s.Close()
continue // ignore - likely access denied
}
if m.match(desc) {
svcs = append(svcs, s)
} else {
s.Close()
}
}
return svcs, nil
} | 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.Lock()
if first == nil {
first = err
}
mu.Unlock()
}
}(s)
}
wg.Wait()
return
} | 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, or
// continue operation, in milliseconds. Before the specified amount
// of time has elapsed, the service should make its next call to the
// SetServiceStatus function with either an incremented dwCheckPoint
// value or a change in dwCurrentState. If the amount of time specified
// by dwWaitHint passes, and dwCheckPoint has not been incremented or
// dwCurrentState has not changed, the service control manager or service
// control program can assume that an error has occurred and the service
// should be stopped. However, if the service shares a process with other
// services, the service control manager cannot terminate the service
// application because it would have to terminate the other services
// sharing the process 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 seconds.
//
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms686315(v=vs.85).aspx
//
waitHint = time.Duration(status.WaitHint) * time.Millisecond
if waitHint == 0 {
waitHint = time.Second * 10
}
interval = waitHint / 10
switch {
case interval < time.Second:
interval = time.Second
case interval > time.Second*10:
interval = time.Second * 10
}
return
} | 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 really should be a panic.
return svc.Status{}, errors.New("winsvc: invalid pending state: " +
svcStateString(pendingState))
}
status, err := querySvc(s)
if err != nil {
return status, err
}
start := time.Now()
for status.State == pendingState {
waitHint, interval := calculateWaitHint(status)
time.Sleep(interval) // sleep before rechecking status
status, err = querySvc(s)
if err != nil {
return status, err
}
if status.State != pendingState {
break
}
switch {
// Exceeded our timeout
case time.Since(start) > 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 transition out of state",
Name: s.Name,
Status: status,
Duration: time.Since(start),
}
return status, err
}
return status, nil
} | 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, State: status.State}
}
return sts, nil
} | 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 randomly
// when both channels are ready, which produces unnecessary drops 50% of the time.
case output <- next:
ch.buffer.Remove()
default:
select {
case elem, open := <-input:
if open {
ch.buffer.Add(elem)
if ch.size != Infinity && ch.buffer.Length() > int(ch.size) {
ch.buffer.Remove()
}
} 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)
} | 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 := <-berrc:
return 0, err
}
}
return dst.Write(bf.Bytes())
} | 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 value should be divided by a space [line: %d]", ln.no)
}
if !strings.HasSuffix(nv[0], colon) {
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
} | 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),
name: name,
value: value,
}, nil
} | 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 len(np) != 2 {
return "", nil, fmt.Errorf("mixin's format is invalid [line: %d]", ln.no)
}
paramsS := strings.TrimSpace(np[1])
if !strings.HasSuffix(paramsS, closeParenthesis) {
return "", nil, fmt.Errorf("mixin must end with %q [line: %d]", closeParenthesis, ln.no)
}
paramsS = strings.TrimSuffix(paramsS, closeParenthesis)
if strings.Index(paramsS, closeParenthesis) != -1 {
return "", 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 parameter must start with %q [line: %d]", dollarMark, ln.no)
}
p = strings.TrimPrefix(p, dollarMark)
}
params[i] = p
}
return np[0], params, nil
} | 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.isMixinDeclaration()`.
e, _ = newMixinDeclaration(ln, parent)
case ln.isMixinInvocation():
// error can be ignored becuase the line is checked beforehand
// by calling `ln.isMixinInvocation()`.
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
} | 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 > 0 {
bf.WriteString(comma)
}
if strings.HasPrefix(w, dollarMark) {
// 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
} | 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.Write([]byte(s))
return int64(n), err
}
if v, ok := dec.Context().vars[name]; ok {
return v.WriteTo(w)
}
return 0, nil
} | 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("property should end with a colon [line: %d]", ln.no)
}
return strings.TrimSuffix(pv[0], colon), pv[1], nil
} | 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{
elementBase: newElementBase(ln, parent),
property: property,
value: value,
}, nil
} | 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 := 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
} | 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 := <-bc:
if !ok {
if err := w.Flush(); err != nil {
errc <- err
return
}
done <- struct{}{}
return
}
if _, err := w.Write(b); err != nil {
errc <- err
return
}
case err := <-berrc:
errc <- err
return
}
}
}()
return done, errc
} | 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.decs, params
} | 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.sels, params
} | 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(openBrace)
// Writing to the bytes.Buffer never returns an error.
ar.writeDecsTo(bf, nil)
for _, sel := range ar.sels {
// Writing to the bytes.Buffer never returns an error.
sel.WriteTo(bf)
}
// 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
} | 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(bf, params)
bf.WriteString(closeBrace)
}
// Write the child selectors.
for _, childSel := range sel.sels {
// Writing to the bytes.Buffer never returns an error.
childSel.writeTo(bf, params)
}
// 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
} | 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 strings.Split(parent.names(), comma) {
for _, s := range strings.Split(sel.name, comma) {
if bf.Len() > 0 {
bf.WriteString(comma)
}
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()
} | 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 with %q [line: %d]", closeBrace, ln.no)
}
return &selector{
elementBase: newElementBase(ln, parent),
name: name,
}, nil
} | 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
}
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
} | 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(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.WriteHeader(http.StatusInternalServerError)
}
} | 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 res
} | 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.Unlock()
return nil
} | 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, false, ErrInvalidRequest()
}
defer func(r *http.Request) {
err := r.Body.Close()
if err != nil {
rerr = ErrInternal()
}
}(r)
if buf.Len() == 0 {
return nil, false, ErrInvalidRequest()
}
f, _, err := buf.ReadRune()
if err != nil {
return nil, false, ErrInvalidRequest()
}
if err := buf.UnreadRune(); err != nil {
return nil, false, ErrInvalidRequest()
}
var rs []*Request
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
} | 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(contentTypeKey, contentTypeValue)
if err := fastjson.NewEncoder(w).Encode(l); err != nil {
w.WriteHeader(http.StatusInternalServerError)
return
}
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.