_id stringlengths 2 7 | title stringlengths 1 118 | partition stringclasses 3
values | text stringlengths 52 85.5k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q15000 | MoveNext | train | func (t *NodeIterator) MoveNext() bool {
n := t.query.Select(t)
if n != nil {
if !t.node.MoveTo(n) {
t.node = n.Copy()
}
return true
}
return false
} | go | {
"resource": ""
} |
q15001 | Select | train | func (expr *Expr) Select(root NodeNavigator) *NodeIterator {
return &NodeIterator{query: expr.q.Clone(), node: root}
} | go | {
"resource": ""
} |
q15002 | Compile | train | func Compile(expr string) (*Expr, error) {
if expr == "" {
return nil, errors.New("expr expression is nil")
}
qy, err := build(expr)
if err != nil {
return nil, err
}
return &Expr{s: expr, q: qy}, nil
} | go | {
"resource": ""
} |
q15003 | MustCompile | train | func MustCompile(expr string) *Expr {
exp, err := Compile(expr)
if err != nil {
return nil
}
return exp
} | go | {
"resource": ""
} |
q15004 | predicate | train | func predicate(q query) func(NodeNavigator) bool {
type Predicater interface {
Test(NodeNavigator) bool
}
if p, ok := q.(Predicater); ok {
return p.Test
}
return func(NodeNavigator) bool { return true }
} | go | {
"resource": ""
} |
q15005 | substringFunc | train | func substringFunc(arg1, arg2, arg3 query) func(query, iterator) interface{} {
return func(q query, t iterator) interface{} {
var m string
switch typ := arg1.Evaluate(t).(type) {
case string:
m = typ
case query:
node := typ.Select(t)
if node == nil {
return ""
}
m = node.Value()
}
var s... | go | {
"resource": ""
} |
q15006 | utpProcessUdp | train | func (s *Socket) utpProcessUdp(b []byte, addr net.Addr) (utp bool) {
if len(b) == 0 {
// The implementation of utp_process_udp rejects null buffers, and
// anything smaller than the UTP header size. It's also prone to
// assert on those, which we don't want to trigger.
return false
}
if missinggo.AddrPort(ad... | go | {
"resource": ""
} |
q15007 | DialContext | train | func (s *Socket) DialContext(ctx context.Context, network, addr string) (net.Conn, error) {
c, err := s.NewConn()
if err != nil {
return nil, err
}
err = c.Connect(ctx, network, addr)
if err != nil {
c.Close()
return nil, err
}
return c, nil
} | go | {
"resource": ""
} |
q15008 | fdget | train | func fdget(fd int, fds *syscall.FdSet) (index, offset int) {
index = fd / (syscall.FD_SETSIZE / len(fds.Bits)) % len(fds.Bits)
offset = fd % (syscall.FD_SETSIZE / len(fds.Bits))
return
} | go | {
"resource": ""
} |
q15009 | fdset | train | func fdset(fd int, fds *syscall.FdSet) {
idx, pos := fdget(fd, fds)
fds.Bits[idx] = 1 << uint(pos)
} | go | {
"resource": ""
} |
q15010 | fdisset | train | func fdisset(fd int, fds *syscall.FdSet) bool {
idx, pos := fdget(fd, fds)
return fds.Bits[idx]&(1<<uint(pos)) != 0
} | go | {
"resource": ""
} |
q15011 | Read | train | func (p *port) Read(b []byte) (n int, err error) {
var done uint32
if err = syscall.ReadFile(p.handle, b, &done, nil); err != nil {
return
}
if done == 0 {
err = ErrTimeout
return
}
n = int(done)
return
} | go | {
"resource": ""
} |
q15012 | syscallSelect | train | func syscallSelect(n int, r *syscall.FdSet, w *syscall.FdSet, e *syscall.FdSet, tv *syscall.Timeval) error {
return syscall.Select(n, r, w, e, tv)
} | go | {
"resource": ""
} |
q15013 | Read | train | func (p *port) Read(b []byte) (n int, err error) {
var rfds syscall.FdSet
fd := p.fd
fdset(fd, &rfds)
var tv *syscall.Timeval
if p.timeout > 0 {
timeout := syscall.NsecToTimeval(p.timeout.Nanoseconds())
tv = &timeout
}
for {
// If syscall.Select() returns EINTR (Interrupted system call), retry it
if er... | go | {
"resource": ""
} |
q15014 | backupTermios | train | func (p *port) backupTermios() {
oldTermios := &syscall.Termios{}
if err := tcgetattr(p.fd, oldTermios); err != nil {
// Warning only.
log.Printf("serial: could not get setting: %v\n", err)
return
}
// Will be reloaded when closing.
p.oldTermios = oldTermios
} | go | {
"resource": ""
} |
q15015 | restoreTermios | train | func (p *port) restoreTermios() {
if p.oldTermios == nil {
return
}
if err := tcsetattr(p.fd, p.oldTermios); err != nil {
// Warning only.
log.Printf("serial: could not restore setting: %v\n", err)
return
}
p.oldTermios = nil
} | go | {
"resource": ""
} |
q15016 | newTermios | train | func newTermios(c *Config) (termios *syscall.Termios, err error) {
termios = &syscall.Termios{}
flag := termios.Cflag
// Baud rate
if c.BaudRate == 0 {
// 19200 is the required default.
flag = syscall.B19200
} else {
var ok bool
flag, ok = baudRates[c.BaudRate]
if !ok {
err = fmt.Errorf("serial: unsup... | go | {
"resource": ""
} |
q15017 | enableRS485 | train | func enableRS485(fd int, config *RS485Config) error {
if !config.Enabled {
return nil
}
rs485 := rs485_ioctl_opts{
rs485Enabled,
uint32(config.DelayRtsBeforeSend / time.Millisecond),
uint32(config.DelayRtsAfterSend / time.Millisecond),
[5]uint32{0, 0, 0, 0, 0},
}
if config.RtsHighDuringSend {
rs485.fl... | go | {
"resource": ""
} |
q15018 | Open | train | func Open(c *Config) (p Port, err error) {
p = New()
err = p.Open(c)
return
} | go | {
"resource": ""
} |
q15019 | NewServer | train | func NewServer(readHandler func(filename string, rf io.ReaderFrom) error,
writeHandler func(filename string, wt io.WriterTo) error) *Server {
s := &Server{
timeout: defaultTimeout,
retries: defaultRetries,
runGC: make(chan []string),
gcInterval: 1 * time.Minute,
packet... | go | {
"resource": ""
} |
q15020 | SetAnticipate | train | func (s *Server) SetAnticipate(winsz uint) {
if winsz > 1 {
s.sendAEnable = true
s.sendAWinSz = winsz
} else {
s.sendAEnable = false
s.sendAWinSz = 1
}
} | go | {
"resource": ""
} |
q15021 | EnableSinglePort | train | func (s *Server) EnableSinglePort() {
s.singlePort = true
s.handlers = make(map[string]chan []byte, datagramLength)
s.gcCollect = make(chan string)
s.bufPool = sync.Pool{
New: func() interface{} {
return make([]byte, datagramLength)
},
}
go s.internalGC()
} | go | {
"resource": ""
} |
q15022 | SetTimeout | train | func (s *Server) SetTimeout(t time.Duration) {
if t <= 0 {
s.timeout = defaultTimeout
} else {
s.timeout = t
}
} | go | {
"resource": ""
} |
q15023 | SetRetries | train | func (s *Server) SetRetries(count int) {
if count < 1 {
s.retries = defaultRetries
} else {
s.retries = count
}
} | go | {
"resource": ""
} |
q15024 | ListenAndServe | train | func (s *Server) ListenAndServe(addr string) error {
a, err := net.ResolveUDPAddr("udp", addr)
if err != nil {
return err
}
conn, err := net.ListenUDP("udp", a)
if err != nil {
return err
}
return s.Serve(conn)
} | go | {
"resource": ""
} |
q15025 | Serve | train | func (s *Server) Serve(conn *net.UDPConn) error {
defer conn.Close()
laddr := conn.LocalAddr()
host, _, err := net.SplitHostPort(laddr.String())
if err != nil {
return err
}
s.conn = conn
// Having seperate control paths for IP4 and IP6 is annoying,
// but necessary at this point.
addr := net.ParseIP(host)
... | go | {
"resource": ""
} |
q15026 | Shutdown | train | func (s *Server) Shutdown() {
s.conn.Close()
q := make(chan struct{})
s.quit <- q
<-q
s.wg.Wait()
} | go | {
"resource": ""
} |
q15027 | internalGC | train | func (s *Server) internalGC() {
var completedHandlers []string
for {
select {
case newHandler := <-s.gcCollect:
completedHandlers = append(completedHandlers, newHandler)
case <-time.After(s.gcInterval):
s.runGC <- completedHandlers
completedHandlers = nil
}
}
} | go | {
"resource": ""
} |
q15028 | packRQ | train | func packRQ(p []byte, op uint16, filename, mode string, opts options) int {
binary.BigEndian.PutUint16(p, op)
n := 2
n += copy(p[2:len(p)-10], filename)
p[n] = 0
n++
n += copy(p[n:], mode)
p[n] = 0
n++
for name, value := range opts {
n += copy(p[n:], name)
p[n] = 0
n++
n += copy(p[n:], value)
p[n] = ... | go | {
"resource": ""
} |
q15029 | NewClient | train | func NewClient(addr string) (*Client, error) {
a, err := net.ResolveUDPAddr("udp", addr)
if err != nil {
return nil, fmt.Errorf("resolving address %s: %v", addr, err)
}
return &Client{
addr: a,
timeout: defaultTimeout,
retries: defaultRetries,
}, nil
} | go | {
"resource": ""
} |
q15030 | SetTimeout | train | func (c *Client) SetTimeout(t time.Duration) {
if t <= 0 {
c.timeout = defaultTimeout
}
c.timeout = t
} | go | {
"resource": ""
} |
q15031 | SetRetries | train | func (c *Client) SetRetries(count int) {
if count < 1 {
c.retries = defaultRetries
}
c.retries = count
} | go | {
"resource": ""
} |
q15032 | Send | train | func (c Client) Send(filename string, mode string) (io.ReaderFrom, error) {
conn, err := net.ListenUDP("udp", &net.UDPAddr{})
if err != nil {
return nil, err
}
s := &sender{
send: make([]byte, datagramLength),
receive: make([]byte, datagramLength),
conn: &connConnection{conn: conn},
retry: &backof... | go | {
"resource": ""
} |
q15033 | Receive | train | func (c Client) Receive(filename string, mode string) (io.WriterTo, error) {
conn, err := net.ListenUDP("udp", &net.UDPAddr{})
if err != nil {
return nil, err
}
if c.timeout == 0 {
c.timeout = defaultTimeout
}
r := &receiver{
send: make([]byte, datagramLength),
receive: make([]byte, datagramLength),
... | go | {
"resource": ""
} |
q15034 | AvailableBackends | train | func AvailableBackends() []BackendType {
b := []BackendType{}
for k := range supportedBackends {
if k != FileBackend {
b = append(b, k)
}
}
// make sure FileBackend is last
return append(b, FileBackend)
} | go | {
"resource": ""
} |
q15035 | Open | train | func Open(cfg Config) (Keyring, error) {
if cfg.AllowedBackends == nil {
cfg.AllowedBackends = AvailableBackends()
}
debugf("Considering backends: %v", cfg.AllowedBackends)
for _, backend := range cfg.AllowedBackends {
if opener, ok := supportedBackends[backend]; ok {
openBackend, err := opener(cfg)
if er... | go | {
"resource": ""
} |
q15036 | NewArrayKeyring | train | func NewArrayKeyring(initial []Item) *ArrayKeyring {
kr := &ArrayKeyring{}
for _, i := range initial {
_ = kr.Set(i)
}
return kr
} | go | {
"resource": ""
} |
q15037 | Get | train | func (k *ArrayKeyring) Get(key string) (Item, error) {
if i, ok := k.items[key]; ok {
return i, nil
}
return Item{}, ErrKeyNotFound
} | go | {
"resource": ""
} |
q15038 | Set | train | func (k *ArrayKeyring) Set(i Item) error {
if k.items == nil {
k.items = map[string]Item{}
}
k.items[i.Key] = i
return nil
} | go | {
"resource": ""
} |
q15039 | Remove | train | func (k *ArrayKeyring) Remove(key string) error {
delete(k.items, key)
return nil
} | go | {
"resource": ""
} |
q15040 | Keys | train | func (k *ArrayKeyring) Keys() ([]string, error) {
var keys = []string{}
for key := range k.items {
keys = append(keys, key)
}
return keys, nil
} | go | {
"resource": ""
} |
q15041 | WithHTTPClient | train | func WithHTTPClient(client *http.Client) ClientOption {
return func(metaclient *Client) { metaclient.client = client }
} | go | {
"resource": ""
} |
q15042 | WithBaseURL | train | func WithBaseURL(base *url.URL) ClientOption {
return func(metaclient *Client) { metaclient.baseURL = base }
} | go | {
"resource": ""
} |
q15043 | NewClient | train | func NewClient(opts ...ClientOption) *Client {
client := &Client{
client: &http.Client{Timeout: defaultTimeout},
baseURL: defaultBaseURL,
}
for _, opt := range opts {
opt(client)
}
return client
} | go | {
"resource": ""
} |
q15044 | Metadata | train | func (c *Client) Metadata() (*Metadata, error) {
metadata := new(Metadata)
err := c.doGetURL(c.resolve("/metadata/v1.json"), func(r io.Reader) error {
return json.NewDecoder(r).Decode(metadata)
})
return metadata, err
} | go | {
"resource": ""
} |
q15045 | DropletID | train | func (c *Client) DropletID() (int, error) {
dropletID := new(int)
err := c.doGet("id", func(r io.Reader) error {
_, err := fmt.Fscanf(r, "%d", dropletID)
return err
})
return *dropletID, err
} | go | {
"resource": ""
} |
q15046 | Hostname | train | func (c *Client) Hostname() (string, error) {
var hostname string
err := c.doGet("hostname", func(r io.Reader) error {
hostnameraw, err := ioutil.ReadAll(r)
hostname = string(hostnameraw)
return err
})
return hostname, err
} | go | {
"resource": ""
} |
q15047 | UserData | train | func (c *Client) UserData() (string, error) {
var userdata string
err := c.doGet("user-data", func(r io.Reader) error {
userdataraw, err := ioutil.ReadAll(r)
userdata = string(userdataraw)
return err
})
return userdata, err
} | go | {
"resource": ""
} |
q15048 | VendorData | train | func (c *Client) VendorData() (string, error) {
var vendordata string
err := c.doGet("vendor-data", func(r io.Reader) error {
vendordataraw, err := ioutil.ReadAll(r)
vendordata = string(vendordataraw)
return err
})
return vendordata, err
} | go | {
"resource": ""
} |
q15049 | Region | train | func (c *Client) Region() (string, error) {
var region string
err := c.doGet("region", func(r io.Reader) error {
regionraw, err := ioutil.ReadAll(r)
region = string(regionraw)
return err
})
return region, err
} | go | {
"resource": ""
} |
q15050 | AuthToken | train | func (c *Client) AuthToken() (string, error) {
var authToken string
err := c.doGet("auth-token", func(r io.Reader) error {
authTokenraw, err := ioutil.ReadAll(r)
authToken = string(authTokenraw)
return err
})
return authToken, err
} | go | {
"resource": ""
} |
q15051 | FloatingIPv4Active | train | func (c *Client) FloatingIPv4Active() (bool, error) {
var active bool
err := c.doGet("floating_ip/ipv4/active", func(r io.Reader) error {
activeraw, err := ioutil.ReadAll(r)
if string(activeraw) == "true" {
active = true
}
return err
})
return active, err
} | go | {
"resource": ""
} |
q15052 | Save | train | func Save(path string, v interface{}) error {
lock.Lock()
defer lock.Unlock()
f, err := os.Create(path)
if err != nil {
return err
}
defer f.Close()
r, err := Marshal(v)
if err != nil {
return err
}
_, err = io.Copy(f, r)
return err
} | go | {
"resource": ""
} |
q15053 | Read | train | func (this *Reader) Read(p []byte) (n int, err error) {
// checks for when we have no data
for this.writePos == 0 || this.readPos == this.writePos {
// if we have an error / EOF, just return it
if this.err != nil {
return n, this.err
}
// else, fill our buffer
this.fillBuffer()
}
// TODO: checks for ... | go | {
"resource": ""
} |
q15054 | NewConverter | train | func NewConverter(fromEncoding string, toEncoding string) (converter *Converter, err error) {
converter = new(Converter)
// convert to C strings
toEncodingC := C.CString(toEncoding)
fromEncodingC := C.CString(fromEncoding)
// open an iconv descriptor
converter.context, err = C.iconv_open(toEncodingC, fromEncodi... | go | {
"resource": ""
} |
q15055 | Close | train | func (this *Converter) Close() (err error) {
if this.open {
_, err = C.iconv_close(this.context)
}
return
} | go | {
"resource": ""
} |
q15056 | Convert | train | func (this *Converter) Convert(input []byte, output []byte) (bytesRead int, bytesWritten int, err error) {
// make sure we are still open
if this.open {
inputLeft := C.size_t(len(input))
outputLeft := C.size_t(len(output))
if inputLeft > 0 && outputLeft > 0 {
// we have to give iconv a pointer to a pointer ... | go | {
"resource": ""
} |
q15057 | ConvertString | train | func (this *Converter) ConvertString(input string) (output string, err error) {
// make sure we are still open
if this.open {
// construct the buffers
inputBuffer := []byte(input)
outputBuffer := make([]byte, len(inputBuffer)*2) // we use a larger buffer to help avoid resizing later
// call Convert until all... | go | {
"resource": ""
} |
q15058 | Convert | train | func Convert(input []byte, output []byte, fromEncoding string, toEncoding string) (bytesRead int, bytesWritten int, err error) {
// create a temporary converter
converter, err := NewConverter(fromEncoding, toEncoding)
if err == nil {
// call converter's Convert
bytesRead, bytesWritten, err = converter.Convert(i... | go | {
"resource": ""
} |
q15059 | ConvertString | train | func ConvertString(input string, fromEncoding string, toEncoding string) (output string, err error) {
// create a temporary converter
converter, err := NewConverter(fromEncoding, toEncoding)
if err == nil {
// convert the string
output, err = converter.ConvertString(input)
// close the converter
converter.... | go | {
"resource": ""
} |
q15060 | Write | train | func (this *Writer) Write(p []byte) (n int, err error) {
// write data into our internal buffer
bytesRead, bytesWritten, err := this.converter.Convert(p, this.buffer[this.writePos:])
// update bytes written for return
n += bytesRead
this.writePos += bytesWritten
// checks for when we have a full buffer
for thi... | go | {
"resource": ""
} |
q15061 | Transform | train | func Transform(scheme ColourScheme, data ViewRegionMap, viewport text.Region) Recipe {
pe := util.Prof.Enter("render.Transform")
defer pe.Exit()
data.Cull(viewport)
recipe := make(Recipe)
for _, v := range data {
k := scheme.Spice(&v)
rs := recipe[k]
a := util.Prof.Enter("render.Transform.(Regions)")
r :=... | go | {
"resource": ""
} |
q15062 | Transcribe | train | func (r Recipe) Transcribe() (ret TranscribedRecipe) {
pe := util.Prof.Enter("render.Transcribe")
defer pe.Exit()
for flav, set := range r {
for _, r := range set.Regions() {
ret = append(ret, RenderUnit{Flavour: flav, Region: r})
}
}
sort.Sort(&ret)
return
} | go | {
"resource": ""
} |
q15063 | String | train | func (e *Edit) String() string {
return fmt.Sprintf("%s: %v, %v, %v", e.command, e.args, e.bypassUndo, e.composite)
} | go | {
"resource": ""
} |
q15064 | Undo | train | func (e *Edit) Undo() {
e.composite.Undo()
e.v.Sel().Clear()
for _, r := range e.savedSel.Regions() {
e.v.Sel().Add(r)
}
} | go | {
"resource": ""
} |
q15065 | Less | train | func (k *KeyBindings) Less(i, j int) bool {
return k.Bindings[i].Keys[k.seqIndex].Index() < k.Bindings[j].Keys[k.seqIndex].Index()
} | go | {
"resource": ""
} |
q15066 | Swap | train | func (k *KeyBindings) Swap(i, j int) {
k.Bindings[i], k.Bindings[j] = k.Bindings[j], k.Bindings[i]
} | go | {
"resource": ""
} |
q15067 | DropLessEqualKeys | train | func (k *KeyBindings) DropLessEqualKeys(count int) {
for {
for i := 0; i < len(k.Bindings); {
if len(k.Bindings[i].Keys) <= count {
k.Bindings[i] = k.Bindings[len(k.Bindings)-1]
k.Bindings = k.Bindings[:len(k.Bindings)-1]
} else {
i++
}
}
sort.Sort(k)
if k.parent == nil {
break
}
k ... | go | {
"resource": ""
} |
q15068 | Filter | train | func (k *KeyBindings) Filter(kp KeyPress) (ret KeyBindings) {
p := Prof.Enter("key.filter")
defer p.Exit()
kp.fix()
k.DropLessEqualKeys(k.seqIndex)
ret.seqIndex = k.seqIndex + 1
ki := kp.Index()
k.filter(ki, &ret)
if kp.IsCharacter() {
k.filter(int(Any), &ret)
}
return
} | go | {
"resource": ""
} |
q15069 | Action | train | func (k *KeyBindings) Action(qc func(key string, operator Op, operand interface{}, match_all bool) bool) (kb *KeyBinding) {
p := Prof.Enter("key.action")
defer p.Exit()
for {
for i := range k.Bindings {
if len(k.Bindings[i].Keys) > k.seqIndex {
// This key binding is of a key sequence longer than what is c... | go | {
"resource": ""
} |
q15070 | IsCharacter | train | func (k KeyPress) IsCharacter() bool {
return unicode.IsPrint(rune(k.Key)) && !k.Super && !k.Ctrl
} | go | {
"resource": ""
} |
q15071 | fix | train | func (k *KeyPress) fix() {
lower := Key(unicode.ToLower(rune(k.Key)))
if lower != k.Key {
k.Shift = true
k.Key = lower
}
} | go | {
"resource": ""
} |
q15072 | LoadJSON | train | func LoadJSON(path string, marshal json.Unmarshaler) error {
j := NewJSON(path, marshal)
watch(j)
j.Load()
return j.err
} | go | {
"resource": ""
} |
q15073 | reparse | train | func (v *View) reparse(forced bool) {
if v.isClosed() {
// No point in issuing a re-parse if the view has been closed
return
}
if len(v.reparseChan) < cap(v.reparseChan) || forced {
v.reparseChan <- parseReq{forced}
}
} | go | {
"resource": ""
} |
q15074 | Erase | train | func (v *View) Erase(edit *Edit, r text.Region) {
edit.composite.AddExec(text.NewEraseAction(v.buffer, r))
} | go | {
"resource": ""
} |
q15075 | Replace | train | func (v *View) Replace(edit *Edit, r text.Region, value string) {
edit.composite.AddExec(text.NewReplaceAction(v.buffer, r, value))
} | go | {
"resource": ""
} |
q15076 | EndEdit | train | func (v *View) EndEdit(edit *Edit) {
if edit.invalid {
// This happens when nesting Edits and the child Edit ends after the parent edit.
log.Fine("This edit has already been invalidated: %v, %v", edit, v.editstack)
return
}
// Find the position of this Edit object in this View's Edit stack.
// If plugins, co... | go | {
"resource": ""
} |
q15077 | IsDirty | train | func (v *View) IsDirty() bool {
if v.IsScratch() {
return false
}
lastSave := v.Settings().Int("lime.last_save_change_count", -1)
return v.ChangeCount() != lastSave
} | go | {
"resource": ""
} |
q15078 | SaveAs | train | func (v *View) SaveAs(name string) (err error) {
log.Fine("SaveAs(%s)", name)
v.Settings().Set("lime.saving", true)
defer v.Settings().Erase("lime.saving")
OnPreSave.Call(v)
if atomic := v.Settings().Bool("atomic_save", true); v.FileName() == "" || !atomic {
if err := v.nonAtomicSave(name); err != nil {
retur... | go | {
"resource": ""
} |
q15079 | AddRegions | train | func (v *View) AddRegions(key string, regions []text.Region, scope, icon string, flags render.ViewRegionFlags) {
vr := render.ViewRegions{Scope: scope, Icon: icon, Flags: flags}
vr.Regions.AddAll(regions)
v.lock.Lock()
defer v.lock.Unlock()
v.regions[key] = vr
} | go | {
"resource": ""
} |
q15080 | GetRegions | train | func (v *View) GetRegions(key string) (ret []text.Region) {
v.lock.Lock()
defer v.lock.Unlock()
vr := v.regions[key]
rs := vr.Regions.Regions()
ret = make([]text.Region, len(rs))
copy(ret, rs)
return
} | go | {
"resource": ""
} |
q15081 | EraseRegions | train | func (v *View) EraseRegions(key string) {
v.lock.Lock()
defer v.lock.Unlock()
delete(v.regions, key)
} | go | {
"resource": ""
} |
q15082 | Close | train | func (v *View) Close() bool {
OnPreClose.Call(v)
if v.IsDirty() {
close_anyway := GetEditor().Frontend().OkCancelDialog("File has been modified since last save, close anyway?", "Close")
if !close_anyway {
return false
}
}
if n := v.FileName(); n != "" {
GetEditor().UnWatch(n, v)
}
// Call the event fi... | go | {
"resource": ""
} |
q15083 | FindByClass | train | func (v *View) FindByClass(point int, forward bool, classes int) int {
i := -1
if forward {
i = 1
}
size := v.Size()
// Sublime doesn't consider initial point even if it matches.
for p := point + i; ; p += i {
if p <= 0 {
return 0
}
if p >= size {
return size
}
if v.Classify(p)&classes != 0 {
... | go | {
"resource": ""
} |
q15084 | ExpandByClass | train | func (v *View) ExpandByClass(r text.Region, classes int) text.Region {
// Sublime doesn't consider the points the region starts on.
// If not already on edge of buffer, expand by 1 in both directions.
a := r.A
if a > 0 {
a -= 1
} else if a < 0 {
a = 0
}
b := r.B
size := v.Size()
if b < size {
b += 1
} ... | go | {
"resource": ""
} |
q15085 | init | train | func (ch *commandHandler) init(cmd interface{}, args Args) error {
if in, ok := cmd.(CustomInit); ok {
return in.Init(args)
}
v := reflect.ValueOf(cmd).Elem()
t := v.Type()
for i := 0; i < v.NumField(); i++ {
ft := t.Field(i)
f := v.Field(i)
if ft.Anonymous || !f.CanSet() {
continue
}
key := util.Pa... | go | {
"resource": ""
} |
q15086 | Close | train | func (w *Window) Close() bool {
if !w.CloseAllViews() {
return false
}
GetEditor().remove(w)
return true
} | go | {
"resource": ""
} |
q15087 | CloseAllViews | train | func (w *Window) CloseAllViews() bool {
for len(w.views) > 0 {
if !w.views[0].Close() {
return false
}
}
return true
} | go | {
"resource": ""
} |
q15088 | SaveAs | train | func (p *Project) SaveAs(name string) error {
log.Fine("Saving project as %s", name)
if data, err := json.Marshal(p); err != nil {
return err
} else if err := ioutil.WriteFile(name, data, 0644); err != nil {
return err
}
if abs, err := filepath.Abs(name); err != nil {
p.SetName(name)
} else {
p.SetName(ab... | go | {
"resource": ""
} |
q15089 | call | train | func (ie *InitEvent) call() {
log.Debug("OnInit callbacks executing")
defer log.Debug("OnInit callbacks finished")
for _, ev := range *ie {
ev()
}
} | go | {
"resource": ""
} |
q15090 | flushDir | train | func (w *Watcher) flushDir(name string) {
log.Finest("Flusing watched directory %s", name)
w.dirs = append(w.dirs, name)
for _, p := range w.watchers {
if filepath.Dir(p) == name && !util.Exists(w.dirs, p) {
if err := w.removeWatch(p); err != nil {
log.Error("Couldn't unwatch file %s: %s", p, err)
}
}
... | go | {
"resource": ""
} |
q15091 | removeDir | train | func (w *Watcher) removeDir(name string) {
for p, _ := range w.watched {
if filepath.Dir(p) == name {
stat, err := os.Stat(p)
if err != nil {
log.Error("Stat error: %s", err)
}
if err := w.watch(p, stat.IsDir()); err != nil {
log.Error("Could not watch: %s", err)
continue
}
}
}
w.dirs ... | go | {
"resource": ""
} |
q15092 | observe | train | func (w *Watcher) observe() {
for {
select {
case ev, ok := <-w.fsEvent:
if !ok {
// We get here only when w.fsEvent is stopped when closing the watcher
w.watched = nil
w.watchers = nil
w.dirs = nil
close(w.fsEvent)
w.fsEvent = nil
return
}
w.parseEv(ev)
}
}
} | go | {
"resource": ""
} |
q15093 | Redo | train | func (us *UndoStack) Redo(hard bool) {
if us.position >= len(us.actions) {
// No more actions to redo
return
}
to := us.index(1, hard)
if to == -1 {
to = len(us.actions)
}
for us.position < to {
us.actions[us.position].Apply()
us.position++
}
} | go | {
"resource": ""
} |
q15094 | GlueFrom | train | func (us *UndoStack) GlueFrom(mark int) {
if mark >= us.position {
return
}
var e Edit
e.command = "sequence"
type entry struct {
name string
args Args
}
e.v = us.actions[mark].v
e.savedSel.AddAll(us.actions[mark].savedSel.Regions())
entries := make([]entry, us.position-mark)
for i := range entries {
... | go | {
"resource": ""
} |
q15095 | watch | train | func watch(pkg Package) {
if err := watcher.Watch(pkg.Path(), pkg); err != nil {
log.Warn("Couldn't watch %s: %s", pkg.Path(), err)
}
} | go | {
"resource": ""
} |
q15096 | watchDir | train | func watchDir(dir string) {
log.Finest("Watching scaned dir: %s", dir)
sd := &scanDir{dir}
if err := watcher.Watch(sd.path, sd); err != nil {
log.Error("Couldn't watch %s: %s", sd.path, err)
}
} | go | {
"resource": ""
} |
q15097 | Cull | train | func (vrm *ViewRegionMap) Cull(viewport text.Region) {
pe := util.Prof.Enter("render.vrm.Cull")
defer pe.Exit()
rm := []string{}
for k, v := range *vrm {
v.Cull(viewport)
if v.Regions.Len() == 0 {
rm = append(rm, k)
} else {
(*vrm)[k] = v
}
}
for _, r := range rm {
delete(*vrm, r)
}
} | go | {
"resource": ""
} |
q15098 | Cull | train | func (vr *ViewRegions) Cull(viewport text.Region) {
pe := util.Prof.Enter("render.vr.Cull")
defer pe.Exit()
nr := []text.Region{}
for _, r := range vr.Regions.Regions() {
if viewport.Intersects(r) {
in := viewport.Intersection(r)
if in.Size() != 0 {
nr = append(nr, in)
}
}
}
vr.Regions.Clear()
v... | go | {
"resource": ""
} |
q15099 | Clone | train | func (vr *ViewRegions) Clone() *ViewRegions {
ret := ViewRegions{Scope: vr.Scope, Icon: vr.Icon, Flags: vr.Flags}
ret.Regions.AddAll(vr.Regions.Regions())
return &ret
} | go | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.