id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens listlengths 21 1.41k | docstring stringlengths 6 2.61k | docstring_tokens listlengths 3 215 | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
15,000 | antchfx/xpath | xpath.go | MoveNext | 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 | 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
} | [
"func",
"(",
"t",
"*",
"NodeIterator",
")",
"MoveNext",
"(",
")",
"bool",
"{",
"n",
":=",
"t",
".",
"query",
".",
"Select",
"(",
"t",
")",
"\n",
"if",
"n",
"!=",
"nil",
"{",
"if",
"!",
"t",
".",
"node",
".",
"MoveTo",
"(",
"n",
")",
"{",
"t... | // MoveNext moves Navigator to the next match node. | [
"MoveNext",
"moves",
"Navigator",
"to",
"the",
"next",
"match",
"node",
"."
] | ce1d48779e67a1ddfb380995fe532b2e0015919c | https://github.com/antchfx/xpath/blob/ce1d48779e67a1ddfb380995fe532b2e0015919c/xpath.go#L84-L93 |
15,001 | antchfx/xpath | xpath.go | Select | func (expr *Expr) Select(root NodeNavigator) *NodeIterator {
return &NodeIterator{query: expr.q.Clone(), node: root}
} | go | func (expr *Expr) Select(root NodeNavigator) *NodeIterator {
return &NodeIterator{query: expr.q.Clone(), node: root}
} | [
"func",
"(",
"expr",
"*",
"Expr",
")",
"Select",
"(",
"root",
"NodeNavigator",
")",
"*",
"NodeIterator",
"{",
"return",
"&",
"NodeIterator",
"{",
"query",
":",
"expr",
".",
"q",
".",
"Clone",
"(",
")",
",",
"node",
":",
"root",
"}",
"\n",
"}"
] | // Select selects a node set using the specified XPath expression. | [
"Select",
"selects",
"a",
"node",
"set",
"using",
"the",
"specified",
"XPath",
"expression",
"."
] | ce1d48779e67a1ddfb380995fe532b2e0015919c | https://github.com/antchfx/xpath/blob/ce1d48779e67a1ddfb380995fe532b2e0015919c/xpath.go#L129-L131 |
15,002 | antchfx/xpath | xpath.go | Compile | 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 | 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
} | [
"func",
"Compile",
"(",
"expr",
"string",
")",
"(",
"*",
"Expr",
",",
"error",
")",
"{",
"if",
"expr",
"==",
"\"",
"\"",
"{",
"return",
"nil",
",",
"errors",
".",
"New",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"qy",
",",
"err",
":=",
"build",
... | // Compile compiles an XPath expression string. | [
"Compile",
"compiles",
"an",
"XPath",
"expression",
"string",
"."
] | ce1d48779e67a1ddfb380995fe532b2e0015919c | https://github.com/antchfx/xpath/blob/ce1d48779e67a1ddfb380995fe532b2e0015919c/xpath.go#L139-L148 |
15,003 | antchfx/xpath | xpath.go | MustCompile | func MustCompile(expr string) *Expr {
exp, err := Compile(expr)
if err != nil {
return nil
}
return exp
} | go | func MustCompile(expr string) *Expr {
exp, err := Compile(expr)
if err != nil {
return nil
}
return exp
} | [
"func",
"MustCompile",
"(",
"expr",
"string",
")",
"*",
"Expr",
"{",
"exp",
",",
"err",
":=",
"Compile",
"(",
"expr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"exp",
"\n",
"}"
] | // MustCompile compiles an XPath expression string and ignored error. | [
"MustCompile",
"compiles",
"an",
"XPath",
"expression",
"string",
"and",
"ignored",
"error",
"."
] | ce1d48779e67a1ddfb380995fe532b2e0015919c | https://github.com/antchfx/xpath/blob/ce1d48779e67a1ddfb380995fe532b2e0015919c/xpath.go#L151-L157 |
15,004 | antchfx/xpath | func.go | predicate | 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 | 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 }
} | [
"func",
"predicate",
"(",
"q",
"query",
")",
"func",
"(",
"NodeNavigator",
")",
"bool",
"{",
"type",
"Predicater",
"interface",
"{",
"Test",
"(",
"NodeNavigator",
")",
"bool",
"\n",
"}",
"\n",
"if",
"p",
",",
"ok",
":=",
"q",
".",
"(",
"Predicater",
... | // The XPath function list. | [
"The",
"XPath",
"function",
"list",
"."
] | ce1d48779e67a1ddfb380995fe532b2e0015919c | https://github.com/antchfx/xpath/blob/ce1d48779e67a1ddfb380995fe532b2e0015919c/func.go#L14-L22 |
15,005 | antchfx/xpath | func.go | substringFunc | 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 start, length float64
var ok bool
if start, ok = arg2.Evaluate(t).(float64); !ok {
panic(errors.New("substring() function first argument type must be int"))
} else if start < 1 {
panic(errors.New("substring() function first argument type must be >= 1"))
}
start--
if arg3 != nil {
if length, ok = arg3.Evaluate(t).(float64); !ok {
panic(errors.New("substring() function second argument type must be int"))
}
}
if (len(m) - int(start)) < int(length) {
panic(errors.New("substring() function start and length argument out of range"))
}
if length > 0 {
return m[int(start):int(length+start)]
}
return m[int(start):]
}
} | go | 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 start, length float64
var ok bool
if start, ok = arg2.Evaluate(t).(float64); !ok {
panic(errors.New("substring() function first argument type must be int"))
} else if start < 1 {
panic(errors.New("substring() function first argument type must be >= 1"))
}
start--
if arg3 != nil {
if length, ok = arg3.Evaluate(t).(float64); !ok {
panic(errors.New("substring() function second argument type must be int"))
}
}
if (len(m) - int(start)) < int(length) {
panic(errors.New("substring() function start and length argument out of range"))
}
if length > 0 {
return m[int(start):int(length+start)]
}
return m[int(start):]
}
} | [
"func",
"substringFunc",
"(",
"arg1",
",",
"arg2",
",",
"arg3",
"query",
")",
"func",
"(",
"query",
",",
"iterator",
")",
"interface",
"{",
"}",
"{",
"return",
"func",
"(",
"q",
"query",
",",
"t",
"iterator",
")",
"interface",
"{",
"}",
"{",
"var",
... | // substringFunc is XPath functions substring function returns a part of a given string. | [
"substringFunc",
"is",
"XPath",
"functions",
"substring",
"function",
"returns",
"a",
"part",
"of",
"a",
"given",
"string",
"."
] | ce1d48779e67a1ddfb380995fe532b2e0015919c | https://github.com/antchfx/xpath/blob/ce1d48779e67a1ddfb380995fe532b2e0015919c/func.go#L337-L373 |
15,006 | anacrolix/go-libutp | socket.go | utpProcessUdp | 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(addr) == 0 {
return false
}
mu.Unlock()
block := func() bool {
if s.firewallCallback == nil {
return false
}
return s.firewallCallback(addr)
}()
mu.Lock()
s.block = block
if s.closed {
return false
}
var sal C.socklen_t
staticRsa, sal = netAddrToLibSockaddr(addr)
ret := C.utp_process_udp(s.ctx, (*C.byte)(&b[0]), C.size_t(len(b)), (*C.struct_sockaddr)(unsafe.Pointer(&staticRsa)), sal)
switch ret {
case 1:
return true
case 0:
return false
default:
panic(ret)
}
} | go | 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(addr) == 0 {
return false
}
mu.Unlock()
block := func() bool {
if s.firewallCallback == nil {
return false
}
return s.firewallCallback(addr)
}()
mu.Lock()
s.block = block
if s.closed {
return false
}
var sal C.socklen_t
staticRsa, sal = netAddrToLibSockaddr(addr)
ret := C.utp_process_udp(s.ctx, (*C.byte)(&b[0]), C.size_t(len(b)), (*C.struct_sockaddr)(unsafe.Pointer(&staticRsa)), sal)
switch ret {
case 1:
return true
case 0:
return false
default:
panic(ret)
}
} | [
"func",
"(",
"s",
"*",
"Socket",
")",
"utpProcessUdp",
"(",
"b",
"[",
"]",
"byte",
",",
"addr",
"net",
".",
"Addr",
")",
"(",
"utp",
"bool",
")",
"{",
"if",
"len",
"(",
"b",
")",
"==",
"0",
"{",
"// The implementation of utp_process_udp rejects null buff... | // Wraps libutp's utp_process_udp, returning relevant information. | [
"Wraps",
"libutp",
"s",
"utp_process_udp",
"returning",
"relevant",
"information",
"."
] | d7dd83bce17eb552d89dc42b7acdb8498e7e70db | https://github.com/anacrolix/go-libutp/blob/d7dd83bce17eb552d89dc42b7acdb8498e7e70db/socket.go#L285-L318 |
15,007 | anacrolix/go-libutp | socket.go | DialContext | 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 | 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
} | [
"func",
"(",
"s",
"*",
"Socket",
")",
"DialContext",
"(",
"ctx",
"context",
".",
"Context",
",",
"network",
",",
"addr",
"string",
")",
"(",
"net",
".",
"Conn",
",",
"error",
")",
"{",
"c",
",",
"err",
":=",
"s",
".",
"NewConn",
"(",
")",
"\n",
... | // Passing an empty network will use the network of the Socket's listener. | [
"Passing",
"an",
"empty",
"network",
"will",
"use",
"the",
"network",
"of",
"the",
"Socket",
"s",
"listener",
"."
] | d7dd83bce17eb552d89dc42b7acdb8498e7e70db | https://github.com/anacrolix/go-libutp/blob/d7dd83bce17eb552d89dc42b7acdb8498e7e70db/socket.go#L405-L416 |
15,008 | goburrow/serial | serial_linux.go | fdget | 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 | 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
} | [
"func",
"fdget",
"(",
"fd",
"int",
",",
"fds",
"*",
"syscall",
".",
"FdSet",
")",
"(",
"index",
",",
"offset",
"int",
")",
"{",
"index",
"=",
"fd",
"/",
"(",
"syscall",
".",
"FD_SETSIZE",
"/",
"len",
"(",
"fds",
".",
"Bits",
")",
")",
"%",
"len... | // fdget returns index and offset of fd in fds. | [
"fdget",
"returns",
"index",
"and",
"offset",
"of",
"fd",
"in",
"fds",
"."
] | 5efbe925ecf714f8ba147bf2226f2e7afc7111bc | https://github.com/goburrow/serial/blob/5efbe925ecf714f8ba147bf2226f2e7afc7111bc/serial_linux.go#L87-L91 |
15,009 | goburrow/serial | serial_linux.go | fdset | func fdset(fd int, fds *syscall.FdSet) {
idx, pos := fdget(fd, fds)
fds.Bits[idx] = 1 << uint(pos)
} | go | func fdset(fd int, fds *syscall.FdSet) {
idx, pos := fdget(fd, fds)
fds.Bits[idx] = 1 << uint(pos)
} | [
"func",
"fdset",
"(",
"fd",
"int",
",",
"fds",
"*",
"syscall",
".",
"FdSet",
")",
"{",
"idx",
",",
"pos",
":=",
"fdget",
"(",
"fd",
",",
"fds",
")",
"\n",
"fds",
".",
"Bits",
"[",
"idx",
"]",
"=",
"1",
"<<",
"uint",
"(",
"pos",
")",
"\n",
"... | // fdset implements FD_SET macro. | [
"fdset",
"implements",
"FD_SET",
"macro",
"."
] | 5efbe925ecf714f8ba147bf2226f2e7afc7111bc | https://github.com/goburrow/serial/blob/5efbe925ecf714f8ba147bf2226f2e7afc7111bc/serial_linux.go#L94-L97 |
15,010 | goburrow/serial | serial_linux.go | fdisset | func fdisset(fd int, fds *syscall.FdSet) bool {
idx, pos := fdget(fd, fds)
return fds.Bits[idx]&(1<<uint(pos)) != 0
} | go | func fdisset(fd int, fds *syscall.FdSet) bool {
idx, pos := fdget(fd, fds)
return fds.Bits[idx]&(1<<uint(pos)) != 0
} | [
"func",
"fdisset",
"(",
"fd",
"int",
",",
"fds",
"*",
"syscall",
".",
"FdSet",
")",
"bool",
"{",
"idx",
",",
"pos",
":=",
"fdget",
"(",
"fd",
",",
"fds",
")",
"\n",
"return",
"fds",
".",
"Bits",
"[",
"idx",
"]",
"&",
"(",
"1",
"<<",
"uint",
"... | // fdisset implements FD_ISSET macro. | [
"fdisset",
"implements",
"FD_ISSET",
"macro",
"."
] | 5efbe925ecf714f8ba147bf2226f2e7afc7111bc | https://github.com/goburrow/serial/blob/5efbe925ecf714f8ba147bf2226f2e7afc7111bc/serial_linux.go#L100-L103 |
15,011 | goburrow/serial | serial_windows.go | Read | 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 | 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
} | [
"func",
"(",
"p",
"*",
"port",
")",
"Read",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"var",
"done",
"uint32",
"\n",
"if",
"err",
"=",
"syscall",
".",
"ReadFile",
"(",
"p",
".",
"handle",
",",
"b",
",",
... | // Read reads from serial port.
// It is blocked until data received or timeout after p.timeout. | [
"Read",
"reads",
"from",
"serial",
"port",
".",
"It",
"is",
"blocked",
"until",
"data",
"received",
"or",
"timeout",
"after",
"p",
".",
"timeout",
"."
] | 5efbe925ecf714f8ba147bf2226f2e7afc7111bc | https://github.com/goburrow/serial/blob/5efbe925ecf714f8ba147bf2226f2e7afc7111bc/serial_windows.go#L62-L73 |
15,012 | goburrow/serial | serial_darwin.go | syscallSelect | 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 | 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)
} | [
"func",
"syscallSelect",
"(",
"n",
"int",
",",
"r",
"*",
"syscall",
".",
"FdSet",
",",
"w",
"*",
"syscall",
".",
"FdSet",
",",
"e",
"*",
"syscall",
".",
"FdSet",
",",
"tv",
"*",
"syscall",
".",
"Timeval",
")",
"error",
"{",
"return",
"syscall",
"."... | // syscallSelect is a wapper for syscall.Select that only returns error. | [
"syscallSelect",
"is",
"a",
"wapper",
"for",
"syscall",
".",
"Select",
"that",
"only",
"returns",
"error",
"."
] | 5efbe925ecf714f8ba147bf2226f2e7afc7111bc | https://github.com/goburrow/serial/blob/5efbe925ecf714f8ba147bf2226f2e7afc7111bc/serial_darwin.go#L38-L40 |
15,013 | goburrow/serial | serial_posix.go | Read | 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 err = syscallSelect(fd+1, &rfds, nil, nil, tv); err == nil {
break
}
if err != syscall.EINTR {
err = fmt.Errorf("serial: could not select: %v", err)
return
}
}
if !fdisset(fd, &rfds) {
// Timeout
err = ErrTimeout
return
}
n, err = syscall.Read(fd, b)
return
} | go | 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 err = syscallSelect(fd+1, &rfds, nil, nil, tv); err == nil {
break
}
if err != syscall.EINTR {
err = fmt.Errorf("serial: could not select: %v", err)
return
}
}
if !fdisset(fd, &rfds) {
// Timeout
err = ErrTimeout
return
}
n, err = syscall.Read(fd, b)
return
} | [
"func",
"(",
"p",
"*",
"port",
")",
"Read",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"var",
"rfds",
"syscall",
".",
"FdSet",
"\n\n",
"fd",
":=",
"p",
".",
"fd",
"\n",
"fdset",
"(",
"fd",
",",
"&",
"rf... | // Read reads from serial port. Port must be opened before calling this method.
// It is blocked until all data received or timeout after p.timeout. | [
"Read",
"reads",
"from",
"serial",
"port",
".",
"Port",
"must",
"be",
"opened",
"before",
"calling",
"this",
"method",
".",
"It",
"is",
"blocked",
"until",
"all",
"data",
"received",
"or",
"timeout",
"after",
"p",
".",
"timeout",
"."
] | 5efbe925ecf714f8ba147bf2226f2e7afc7111bc | https://github.com/goburrow/serial/blob/5efbe925ecf714f8ba147bf2226f2e7afc7111bc/serial_posix.go#L87-L115 |
15,014 | goburrow/serial | serial_posix.go | backupTermios | 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 | 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
} | [
"func",
"(",
"p",
"*",
"port",
")",
"backupTermios",
"(",
")",
"{",
"oldTermios",
":=",
"&",
"syscall",
".",
"Termios",
"{",
"}",
"\n",
"if",
"err",
":=",
"tcgetattr",
"(",
"p",
".",
"fd",
",",
"oldTermios",
")",
";",
"err",
"!=",
"nil",
"{",
"//... | // backupTermios saves current termios setting.
// Make sure that device file has been opened before calling this function. | [
"backupTermios",
"saves",
"current",
"termios",
"setting",
".",
"Make",
"sure",
"that",
"device",
"file",
"has",
"been",
"opened",
"before",
"calling",
"this",
"function",
"."
] | 5efbe925ecf714f8ba147bf2226f2e7afc7111bc | https://github.com/goburrow/serial/blob/5efbe925ecf714f8ba147bf2226f2e7afc7111bc/serial_posix.go#L132-L141 |
15,015 | goburrow/serial | serial_posix.go | restoreTermios | 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 | 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
} | [
"func",
"(",
"p",
"*",
"port",
")",
"restoreTermios",
"(",
")",
"{",
"if",
"p",
".",
"oldTermios",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"if",
"err",
":=",
"tcsetattr",
"(",
"p",
".",
"fd",
",",
"p",
".",
"oldTermios",
")",
";",
"err",
"... | // restoreTermios restores backed up termios setting.
// Make sure that device file has been opened before calling this function. | [
"restoreTermios",
"restores",
"backed",
"up",
"termios",
"setting",
".",
"Make",
"sure",
"that",
"device",
"file",
"has",
"been",
"opened",
"before",
"calling",
"this",
"function",
"."
] | 5efbe925ecf714f8ba147bf2226f2e7afc7111bc | https://github.com/goburrow/serial/blob/5efbe925ecf714f8ba147bf2226f2e7afc7111bc/serial_posix.go#L145-L155 |
15,016 | goburrow/serial | serial_posix.go | newTermios | 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: unsupported baud rate %v", c.BaudRate)
return
}
}
termios.Cflag |= flag
// Input baud.
cfSetIspeed(termios, flag)
// Output baud.
cfSetOspeed(termios, flag)
// Character size.
if c.DataBits == 0 {
flag = syscall.CS8
} else {
var ok bool
flag, ok = charSizes[c.DataBits]
if !ok {
err = fmt.Errorf("serial: unsupported character size %v", c.DataBits)
return
}
}
termios.Cflag |= flag
// Stop bits
switch c.StopBits {
case 0, 1:
// Default is one stop bit.
// noop
case 2:
// CSTOPB: Set two stop bits.
termios.Cflag |= syscall.CSTOPB
default:
err = fmt.Errorf("serial: unsupported stop bits %v", c.StopBits)
return
}
switch c.Parity {
case "N":
// noop
case "O":
// PARODD: Parity is odd.
termios.Cflag |= syscall.PARODD
fallthrough
case "", "E":
// As mentioned in the modbus spec, the default parity mode must be Even parity
// PARENB: Enable parity generation on output.
termios.Cflag |= syscall.PARENB
// INPCK: Enable input parity checking.
termios.Iflag |= syscall.INPCK
default:
err = fmt.Errorf("serial: unsupported parity %v", c.Parity)
return
}
// Control modes.
// CREAD: Enable receiver.
// CLOCAL: Ignore control lines.
termios.Cflag |= syscall.CREAD | syscall.CLOCAL
// Special characters.
// VMIN: Minimum number of characters for noncanonical read.
// VTIME: Time in deciseconds for noncanonical read.
// Both are unused as NDELAY is we utilized when opening device.
return
} | go | 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: unsupported baud rate %v", c.BaudRate)
return
}
}
termios.Cflag |= flag
// Input baud.
cfSetIspeed(termios, flag)
// Output baud.
cfSetOspeed(termios, flag)
// Character size.
if c.DataBits == 0 {
flag = syscall.CS8
} else {
var ok bool
flag, ok = charSizes[c.DataBits]
if !ok {
err = fmt.Errorf("serial: unsupported character size %v", c.DataBits)
return
}
}
termios.Cflag |= flag
// Stop bits
switch c.StopBits {
case 0, 1:
// Default is one stop bit.
// noop
case 2:
// CSTOPB: Set two stop bits.
termios.Cflag |= syscall.CSTOPB
default:
err = fmt.Errorf("serial: unsupported stop bits %v", c.StopBits)
return
}
switch c.Parity {
case "N":
// noop
case "O":
// PARODD: Parity is odd.
termios.Cflag |= syscall.PARODD
fallthrough
case "", "E":
// As mentioned in the modbus spec, the default parity mode must be Even parity
// PARENB: Enable parity generation on output.
termios.Cflag |= syscall.PARENB
// INPCK: Enable input parity checking.
termios.Iflag |= syscall.INPCK
default:
err = fmt.Errorf("serial: unsupported parity %v", c.Parity)
return
}
// Control modes.
// CREAD: Enable receiver.
// CLOCAL: Ignore control lines.
termios.Cflag |= syscall.CREAD | syscall.CLOCAL
// Special characters.
// VMIN: Minimum number of characters for noncanonical read.
// VTIME: Time in deciseconds for noncanonical read.
// Both are unused as NDELAY is we utilized when opening device.
return
} | [
"func",
"newTermios",
"(",
"c",
"*",
"Config",
")",
"(",
"termios",
"*",
"syscall",
".",
"Termios",
",",
"err",
"error",
")",
"{",
"termios",
"=",
"&",
"syscall",
".",
"Termios",
"{",
"}",
"\n",
"flag",
":=",
"termios",
".",
"Cflag",
"\n",
"// Baud r... | // Helpers for termios | [
"Helpers",
"for",
"termios"
] | 5efbe925ecf714f8ba147bf2226f2e7afc7111bc | https://github.com/goburrow/serial/blob/5efbe925ecf714f8ba147bf2226f2e7afc7111bc/serial_posix.go#L159-L229 |
15,017 | goburrow/serial | serial_posix.go | enableRS485 | 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.flags |= rs485RTSOnSend
}
if config.RtsHighAfterSend {
rs485.flags |= rs485RTSAfterSend
}
if config.RxDuringTx {
rs485.flags |= rs485RXDuringTX
}
r, _, errno := syscall.Syscall(
syscall.SYS_IOCTL,
uintptr(fd),
uintptr(rs485Tiocs),
uintptr(unsafe.Pointer(&rs485)))
if errno != 0 {
return os.NewSyscallError("SYS_IOCTL (RS485)", errno)
}
if r != 0 {
return errors.New("serial: unknown error from SYS_IOCTL (RS485)")
}
return nil
} | go | 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.flags |= rs485RTSOnSend
}
if config.RtsHighAfterSend {
rs485.flags |= rs485RTSAfterSend
}
if config.RxDuringTx {
rs485.flags |= rs485RXDuringTX
}
r, _, errno := syscall.Syscall(
syscall.SYS_IOCTL,
uintptr(fd),
uintptr(rs485Tiocs),
uintptr(unsafe.Pointer(&rs485)))
if errno != 0 {
return os.NewSyscallError("SYS_IOCTL (RS485)", errno)
}
if r != 0 {
return errors.New("serial: unknown error from SYS_IOCTL (RS485)")
}
return nil
} | [
"func",
"enableRS485",
"(",
"fd",
"int",
",",
"config",
"*",
"RS485Config",
")",
"error",
"{",
"if",
"!",
"config",
".",
"Enabled",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"rs485",
":=",
"rs485_ioctl_opts",
"{",
"rs485Enabled",
",",
"uint32",
"(",
"config... | // enableRS485 enables RS485 functionality of driver via an ioctl if the config says so | [
"enableRS485",
"enables",
"RS485",
"functionality",
"of",
"driver",
"via",
"an",
"ioctl",
"if",
"the",
"config",
"says",
"so"
] | 5efbe925ecf714f8ba147bf2226f2e7afc7111bc | https://github.com/goburrow/serial/blob/5efbe925ecf714f8ba147bf2226f2e7afc7111bc/serial_posix.go#L232-L265 |
15,018 | goburrow/serial | serial.go | Open | func Open(c *Config) (p Port, err error) {
p = New()
err = p.Open(c)
return
} | go | func Open(c *Config) (p Port, err error) {
p = New()
err = p.Open(c)
return
} | [
"func",
"Open",
"(",
"c",
"*",
"Config",
")",
"(",
"p",
"Port",
",",
"err",
"error",
")",
"{",
"p",
"=",
"New",
"(",
")",
"\n",
"err",
"=",
"p",
".",
"Open",
"(",
"c",
")",
"\n",
"return",
"\n",
"}"
] | // Open opens a serial port. | [
"Open",
"opens",
"a",
"serial",
"port",
"."
] | 5efbe925ecf714f8ba147bf2226f2e7afc7111bc | https://github.com/goburrow/serial/blob/5efbe925ecf714f8ba147bf2226f2e7afc7111bc/serial.go#L60-L64 |
15,019 | pin/tftp | server.go | NewServer | 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,
packetReadTimeout: 100 * time.Millisecond,
readHandler: readHandler,
writeHandler: writeHandler,
}
return s
} | go | 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,
packetReadTimeout: 100 * time.Millisecond,
readHandler: readHandler,
writeHandler: writeHandler,
}
return s
} | [
"func",
"NewServer",
"(",
"readHandler",
"func",
"(",
"filename",
"string",
",",
"rf",
"io",
".",
"ReaderFrom",
")",
"error",
",",
"writeHandler",
"func",
"(",
"filename",
"string",
",",
"wt",
"io",
".",
"WriterTo",
")",
"error",
")",
"*",
"Server",
"{",... | // NewServer creates TFTP server. It requires two functions to handle
// read and write requests.
// In case nil is provided for read or write handler the respective
// operation is disabled. | [
"NewServer",
"creates",
"TFTP",
"server",
".",
"It",
"requires",
"two",
"functions",
"to",
"handle",
"read",
"and",
"write",
"requests",
".",
"In",
"case",
"nil",
"is",
"provided",
"for",
"read",
"or",
"write",
"handler",
"the",
"respective",
"operation",
"i... | 70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4 | https://github.com/pin/tftp/blob/70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4/server.go#L18-L30 |
15,020 | pin/tftp | server.go | SetAnticipate | func (s *Server) SetAnticipate(winsz uint) {
if winsz > 1 {
s.sendAEnable = true
s.sendAWinSz = winsz
} else {
s.sendAEnable = false
s.sendAWinSz = 1
}
} | go | func (s *Server) SetAnticipate(winsz uint) {
if winsz > 1 {
s.sendAEnable = true
s.sendAWinSz = winsz
} else {
s.sendAEnable = false
s.sendAWinSz = 1
}
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"SetAnticipate",
"(",
"winsz",
"uint",
")",
"{",
"if",
"winsz",
">",
"1",
"{",
"s",
".",
"sendAEnable",
"=",
"true",
"\n",
"s",
".",
"sendAWinSz",
"=",
"winsz",
"\n",
"}",
"else",
"{",
"s",
".",
"sendAEnable",
... | // SetAnticipate provides an experimental feature in which when a packets
// is requested the server will keep sending a number of packets before
// checking whether an ack has been received. It improves tftp downloading
// speed by a few times.
// The argument winsz specifies how many packets will be sent before
// waiting for an ack packet.
// When winsz is bigger than 1, the feature is enabled, and the server
// runs through a different experimental code path. When winsz is 0 or 1,
// the feature is disabled. | [
"SetAnticipate",
"provides",
"an",
"experimental",
"feature",
"in",
"which",
"when",
"a",
"packets",
"is",
"requested",
"the",
"server",
"will",
"keep",
"sending",
"a",
"number",
"of",
"packets",
"before",
"checking",
"whether",
"an",
"ack",
"has",
"been",
"re... | 70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4 | https://github.com/pin/tftp/blob/70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4/server.go#L76-L84 |
15,021 | pin/tftp | server.go | EnableSinglePort | 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 | 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()
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"EnableSinglePort",
"(",
")",
"{",
"s",
".",
"singlePort",
"=",
"true",
"\n",
"s",
".",
"handlers",
"=",
"make",
"(",
"map",
"[",
"string",
"]",
"chan",
"[",
"]",
"byte",
",",
"datagramLength",
")",
"\n",
"s",
... | // EnableSinglePort enables an experimental mode where the server will
// serve all connections on port 69 only. There will be no random TIDs
// on the server side.
//
// Enabling this will negatively impact performance | [
"EnableSinglePort",
"enables",
"an",
"experimental",
"mode",
"where",
"the",
"server",
"will",
"serve",
"all",
"connections",
"on",
"port",
"69",
"only",
".",
"There",
"will",
"be",
"no",
"random",
"TIDs",
"on",
"the",
"server",
"side",
".",
"Enabling",
"thi... | 70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4 | https://github.com/pin/tftp/blob/70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4/server.go#L91-L101 |
15,022 | pin/tftp | server.go | SetTimeout | func (s *Server) SetTimeout(t time.Duration) {
if t <= 0 {
s.timeout = defaultTimeout
} else {
s.timeout = t
}
} | go | func (s *Server) SetTimeout(t time.Duration) {
if t <= 0 {
s.timeout = defaultTimeout
} else {
s.timeout = t
}
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"SetTimeout",
"(",
"t",
"time",
".",
"Duration",
")",
"{",
"if",
"t",
"<=",
"0",
"{",
"s",
".",
"timeout",
"=",
"defaultTimeout",
"\n",
"}",
"else",
"{",
"s",
".",
"timeout",
"=",
"t",
"\n",
"}",
"\n",
"}"
... | // SetTimeout sets maximum time server waits for single network
// round-trip to succeed.
// Default is 5 seconds. | [
"SetTimeout",
"sets",
"maximum",
"time",
"server",
"waits",
"for",
"single",
"network",
"round",
"-",
"trip",
"to",
"succeed",
".",
"Default",
"is",
"5",
"seconds",
"."
] | 70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4 | https://github.com/pin/tftp/blob/70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4/server.go#L106-L112 |
15,023 | pin/tftp | server.go | SetRetries | func (s *Server) SetRetries(count int) {
if count < 1 {
s.retries = defaultRetries
} else {
s.retries = count
}
} | go | func (s *Server) SetRetries(count int) {
if count < 1 {
s.retries = defaultRetries
} else {
s.retries = count
}
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"SetRetries",
"(",
"count",
"int",
")",
"{",
"if",
"count",
"<",
"1",
"{",
"s",
".",
"retries",
"=",
"defaultRetries",
"\n",
"}",
"else",
"{",
"s",
".",
"retries",
"=",
"count",
"\n",
"}",
"\n",
"}"
] | // SetRetries sets maximum number of attempts server made to transmit a
// packet.
// Default is 5 attempts. | [
"SetRetries",
"sets",
"maximum",
"number",
"of",
"attempts",
"server",
"made",
"to",
"transmit",
"a",
"packet",
".",
"Default",
"is",
"5",
"attempts",
"."
] | 70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4 | https://github.com/pin/tftp/blob/70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4/server.go#L130-L136 |
15,024 | pin/tftp | server.go | ListenAndServe | 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 | 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)
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"ListenAndServe",
"(",
"addr",
"string",
")",
"error",
"{",
"a",
",",
"err",
":=",
"net",
".",
"ResolveUDPAddr",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
... | // ListenAndServe binds to address provided and start the server.
// ListenAndServe returns when Shutdown is called. | [
"ListenAndServe",
"binds",
"to",
"address",
"provided",
"and",
"start",
"the",
"server",
".",
"ListenAndServe",
"returns",
"when",
"Shutdown",
"is",
"called",
"."
] | 70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4 | https://github.com/pin/tftp/blob/70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4/server.go#L146-L156 |
15,025 | pin/tftp | server.go | Serve | 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)
if addr == nil {
return fmt.Errorf("Failed to determine IP class of listening address")
}
if addr.To4() != nil {
s.conn4 = ipv4.NewPacketConn(conn)
if err := s.conn4.SetControlMessage(ipv4.FlagDst|ipv4.FlagInterface, true); err != nil {
s.conn4 = nil
}
} else {
s.conn6 = ipv6.NewPacketConn(conn)
if err := s.conn6.SetControlMessage(ipv6.FlagDst|ipv6.FlagInterface, true); err != nil {
s.conn6 = nil
}
}
s.quit = make(chan chan struct{})
if s.singlePort {
s.singlePortProcessRequests()
} else {
for {
select {
case q := <-s.quit:
q <- struct{}{}
return nil
default:
var err error
if s.conn4 != nil {
err = s.processRequest4()
} else if s.conn6 != nil {
err = s.processRequest6()
} else {
err = s.processRequest()
}
if err != nil {
// TODO: add logging handler
}
}
}
}
return nil
} | go | 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)
if addr == nil {
return fmt.Errorf("Failed to determine IP class of listening address")
}
if addr.To4() != nil {
s.conn4 = ipv4.NewPacketConn(conn)
if err := s.conn4.SetControlMessage(ipv4.FlagDst|ipv4.FlagInterface, true); err != nil {
s.conn4 = nil
}
} else {
s.conn6 = ipv6.NewPacketConn(conn)
if err := s.conn6.SetControlMessage(ipv6.FlagDst|ipv6.FlagInterface, true); err != nil {
s.conn6 = nil
}
}
s.quit = make(chan chan struct{})
if s.singlePort {
s.singlePortProcessRequests()
} else {
for {
select {
case q := <-s.quit:
q <- struct{}{}
return nil
default:
var err error
if s.conn4 != nil {
err = s.processRequest4()
} else if s.conn6 != nil {
err = s.processRequest6()
} else {
err = s.processRequest()
}
if err != nil {
// TODO: add logging handler
}
}
}
}
return nil
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"Serve",
"(",
"conn",
"*",
"net",
".",
"UDPConn",
")",
"error",
"{",
"defer",
"conn",
".",
"Close",
"(",
")",
"\n",
"laddr",
":=",
"conn",
".",
"LocalAddr",
"(",
")",
"\n",
"host",
",",
"_",
",",
"err",
":=... | // Serve starts server provided already opened UDP connecton. It is
// useful for the case when you want to run server in separate goroutine
// but still want to be able to handle any errors opening connection.
// Serve returns when Shutdown is called or connection is closed. | [
"Serve",
"starts",
"server",
"provided",
"already",
"opened",
"UDP",
"connecton",
".",
"It",
"is",
"useful",
"for",
"the",
"case",
"when",
"you",
"want",
"to",
"run",
"server",
"in",
"separate",
"goroutine",
"but",
"still",
"want",
"to",
"be",
"able",
"to"... | 70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4 | https://github.com/pin/tftp/blob/70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4/server.go#L162-L213 |
15,026 | pin/tftp | server.go | Shutdown | func (s *Server) Shutdown() {
s.conn.Close()
q := make(chan struct{})
s.quit <- q
<-q
s.wg.Wait()
} | go | func (s *Server) Shutdown() {
s.conn.Close()
q := make(chan struct{})
s.quit <- q
<-q
s.wg.Wait()
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"Shutdown",
"(",
")",
"{",
"s",
".",
"conn",
".",
"Close",
"(",
")",
"\n",
"q",
":=",
"make",
"(",
"chan",
"struct",
"{",
"}",
")",
"\n",
"s",
".",
"quit",
"<-",
"q",
"\n",
"<-",
"q",
"\n",
"s",
".",
... | // Shutdown make server stop listening for new requests, allows
// server to finish outstanding transfers and stops server. | [
"Shutdown",
"make",
"server",
"stop",
"listening",
"for",
"new",
"requests",
"allows",
"server",
"to",
"finish",
"outstanding",
"transfers",
"and",
"stops",
"server",
"."
] | 70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4 | https://github.com/pin/tftp/blob/70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4/server.go#L271-L277 |
15,027 | pin/tftp | single_port.go | internalGC | 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 | 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
}
}
} | [
"func",
"(",
"s",
"*",
"Server",
")",
"internalGC",
"(",
")",
"{",
"var",
"completedHandlers",
"[",
"]",
"string",
"\n",
"for",
"{",
"select",
"{",
"case",
"newHandler",
":=",
"<-",
"s",
".",
"gcCollect",
":",
"completedHandlers",
"=",
"append",
"(",
"... | // internalGC collects all the finished signals from each connection's goroutine
// The main loop is sent the key to be nil'ed after the gcInterval has passed | [
"internalGC",
"collects",
"all",
"the",
"finished",
"signals",
"from",
"each",
"connection",
"s",
"goroutine",
"The",
"main",
"loop",
"is",
"sent",
"the",
"key",
"to",
"be",
"nil",
"ed",
"after",
"the",
"gcInterval",
"has",
"passed"
] | 70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4 | https://github.com/pin/tftp/blob/70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4/single_port.go#L92-L103 |
15,028 | pin/tftp | packet.go | packRQ | 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] = 0
n++
}
return n
} | go | 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] = 0
n++
}
return n
} | [
"func",
"packRQ",
"(",
"p",
"[",
"]",
"byte",
",",
"op",
"uint16",
",",
"filename",
",",
"mode",
"string",
",",
"opts",
"options",
")",
"int",
"{",
"binary",
".",
"BigEndian",
".",
"PutUint16",
"(",
"p",
",",
"op",
")",
"\n",
"n",
":=",
"2",
"\n"... | // packRQ returns length of the packet in b | [
"packRQ",
"returns",
"length",
"of",
"the",
"packet",
"in",
"b"
] | 70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4 | https://github.com/pin/tftp/blob/70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4/packet.go#L35-L53 |
15,029 | pin/tftp | client.go | NewClient | 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 | 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
} | [
"func",
"NewClient",
"(",
"addr",
"string",
")",
"(",
"*",
"Client",
",",
"error",
")",
"{",
"a",
",",
"err",
":=",
"net",
".",
"ResolveUDPAddr",
"(",
"\"",
"\"",
",",
"addr",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"fmt",... | // NewClient creates TFTP client for server on address provided. | [
"NewClient",
"creates",
"TFTP",
"client",
"for",
"server",
"on",
"address",
"provided",
"."
] | 70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4 | https://github.com/pin/tftp/blob/70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4/client.go#L12-L22 |
15,030 | pin/tftp | client.go | SetTimeout | func (c *Client) SetTimeout(t time.Duration) {
if t <= 0 {
c.timeout = defaultTimeout
}
c.timeout = t
} | go | func (c *Client) SetTimeout(t time.Duration) {
if t <= 0 {
c.timeout = defaultTimeout
}
c.timeout = t
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SetTimeout",
"(",
"t",
"time",
".",
"Duration",
")",
"{",
"if",
"t",
"<=",
"0",
"{",
"c",
".",
"timeout",
"=",
"defaultTimeout",
"\n",
"}",
"\n",
"c",
".",
"timeout",
"=",
"t",
"\n",
"}"
] | // SetTimeout sets maximum time client waits for single network round-trip to succeed.
// Default is 5 seconds. | [
"SetTimeout",
"sets",
"maximum",
"time",
"client",
"waits",
"for",
"single",
"network",
"round",
"-",
"trip",
"to",
"succeed",
".",
"Default",
"is",
"5",
"seconds",
"."
] | 70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4 | https://github.com/pin/tftp/blob/70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4/client.go#L26-L31 |
15,031 | pin/tftp | client.go | SetRetries | func (c *Client) SetRetries(count int) {
if count < 1 {
c.retries = defaultRetries
}
c.retries = count
} | go | func (c *Client) SetRetries(count int) {
if count < 1 {
c.retries = defaultRetries
}
c.retries = count
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SetRetries",
"(",
"count",
"int",
")",
"{",
"if",
"count",
"<",
"1",
"{",
"c",
".",
"retries",
"=",
"defaultRetries",
"\n",
"}",
"\n",
"c",
".",
"retries",
"=",
"count",
"\n",
"}"
] | // SetRetries sets maximum number of attempts client made to transmit a packet.
// Default is 5 attempts. | [
"SetRetries",
"sets",
"maximum",
"number",
"of",
"attempts",
"client",
"made",
"to",
"transmit",
"a",
"packet",
".",
"Default",
"is",
"5",
"attempts",
"."
] | 70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4 | https://github.com/pin/tftp/blob/70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4/client.go#L35-L40 |
15,032 | pin/tftp | client.go | Send | 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: &backoff{handler: c.backoff},
timeout: c.timeout,
retries: c.retries,
addr: c.addr,
mode: mode,
}
if c.blksize != 0 {
s.opts = make(options)
s.opts["blksize"] = strconv.Itoa(c.blksize)
}
n := packRQ(s.send, opWRQ, filename, mode, s.opts)
addr, err := s.sendWithRetry(n)
if err != nil {
return nil, err
}
s.addr = addr
s.opts = nil
return s, nil
} | go | 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: &backoff{handler: c.backoff},
timeout: c.timeout,
retries: c.retries,
addr: c.addr,
mode: mode,
}
if c.blksize != 0 {
s.opts = make(options)
s.opts["blksize"] = strconv.Itoa(c.blksize)
}
n := packRQ(s.send, opWRQ, filename, mode, s.opts)
addr, err := s.sendWithRetry(n)
if err != nil {
return nil, err
}
s.addr = addr
s.opts = nil
return s, nil
} | [
"func",
"(",
"c",
"Client",
")",
"Send",
"(",
"filename",
"string",
",",
"mode",
"string",
")",
"(",
"io",
".",
"ReaderFrom",
",",
"error",
")",
"{",
"conn",
",",
"err",
":=",
"net",
".",
"ListenUDP",
"(",
"\"",
"\"",
",",
"&",
"net",
".",
"UDPAd... | // Send starts outgoing file transmission. It returns io.ReaderFrom or error. | [
"Send",
"starts",
"outgoing",
"file",
"transmission",
".",
"It",
"returns",
"io",
".",
"ReaderFrom",
"or",
"error",
"."
] | 70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4 | https://github.com/pin/tftp/blob/70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4/client.go#L68-L95 |
15,033 | pin/tftp | client.go | Receive | 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),
conn: &connConnection{conn: conn},
retry: &backoff{handler: c.backoff},
timeout: c.timeout,
retries: c.retries,
addr: c.addr,
autoTerm: true,
block: 1,
mode: mode,
}
if c.blksize != 0 || c.tsize {
r.opts = make(options)
}
if c.blksize != 0 {
r.opts["blksize"] = strconv.Itoa(c.blksize)
// Clean it up so we don't send options twice
defer func() { delete(r.opts, "blksize") }()
}
if c.tsize {
r.opts["tsize"] = "0"
}
n := packRQ(r.send, opRRQ, filename, mode, r.opts)
l, addr, err := r.receiveWithRetry(n)
if err != nil {
return nil, err
}
r.l = l
r.addr = addr
return r, nil
} | go | 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),
conn: &connConnection{conn: conn},
retry: &backoff{handler: c.backoff},
timeout: c.timeout,
retries: c.retries,
addr: c.addr,
autoTerm: true,
block: 1,
mode: mode,
}
if c.blksize != 0 || c.tsize {
r.opts = make(options)
}
if c.blksize != 0 {
r.opts["blksize"] = strconv.Itoa(c.blksize)
// Clean it up so we don't send options twice
defer func() { delete(r.opts, "blksize") }()
}
if c.tsize {
r.opts["tsize"] = "0"
}
n := packRQ(r.send, opRRQ, filename, mode, r.opts)
l, addr, err := r.receiveWithRetry(n)
if err != nil {
return nil, err
}
r.l = l
r.addr = addr
return r, nil
} | [
"func",
"(",
"c",
"Client",
")",
"Receive",
"(",
"filename",
"string",
",",
"mode",
"string",
")",
"(",
"io",
".",
"WriterTo",
",",
"error",
")",
"{",
"conn",
",",
"err",
":=",
"net",
".",
"ListenUDP",
"(",
"\"",
"\"",
",",
"&",
"net",
".",
"UDPA... | // Receive starts incoming file transmission. It returns io.WriterTo or error. | [
"Receive",
"starts",
"incoming",
"file",
"transmission",
".",
"It",
"returns",
"io",
".",
"WriterTo",
"or",
"error",
"."
] | 70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4 | https://github.com/pin/tftp/blob/70c6a2187577a9ecf3e5e89f672ef3d8e1e95dc4/client.go#L98-L137 |
15,034 | 99designs/keyring | keyring.go | AvailableBackends | 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 | 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)
} | [
"func",
"AvailableBackends",
"(",
")",
"[",
"]",
"BackendType",
"{",
"b",
":=",
"[",
"]",
"BackendType",
"{",
"}",
"\n",
"for",
"k",
":=",
"range",
"supportedBackends",
"{",
"if",
"k",
"!=",
"FileBackend",
"{",
"b",
"=",
"append",
"(",
"b",
",",
"k",... | // AvailableBackends provides a slice of all available backend keys on the current OS | [
"AvailableBackends",
"provides",
"a",
"slice",
"of",
"all",
"available",
"backend",
"keys",
"on",
"the",
"current",
"OS"
] | 82da6802f65f1ac7963cfc3b7c62ae12dab8ee5d | https://github.com/99designs/keyring/blob/82da6802f65f1ac7963cfc3b7c62ae12dab8ee5d/keyring.go#L27-L36 |
15,035 | 99designs/keyring | keyring.go | Open | 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 err != nil {
debugf("Failed backend %s: %s", backend, err)
continue
}
return openBackend, nil
}
}
return nil, ErrNoAvailImpl
} | go | 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 err != nil {
debugf("Failed backend %s: %s", backend, err)
continue
}
return openBackend, nil
}
}
return nil, ErrNoAvailImpl
} | [
"func",
"Open",
"(",
"cfg",
"Config",
")",
"(",
"Keyring",
",",
"error",
")",
"{",
"if",
"cfg",
".",
"AllowedBackends",
"==",
"nil",
"{",
"cfg",
".",
"AllowedBackends",
"=",
"AvailableBackends",
"(",
")",
"\n",
"}",
"\n",
"debugf",
"(",
"\"",
"\"",
"... | // Open will open a specific keyring backend | [
"Open",
"will",
"open",
"a",
"specific",
"keyring",
"backend"
] | 82da6802f65f1ac7963cfc3b7c62ae12dab8ee5d | https://github.com/99designs/keyring/blob/82da6802f65f1ac7963cfc3b7c62ae12dab8ee5d/keyring.go#L41-L57 |
15,036 | 99designs/keyring | array.go | NewArrayKeyring | func NewArrayKeyring(initial []Item) *ArrayKeyring {
kr := &ArrayKeyring{}
for _, i := range initial {
_ = kr.Set(i)
}
return kr
} | go | func NewArrayKeyring(initial []Item) *ArrayKeyring {
kr := &ArrayKeyring{}
for _, i := range initial {
_ = kr.Set(i)
}
return kr
} | [
"func",
"NewArrayKeyring",
"(",
"initial",
"[",
"]",
"Item",
")",
"*",
"ArrayKeyring",
"{",
"kr",
":=",
"&",
"ArrayKeyring",
"{",
"}",
"\n",
"for",
"_",
",",
"i",
":=",
"range",
"initial",
"{",
"_",
"=",
"kr",
".",
"Set",
"(",
"i",
")",
"\n",
"}"... | // NewArrayKeyring returns an ArrayKeyring, optionally constructed with an initial slice
// of items | [
"NewArrayKeyring",
"returns",
"an",
"ArrayKeyring",
"optionally",
"constructed",
"with",
"an",
"initial",
"slice",
"of",
"items"
] | 82da6802f65f1ac7963cfc3b7c62ae12dab8ee5d | https://github.com/99designs/keyring/blob/82da6802f65f1ac7963cfc3b7c62ae12dab8ee5d/array.go#L12-L18 |
15,037 | 99designs/keyring | array.go | Get | func (k *ArrayKeyring) Get(key string) (Item, error) {
if i, ok := k.items[key]; ok {
return i, nil
}
return Item{}, ErrKeyNotFound
} | go | func (k *ArrayKeyring) Get(key string) (Item, error) {
if i, ok := k.items[key]; ok {
return i, nil
}
return Item{}, ErrKeyNotFound
} | [
"func",
"(",
"k",
"*",
"ArrayKeyring",
")",
"Get",
"(",
"key",
"string",
")",
"(",
"Item",
",",
"error",
")",
"{",
"if",
"i",
",",
"ok",
":=",
"k",
".",
"items",
"[",
"key",
"]",
";",
"ok",
"{",
"return",
"i",
",",
"nil",
"\n",
"}",
"\n",
"... | // Get returns an Item matching Key | [
"Get",
"returns",
"an",
"Item",
"matching",
"Key"
] | 82da6802f65f1ac7963cfc3b7c62ae12dab8ee5d | https://github.com/99designs/keyring/blob/82da6802f65f1ac7963cfc3b7c62ae12dab8ee5d/array.go#L21-L26 |
15,038 | 99designs/keyring | array.go | Set | func (k *ArrayKeyring) Set(i Item) error {
if k.items == nil {
k.items = map[string]Item{}
}
k.items[i.Key] = i
return nil
} | go | func (k *ArrayKeyring) Set(i Item) error {
if k.items == nil {
k.items = map[string]Item{}
}
k.items[i.Key] = i
return nil
} | [
"func",
"(",
"k",
"*",
"ArrayKeyring",
")",
"Set",
"(",
"i",
"Item",
")",
"error",
"{",
"if",
"k",
".",
"items",
"==",
"nil",
"{",
"k",
".",
"items",
"=",
"map",
"[",
"string",
"]",
"Item",
"{",
"}",
"\n",
"}",
"\n",
"k",
".",
"items",
"[",
... | // Set will store an item on the mock Keyring | [
"Set",
"will",
"store",
"an",
"item",
"on",
"the",
"mock",
"Keyring"
] | 82da6802f65f1ac7963cfc3b7c62ae12dab8ee5d | https://github.com/99designs/keyring/blob/82da6802f65f1ac7963cfc3b7c62ae12dab8ee5d/array.go#L29-L35 |
15,039 | 99designs/keyring | array.go | Remove | func (k *ArrayKeyring) Remove(key string) error {
delete(k.items, key)
return nil
} | go | func (k *ArrayKeyring) Remove(key string) error {
delete(k.items, key)
return nil
} | [
"func",
"(",
"k",
"*",
"ArrayKeyring",
")",
"Remove",
"(",
"key",
"string",
")",
"error",
"{",
"delete",
"(",
"k",
".",
"items",
",",
"key",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // Remove will delete an Item from the Keyring | [
"Remove",
"will",
"delete",
"an",
"Item",
"from",
"the",
"Keyring"
] | 82da6802f65f1ac7963cfc3b7c62ae12dab8ee5d | https://github.com/99designs/keyring/blob/82da6802f65f1ac7963cfc3b7c62ae12dab8ee5d/array.go#L38-L41 |
15,040 | 99designs/keyring | array.go | Keys | func (k *ArrayKeyring) Keys() ([]string, error) {
var keys = []string{}
for key := range k.items {
keys = append(keys, key)
}
return keys, nil
} | go | func (k *ArrayKeyring) Keys() ([]string, error) {
var keys = []string{}
for key := range k.items {
keys = append(keys, key)
}
return keys, nil
} | [
"func",
"(",
"k",
"*",
"ArrayKeyring",
")",
"Keys",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"var",
"keys",
"=",
"[",
"]",
"string",
"{",
"}",
"\n",
"for",
"key",
":=",
"range",
"k",
".",
"items",
"{",
"keys",
"=",
"append",
... | // Keys provides a slice of all Item keys on the Keyring | [
"Keys",
"provides",
"a",
"slice",
"of",
"all",
"Item",
"keys",
"on",
"the",
"Keyring"
] | 82da6802f65f1ac7963cfc3b7c62ae12dab8ee5d | https://github.com/99designs/keyring/blob/82da6802f65f1ac7963cfc3b7c62ae12dab8ee5d/array.go#L44-L50 |
15,041 | digitalocean/go-metadata | client.go | WithHTTPClient | func WithHTTPClient(client *http.Client) ClientOption {
return func(metaclient *Client) { metaclient.client = client }
} | go | func WithHTTPClient(client *http.Client) ClientOption {
return func(metaclient *Client) { metaclient.client = client }
} | [
"func",
"WithHTTPClient",
"(",
"client",
"*",
"http",
".",
"Client",
")",
"ClientOption",
"{",
"return",
"func",
"(",
"metaclient",
"*",
"Client",
")",
"{",
"metaclient",
".",
"client",
"=",
"client",
"}",
"\n",
"}"
] | // WithHTTPClient makes the metadata client use the given HTTP client. | [
"WithHTTPClient",
"makes",
"the",
"metadata",
"client",
"use",
"the",
"given",
"HTTP",
"client",
"."
] | 15bd36e5f6f745f32074d0705a27aee05ae0a216 | https://github.com/digitalocean/go-metadata/blob/15bd36e5f6f745f32074d0705a27aee05ae0a216/client.go#L44-L46 |
15,042 | digitalocean/go-metadata | client.go | WithBaseURL | func WithBaseURL(base *url.URL) ClientOption {
return func(metaclient *Client) { metaclient.baseURL = base }
} | go | func WithBaseURL(base *url.URL) ClientOption {
return func(metaclient *Client) { metaclient.baseURL = base }
} | [
"func",
"WithBaseURL",
"(",
"base",
"*",
"url",
".",
"URL",
")",
"ClientOption",
"{",
"return",
"func",
"(",
"metaclient",
"*",
"Client",
")",
"{",
"metaclient",
".",
"baseURL",
"=",
"base",
"}",
"\n",
"}"
] | // WithBaseURL makes the metadata client reach the metadata API using the
// given base URL. | [
"WithBaseURL",
"makes",
"the",
"metadata",
"client",
"reach",
"the",
"metadata",
"API",
"using",
"the",
"given",
"base",
"URL",
"."
] | 15bd36e5f6f745f32074d0705a27aee05ae0a216 | https://github.com/digitalocean/go-metadata/blob/15bd36e5f6f745f32074d0705a27aee05ae0a216/client.go#L50-L52 |
15,043 | digitalocean/go-metadata | client.go | NewClient | func NewClient(opts ...ClientOption) *Client {
client := &Client{
client: &http.Client{Timeout: defaultTimeout},
baseURL: defaultBaseURL,
}
for _, opt := range opts {
opt(client)
}
return client
} | go | func NewClient(opts ...ClientOption) *Client {
client := &Client{
client: &http.Client{Timeout: defaultTimeout},
baseURL: defaultBaseURL,
}
for _, opt := range opts {
opt(client)
}
return client
} | [
"func",
"NewClient",
"(",
"opts",
"...",
"ClientOption",
")",
"*",
"Client",
"{",
"client",
":=",
"&",
"Client",
"{",
"client",
":",
"&",
"http",
".",
"Client",
"{",
"Timeout",
":",
"defaultTimeout",
"}",
",",
"baseURL",
":",
"defaultBaseURL",
",",
"}",
... | // NewClient creates a client for the metadata API. | [
"NewClient",
"creates",
"a",
"client",
"for",
"the",
"metadata",
"API",
"."
] | 15bd36e5f6f745f32074d0705a27aee05ae0a216 | https://github.com/digitalocean/go-metadata/blob/15bd36e5f6f745f32074d0705a27aee05ae0a216/client.go#L62-L71 |
15,044 | digitalocean/go-metadata | client.go | Metadata | 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 | 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
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Metadata",
"(",
")",
"(",
"*",
"Metadata",
",",
"error",
")",
"{",
"metadata",
":=",
"new",
"(",
"Metadata",
")",
"\n",
"err",
":=",
"c",
".",
"doGetURL",
"(",
"c",
".",
"resolve",
"(",
"\"",
"\"",
")",
",... | // Metadata contains the entire contents of a Droplet's metadata.
// This method is unique because it returns all of the
// metadata at once, instead of individual metadata items. | [
"Metadata",
"contains",
"the",
"entire",
"contents",
"of",
"a",
"Droplet",
"s",
"metadata",
".",
"This",
"method",
"is",
"unique",
"because",
"it",
"returns",
"all",
"of",
"the",
"metadata",
"at",
"once",
"instead",
"of",
"individual",
"metadata",
"items",
"... | 15bd36e5f6f745f32074d0705a27aee05ae0a216 | https://github.com/digitalocean/go-metadata/blob/15bd36e5f6f745f32074d0705a27aee05ae0a216/client.go#L76-L82 |
15,045 | digitalocean/go-metadata | client.go | DropletID | 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 | 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
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"DropletID",
"(",
")",
"(",
"int",
",",
"error",
")",
"{",
"dropletID",
":=",
"new",
"(",
"int",
")",
"\n",
"err",
":=",
"c",
".",
"doGet",
"(",
"\"",
"\"",
",",
"func",
"(",
"r",
"io",
".",
"Reader",
")"... | // DropletID returns the Droplet's unique identifier. This is
// automatically generated upon Droplet creation. | [
"DropletID",
"returns",
"the",
"Droplet",
"s",
"unique",
"identifier",
".",
"This",
"is",
"automatically",
"generated",
"upon",
"Droplet",
"creation",
"."
] | 15bd36e5f6f745f32074d0705a27aee05ae0a216 | https://github.com/digitalocean/go-metadata/blob/15bd36e5f6f745f32074d0705a27aee05ae0a216/client.go#L86-L93 |
15,046 | digitalocean/go-metadata | client.go | Hostname | 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 | 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
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Hostname",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"hostname",
"string",
"\n",
"err",
":=",
"c",
".",
"doGet",
"(",
"\"",
"\"",
",",
"func",
"(",
"r",
"io",
".",
"Reader",
")",
"error",
"{"... | // Hostname returns the Droplet's hostname, as specified by the
// user during Droplet creation. | [
"Hostname",
"returns",
"the",
"Droplet",
"s",
"hostname",
"as",
"specified",
"by",
"the",
"user",
"during",
"Droplet",
"creation",
"."
] | 15bd36e5f6f745f32074d0705a27aee05ae0a216 | https://github.com/digitalocean/go-metadata/blob/15bd36e5f6f745f32074d0705a27aee05ae0a216/client.go#L97-L105 |
15,047 | digitalocean/go-metadata | client.go | UserData | 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 | 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
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"UserData",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"userdata",
"string",
"\n",
"err",
":=",
"c",
".",
"doGet",
"(",
"\"",
"\"",
",",
"func",
"(",
"r",
"io",
".",
"Reader",
")",
"error",
"{"... | // UserData returns the user data that was provided by the user
// during Droplet creation. User data can contain arbitrary data
// for miscellaneous use or, with certain Linux distributions,
// an arbitrary shell script or cloud-config file that will be
// consumed by a variation of cloud-init upon boot. At this time,
// cloud-config support is included with CoreOS, Ubuntu 14.04, and
// CentOS 7 images on DigitalOcean. | [
"UserData",
"returns",
"the",
"user",
"data",
"that",
"was",
"provided",
"by",
"the",
"user",
"during",
"Droplet",
"creation",
".",
"User",
"data",
"can",
"contain",
"arbitrary",
"data",
"for",
"miscellaneous",
"use",
"or",
"with",
"certain",
"Linux",
"distrib... | 15bd36e5f6f745f32074d0705a27aee05ae0a216 | https://github.com/digitalocean/go-metadata/blob/15bd36e5f6f745f32074d0705a27aee05ae0a216/client.go#L114-L122 |
15,048 | digitalocean/go-metadata | client.go | VendorData | 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 | 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
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"VendorData",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"vendordata",
"string",
"\n",
"err",
":=",
"c",
".",
"doGet",
"(",
"\"",
"\"",
",",
"func",
"(",
"r",
"io",
".",
"Reader",
")",
"error",
... | // VendorData provided data that can be used to configure Droplets
// upon their creation. This is similar to user data, but it is
// provided by DigitalOcean instead of the user. | [
"VendorData",
"provided",
"data",
"that",
"can",
"be",
"used",
"to",
"configure",
"Droplets",
"upon",
"their",
"creation",
".",
"This",
"is",
"similar",
"to",
"user",
"data",
"but",
"it",
"is",
"provided",
"by",
"DigitalOcean",
"instead",
"of",
"the",
"user"... | 15bd36e5f6f745f32074d0705a27aee05ae0a216 | https://github.com/digitalocean/go-metadata/blob/15bd36e5f6f745f32074d0705a27aee05ae0a216/client.go#L127-L135 |
15,049 | digitalocean/go-metadata | client.go | Region | 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 | 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
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Region",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"region",
"string",
"\n",
"err",
":=",
"c",
".",
"doGet",
"(",
"\"",
"\"",
",",
"func",
"(",
"r",
"io",
".",
"Reader",
")",
"error",
"{",
... | // Region returns the region code of where the Droplet resides. | [
"Region",
"returns",
"the",
"region",
"code",
"of",
"where",
"the",
"Droplet",
"resides",
"."
] | 15bd36e5f6f745f32074d0705a27aee05ae0a216 | https://github.com/digitalocean/go-metadata/blob/15bd36e5f6f745f32074d0705a27aee05ae0a216/client.go#L138-L146 |
15,050 | digitalocean/go-metadata | client.go | AuthToken | 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 | 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
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"AuthToken",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"authToken",
"string",
"\n",
"err",
":=",
"c",
".",
"doGet",
"(",
"\"",
"\"",
",",
"func",
"(",
"r",
"io",
".",
"Reader",
")",
"error",
"... | // AuthToken returns the authentication token. | [
"AuthToken",
"returns",
"the",
"authentication",
"token",
"."
] | 15bd36e5f6f745f32074d0705a27aee05ae0a216 | https://github.com/digitalocean/go-metadata/blob/15bd36e5f6f745f32074d0705a27aee05ae0a216/client.go#L149-L157 |
15,051 | digitalocean/go-metadata | client.go | FloatingIPv4Active | 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 | 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
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"FloatingIPv4Active",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"var",
"active",
"bool",
"\n",
"err",
":=",
"c",
".",
"doGet",
"(",
"\"",
"\"",
",",
"func",
"(",
"r",
"io",
".",
"Reader",
")",
"error",
... | // FloatingIPv4Active returns true if an IPv4 Floating IP
// Address is assigned to the Droplet. | [
"FloatingIPv4Active",
"returns",
"true",
"if",
"an",
"IPv4",
"Floating",
"IP",
"Address",
"is",
"assigned",
"to",
"the",
"Droplet",
"."
] | 15bd36e5f6f745f32074d0705a27aee05ae0a216 | https://github.com/digitalocean/go-metadata/blob/15bd36e5f6f745f32074d0705a27aee05ae0a216/client.go#L204-L214 |
15,052 | goml/gobrain | persist/persist.go | Save | 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 | 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
} | [
"func",
"Save",
"(",
"path",
"string",
",",
"v",
"interface",
"{",
"}",
")",
"error",
"{",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"f",
",",
"err",
":=",
"os",
".",
"Create",
"(",
"path",
")",
"\n",
... | // Save saves a representation of v to the file at path. | [
"Save",
"saves",
"a",
"representation",
"of",
"v",
"to",
"the",
"file",
"at",
"path",
"."
] | 499982ed3a4862e26a28b65fef3544129b26aa0f | https://github.com/goml/gobrain/blob/499982ed3a4862e26a28b65fef3544129b26aa0f/persist/persist.go#L28-L42 |
15,053 | djimenez/iconv-go | reader.go | Read | 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 when we have less data than len(p)
// we should have an appropriate amount of data, convert it into the given buffer
bytesRead, bytesWritten, err := this.converter.Convert(this.buffer[this.readPos:this.writePos], p)
// adjust byte counters
this.readPos += bytesRead
n += bytesWritten
// if we experienced an iconv error, check it
if err != nil {
// E2BIG errors can be ignored (we'll get them often) as long
// as at least 1 byte was written. If we experienced an E2BIG
// and no bytes were written then the buffer is too small for
// even the next character
if err != syscall.E2BIG || bytesWritten == 0 {
// track anything else
this.err = err
}
}
// return our results
return n, this.err
} | go | 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 when we have less data than len(p)
// we should have an appropriate amount of data, convert it into the given buffer
bytesRead, bytesWritten, err := this.converter.Convert(this.buffer[this.readPos:this.writePos], p)
// adjust byte counters
this.readPos += bytesRead
n += bytesWritten
// if we experienced an iconv error, check it
if err != nil {
// E2BIG errors can be ignored (we'll get them often) as long
// as at least 1 byte was written. If we experienced an E2BIG
// and no bytes were written then the buffer is too small for
// even the next character
if err != syscall.E2BIG || bytesWritten == 0 {
// track anything else
this.err = err
}
}
// return our results
return n, this.err
} | [
"func",
"(",
"this",
"*",
"Reader",
")",
"Read",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"// checks for when we have no data",
"for",
"this",
".",
"writePos",
"==",
"0",
"||",
"this",
".",
"readPos",
"==",
"th... | // implement the io.Reader interface | [
"implement",
"the",
"io",
".",
"Reader",
"interface"
] | 8960e66bd3dacbc8773962b40eb82fc18c63c127 | https://github.com/djimenez/iconv-go/blob/8960e66bd3dacbc8773962b40eb82fc18c63c127/reader.go#L65-L100 |
15,054 | djimenez/iconv-go | converter.go | NewConverter | 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, fromEncodingC)
// free the C Strings
C.free(unsafe.Pointer(toEncodingC))
C.free(unsafe.Pointer(fromEncodingC))
// check err
if err == nil {
// no error, mark the context as open
converter.open = true
}
return
} | go | 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, fromEncodingC)
// free the C Strings
C.free(unsafe.Pointer(toEncodingC))
C.free(unsafe.Pointer(fromEncodingC))
// check err
if err == nil {
// no error, mark the context as open
converter.open = true
}
return
} | [
"func",
"NewConverter",
"(",
"fromEncoding",
"string",
",",
"toEncoding",
"string",
")",
"(",
"converter",
"*",
"Converter",
",",
"err",
"error",
")",
"{",
"converter",
"=",
"new",
"(",
"Converter",
")",
"\n\n",
"// convert to C strings",
"toEncodingC",
":=",
... | // Initialize a new Converter. If fromEncoding or toEncoding are not supported by
// iconv then an EINVAL error will be returned. An ENOMEM error maybe returned if
// there is not enough memory to initialize an iconv descriptor | [
"Initialize",
"a",
"new",
"Converter",
".",
"If",
"fromEncoding",
"or",
"toEncoding",
"are",
"not",
"supported",
"by",
"iconv",
"then",
"an",
"EINVAL",
"error",
"will",
"be",
"returned",
".",
"An",
"ENOMEM",
"error",
"maybe",
"returned",
"if",
"there",
"is",... | 8960e66bd3dacbc8773962b40eb82fc18c63c127 | https://github.com/djimenez/iconv-go/blob/8960e66bd3dacbc8773962b40eb82fc18c63c127/converter.go#L29-L50 |
15,055 | djimenez/iconv-go | converter.go | Close | func (this *Converter) Close() (err error) {
if this.open {
_, err = C.iconv_close(this.context)
}
return
} | go | func (this *Converter) Close() (err error) {
if this.open {
_, err = C.iconv_close(this.context)
}
return
} | [
"func",
"(",
"this",
"*",
"Converter",
")",
"Close",
"(",
")",
"(",
"err",
"error",
")",
"{",
"if",
"this",
".",
"open",
"{",
"_",
",",
"err",
"=",
"C",
".",
"iconv_close",
"(",
"this",
".",
"context",
")",
"\n",
"}",
"\n\n",
"return",
"\n",
"}... | // Close a Converter's iconv description explicitly | [
"Close",
"a",
"Converter",
"s",
"iconv",
"description",
"explicitly"
] | 8960e66bd3dacbc8773962b40eb82fc18c63c127 | https://github.com/djimenez/iconv-go/blob/8960e66bd3dacbc8773962b40eb82fc18c63c127/converter.go#L58-L64 |
15,056 | djimenez/iconv-go | converter.go | Convert | 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 of the underlying
// storage of each byte slice - so far this is the simplest
// way i've found to do that in Go, but it seems ugly
inputPointer := (*C.char)(unsafe.Pointer(&input[0]))
outputPointer := (*C.char)(unsafe.Pointer(&output[0]))
_, err = C.call_iconv(this.context, inputPointer, &inputLeft, outputPointer, &outputLeft)
// update byte counters
bytesRead = len(input) - int(inputLeft)
bytesWritten = len(output) - int(outputLeft)
} else if inputLeft == 0 && outputLeft > 0 {
// inputPointer will be nil, outputPointer is generated as above
outputPointer := (*C.char)(unsafe.Pointer(&output[0]))
_, err = C.call_iconv(this.context, nil, &inputLeft, outputPointer, &outputLeft)
// update write byte counter
bytesWritten = len(output) - int(outputLeft)
} else {
// both input and output are zero length, do a shift state reset
_, err = C.call_iconv(this.context, nil, &inputLeft, nil, &outputLeft)
}
} else {
err = syscall.EBADF
}
return bytesRead, bytesWritten, err
} | go | 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 of the underlying
// storage of each byte slice - so far this is the simplest
// way i've found to do that in Go, but it seems ugly
inputPointer := (*C.char)(unsafe.Pointer(&input[0]))
outputPointer := (*C.char)(unsafe.Pointer(&output[0]))
_, err = C.call_iconv(this.context, inputPointer, &inputLeft, outputPointer, &outputLeft)
// update byte counters
bytesRead = len(input) - int(inputLeft)
bytesWritten = len(output) - int(outputLeft)
} else if inputLeft == 0 && outputLeft > 0 {
// inputPointer will be nil, outputPointer is generated as above
outputPointer := (*C.char)(unsafe.Pointer(&output[0]))
_, err = C.call_iconv(this.context, nil, &inputLeft, outputPointer, &outputLeft)
// update write byte counter
bytesWritten = len(output) - int(outputLeft)
} else {
// both input and output are zero length, do a shift state reset
_, err = C.call_iconv(this.context, nil, &inputLeft, nil, &outputLeft)
}
} else {
err = syscall.EBADF
}
return bytesRead, bytesWritten, err
} | [
"func",
"(",
"this",
"*",
"Converter",
")",
"Convert",
"(",
"input",
"[",
"]",
"byte",
",",
"output",
"[",
"]",
"byte",
")",
"(",
"bytesRead",
"int",
",",
"bytesWritten",
"int",
",",
"err",
"error",
")",
"{",
"// make sure we are still open",
"if",
"this... | // Convert bytes from an input byte slice into a give output byte slice
//
// As many bytes that can converted and fit into the size of output will be
// processed and the number of bytes read for input as well as the number of
// bytes written to output will be returned. If not all converted bytes can fit
// into output and E2BIG error will also be returned. If input contains an invalid
// sequence of bytes for the Converter's fromEncoding an EILSEQ error will be returned
//
// For shift based output encodings, any end shift byte sequences can be generated by
// passing a 0 length byte slice as input. Also passing a 0 length byte slice for output
// will simply reset the iconv descriptor shift state without writing any bytes. | [
"Convert",
"bytes",
"from",
"an",
"input",
"byte",
"slice",
"into",
"a",
"give",
"output",
"byte",
"slice",
"As",
"many",
"bytes",
"that",
"can",
"converted",
"and",
"fit",
"into",
"the",
"size",
"of",
"output",
"will",
"be",
"processed",
"and",
"the",
"... | 8960e66bd3dacbc8773962b40eb82fc18c63c127 | https://github.com/djimenez/iconv-go/blob/8960e66bd3dacbc8773962b40eb82fc18c63c127/converter.go#L77-L112 |
15,057 | djimenez/iconv-go | converter.go | ConvertString | 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 input bytes are read or an error occurs
var bytesRead, totalBytesRead, bytesWritten, totalBytesWritten int
for totalBytesRead < len(inputBuffer) && err == nil {
// use the totals to create buffer slices
bytesRead, bytesWritten, err = this.Convert(inputBuffer[totalBytesRead:], outputBuffer[totalBytesWritten:])
totalBytesRead += bytesRead
totalBytesWritten += bytesWritten
// check for the E2BIG error specifically, we can add to the output
// buffer to correct for it and then continue
if err == syscall.E2BIG {
// increase the size of the output buffer by another input length
// first, create a new buffer
tempBuffer := make([]byte, len(outputBuffer)+len(inputBuffer))
// copy the existing data
copy(tempBuffer, outputBuffer)
// switch the buffers
outputBuffer = tempBuffer
// forget the error
err = nil
}
}
if err == nil {
// perform a final shift state reset
_, bytesWritten, err = this.Convert([]byte{}, outputBuffer[totalBytesWritten:])
// update total count
totalBytesWritten += bytesWritten
}
// construct the final output string
output = string(outputBuffer[:totalBytesWritten])
} else {
err = syscall.EBADF
}
return output, err
} | go | 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 input bytes are read or an error occurs
var bytesRead, totalBytesRead, bytesWritten, totalBytesWritten int
for totalBytesRead < len(inputBuffer) && err == nil {
// use the totals to create buffer slices
bytesRead, bytesWritten, err = this.Convert(inputBuffer[totalBytesRead:], outputBuffer[totalBytesWritten:])
totalBytesRead += bytesRead
totalBytesWritten += bytesWritten
// check for the E2BIG error specifically, we can add to the output
// buffer to correct for it and then continue
if err == syscall.E2BIG {
// increase the size of the output buffer by another input length
// first, create a new buffer
tempBuffer := make([]byte, len(outputBuffer)+len(inputBuffer))
// copy the existing data
copy(tempBuffer, outputBuffer)
// switch the buffers
outputBuffer = tempBuffer
// forget the error
err = nil
}
}
if err == nil {
// perform a final shift state reset
_, bytesWritten, err = this.Convert([]byte{}, outputBuffer[totalBytesWritten:])
// update total count
totalBytesWritten += bytesWritten
}
// construct the final output string
output = string(outputBuffer[:totalBytesWritten])
} else {
err = syscall.EBADF
}
return output, err
} | [
"func",
"(",
"this",
"*",
"Converter",
")",
"ConvertString",
"(",
"input",
"string",
")",
"(",
"output",
"string",
",",
"err",
"error",
")",
"{",
"// make sure we are still open",
"if",
"this",
".",
"open",
"{",
"// construct the buffers",
"inputBuffer",
":=",
... | // Convert an input string
//
// EILSEQ error may be returned if input contains invalid bytes for the
// Converter's fromEncoding. | [
"Convert",
"an",
"input",
"string",
"EILSEQ",
"error",
"may",
"be",
"returned",
"if",
"input",
"contains",
"invalid",
"bytes",
"for",
"the",
"Converter",
"s",
"fromEncoding",
"."
] | 8960e66bd3dacbc8773962b40eb82fc18c63c127 | https://github.com/djimenez/iconv-go/blob/8960e66bd3dacbc8773962b40eb82fc18c63c127/converter.go#L118-L168 |
15,058 | djimenez/iconv-go | iconv.go | Convert | 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(input, output)
if err == nil {
var shiftBytesWritten int
// call Convert with a nil input to generate any end shift sequences
_, shiftBytesWritten, err = converter.Convert(nil, output[bytesWritten:])
// add shift bytes to total bytes
bytesWritten += shiftBytesWritten
}
// close the converter
converter.Close()
}
return
} | go | 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(input, output)
if err == nil {
var shiftBytesWritten int
// call Convert with a nil input to generate any end shift sequences
_, shiftBytesWritten, err = converter.Convert(nil, output[bytesWritten:])
// add shift bytes to total bytes
bytesWritten += shiftBytesWritten
}
// close the converter
converter.Close()
}
return
} | [
"func",
"Convert",
"(",
"input",
"[",
"]",
"byte",
",",
"output",
"[",
"]",
"byte",
",",
"fromEncoding",
"string",
",",
"toEncoding",
"string",
")",
"(",
"bytesRead",
"int",
",",
"bytesWritten",
"int",
",",
"err",
"error",
")",
"{",
"// create a temporary ... | // All in one Convert method, rather than requiring the construction of an iconv.Converter | [
"All",
"in",
"one",
"Convert",
"method",
"rather",
"than",
"requiring",
"the",
"construction",
"of",
"an",
"iconv",
".",
"Converter"
] | 8960e66bd3dacbc8773962b40eb82fc18c63c127 | https://github.com/djimenez/iconv-go/blob/8960e66bd3dacbc8773962b40eb82fc18c63c127/iconv.go#L9-L32 |
15,059 | djimenez/iconv-go | iconv.go | ConvertString | 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.Close()
}
return
} | go | 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.Close()
}
return
} | [
"func",
"ConvertString",
"(",
"input",
"string",
",",
"fromEncoding",
"string",
",",
"toEncoding",
"string",
")",
"(",
"output",
"string",
",",
"err",
"error",
")",
"{",
"// create a temporary converter",
"converter",
",",
"err",
":=",
"NewConverter",
"(",
"from... | // All in one ConvertString method, rather than requiring the construction of an iconv.Converter | [
"All",
"in",
"one",
"ConvertString",
"method",
"rather",
"than",
"requiring",
"the",
"construction",
"of",
"an",
"iconv",
".",
"Converter"
] | 8960e66bd3dacbc8773962b40eb82fc18c63c127 | https://github.com/djimenez/iconv-go/blob/8960e66bd3dacbc8773962b40eb82fc18c63c127/iconv.go#L35-L48 |
15,060 | djimenez/iconv-go | writer.go | Write | 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 this.writePos > 0 {
// if we have an error, just return it
if this.err != nil {
return
}
// else empty the buffer
this.emptyBuffer()
}
return n, err
} | go | 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 this.writePos > 0 {
// if we have an error, just return it
if this.err != nil {
return
}
// else empty the buffer
this.emptyBuffer()
}
return n, err
} | [
"func",
"(",
"this",
"*",
"Writer",
")",
"Write",
"(",
"p",
"[",
"]",
"byte",
")",
"(",
"n",
"int",
",",
"err",
"error",
")",
"{",
"// write data into our internal buffer",
"bytesRead",
",",
"bytesWritten",
",",
"err",
":=",
"this",
".",
"converter",
"."... | // implement the io.Writer interface | [
"implement",
"the",
"io",
".",
"Writer",
"interface"
] | 8960e66bd3dacbc8773962b40eb82fc18c63c127 | https://github.com/djimenez/iconv-go/blob/8960e66bd3dacbc8773962b40eb82fc18c63c127/writer.go#L62-L82 |
15,061 | limetext/backend | render/renderer.go | Transform | 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 := v.Regions.Regions()
a.Exit()
a = util.Prof.Enter("render.Transform.(AddAll)")
rs.AddAll(r)
a.Exit()
recipe[k] = rs
}
return recipe
} | go | 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 := v.Regions.Regions()
a.Exit()
a = util.Prof.Enter("render.Transform.(AddAll)")
rs.AddAll(r)
a.Exit()
recipe[k] = rs
}
return recipe
} | [
"func",
"Transform",
"(",
"scheme",
"ColourScheme",
",",
"data",
"ViewRegionMap",
",",
"viewport",
"text",
".",
"Region",
")",
"Recipe",
"{",
"pe",
":=",
"util",
".",
"Prof",
".",
"Enter",
"(",
"\"",
"\"",
")",
"\n",
"defer",
"pe",
".",
"Exit",
"(",
... | // Transform takes a ColourScheme, a ViewRegionMap and a viewport as input.
//
// The viewport would be the text.Region of the current buffer that is visible to the user
// and any ViewRegions outside of this area are not forwarded for further processing.
//
// The remaining ViewRegions are then passed on to the ColourScheme for determining the exact Flavour
// for which that RegionSet should be styled, adding Regions of the same Flavour to the same RegionSet.
//
// Typically there are more ViewRegions available in a text buffer than there are unique Flavours in
// a ColourScheme, so this operation can be viewed as reducing the number of state changes required to
// display the text to the user.
//
// The final output, the Recipe, contains a mapping of all unique Flavours and that Flavour's
// associated RegionSet. | [
"Transform",
"takes",
"a",
"ColourScheme",
"a",
"ViewRegionMap",
"and",
"a",
"viewport",
"as",
"input",
".",
"The",
"viewport",
"would",
"be",
"the",
"text",
".",
"Region",
"of",
"the",
"current",
"buffer",
"that",
"is",
"visible",
"to",
"the",
"user",
"an... | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/render/renderer.go#L68-L86 |
15,062 | limetext/backend | render/renderer.go | Transcribe | 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 | 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
} | [
"func",
"(",
"r",
"Recipe",
")",
"Transcribe",
"(",
")",
"(",
"ret",
"TranscribedRecipe",
")",
"{",
"pe",
":=",
"util",
".",
"Prof",
".",
"Enter",
"(",
"\"",
"\"",
")",
"\n",
"defer",
"pe",
".",
"Exit",
"(",
")",
"\n",
"for",
"flav",
",",
"set",
... | // Transcribing the Recipe creates a linear step-by-step
// representation of it, which might or might not
// make it easier for Renderers to work with. | [
"Transcribing",
"the",
"Recipe",
"creates",
"a",
"linear",
"step",
"-",
"by",
"-",
"step",
"representation",
"of",
"it",
"which",
"might",
"or",
"might",
"not",
"make",
"it",
"easier",
"for",
"Renderers",
"to",
"work",
"with",
"."
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/render/renderer.go#L91-L101 |
15,063 | limetext/backend | edit.go | String | func (e *Edit) String() string {
return fmt.Sprintf("%s: %v, %v, %v", e.command, e.args, e.bypassUndo, e.composite)
} | go | func (e *Edit) String() string {
return fmt.Sprintf("%s: %v, %v, %v", e.command, e.args, e.bypassUndo, e.composite)
} | [
"func",
"(",
"e",
"*",
"Edit",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"e",
".",
"command",
",",
"e",
".",
"args",
",",
"e",
".",
"bypassUndo",
",",
"e",
".",
"composite",
")",
"\n",
"}"
] | // Returns a string describing this Edit object. Should typically not be manually called. | [
"Returns",
"a",
"string",
"describing",
"this",
"Edit",
"object",
".",
"Should",
"typically",
"not",
"be",
"manually",
"called",
"."
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/edit.go#L43-L45 |
15,064 | limetext/backend | edit.go | Undo | func (e *Edit) Undo() {
e.composite.Undo()
e.v.Sel().Clear()
for _, r := range e.savedSel.Regions() {
e.v.Sel().Add(r)
}
} | go | func (e *Edit) Undo() {
e.composite.Undo()
e.v.Sel().Clear()
for _, r := range e.savedSel.Regions() {
e.v.Sel().Add(r)
}
} | [
"func",
"(",
"e",
"*",
"Edit",
")",
"Undo",
"(",
")",
"{",
"e",
".",
"composite",
".",
"Undo",
"(",
")",
"\n",
"e",
".",
"v",
".",
"Sel",
"(",
")",
".",
"Clear",
"(",
")",
"\n",
"for",
"_",
",",
"r",
":=",
"range",
"e",
".",
"savedSel",
"... | // Reverses the application of this Edit object. Should typically not be manually called. | [
"Reverses",
"the",
"application",
"of",
"this",
"Edit",
"object",
".",
"Should",
"typically",
"not",
"be",
"manually",
"called",
"."
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/edit.go#L53-L59 |
15,065 | limetext/backend | keys/keybinding.go | Less | func (k *KeyBindings) Less(i, j int) bool {
return k.Bindings[i].Keys[k.seqIndex].Index() < k.Bindings[j].Keys[k.seqIndex].Index()
} | go | func (k *KeyBindings) Less(i, j int) bool {
return k.Bindings[i].Keys[k.seqIndex].Index() < k.Bindings[j].Keys[k.seqIndex].Index()
} | [
"func",
"(",
"k",
"*",
"KeyBindings",
")",
"Less",
"(",
"i",
",",
"j",
"int",
")",
"bool",
"{",
"return",
"k",
".",
"Bindings",
"[",
"i",
"]",
".",
"Keys",
"[",
"k",
".",
"seqIndex",
"]",
".",
"Index",
"(",
")",
"<",
"k",
".",
"Bindings",
"["... | // Compares one KeyBinding to another for sorting purposes. | [
"Compares",
"one",
"KeyBinding",
"to",
"another",
"for",
"sorting",
"purposes",
"."
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/keys/keybinding.go#L56-L58 |
15,066 | limetext/backend | keys/keybinding.go | Swap | func (k *KeyBindings) Swap(i, j int) {
k.Bindings[i], k.Bindings[j] = k.Bindings[j], k.Bindings[i]
} | go | func (k *KeyBindings) Swap(i, j int) {
k.Bindings[i], k.Bindings[j] = k.Bindings[j], k.Bindings[i]
} | [
"func",
"(",
"k",
"*",
"KeyBindings",
")",
"Swap",
"(",
"i",
",",
"j",
"int",
")",
"{",
"k",
".",
"Bindings",
"[",
"i",
"]",
",",
"k",
".",
"Bindings",
"[",
"j",
"]",
"=",
"k",
".",
"Bindings",
"[",
"j",
"]",
",",
"k",
".",
"Bindings",
"[",... | // Swaps the two KeyBindings at the given positions. | [
"Swaps",
"the",
"two",
"KeyBindings",
"at",
"the",
"given",
"positions",
"."
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/keys/keybinding.go#L61-L63 |
15,067 | limetext/backend | keys/keybinding.go | DropLessEqualKeys | 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 = k.parent.KeyBindings()
}
} | go | 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 = k.parent.KeyBindings()
}
} | [
"func",
"(",
"k",
"*",
"KeyBindings",
")",
"DropLessEqualKeys",
"(",
"count",
"int",
")",
"{",
"for",
"{",
"for",
"i",
":=",
"0",
";",
"i",
"<",
"len",
"(",
"k",
".",
"Bindings",
")",
";",
"{",
"if",
"len",
"(",
"k",
".",
"Bindings",
"[",
"i",
... | // Drops all KeyBindings that are a sequence of key presses less or equal
// to the given number. | [
"Drops",
"all",
"KeyBindings",
"that",
"are",
"a",
"sequence",
"of",
"key",
"presses",
"less",
"or",
"equal",
"to",
"the",
"given",
"number",
"."
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/keys/keybinding.go#L67-L83 |
15,068 | limetext/backend | keys/keybinding.go | Filter | 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 | 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
} | [
"func",
"(",
"k",
"*",
"KeyBindings",
")",
"Filter",
"(",
"kp",
"KeyPress",
")",
"(",
"ret",
"KeyBindings",
")",
"{",
"p",
":=",
"Prof",
".",
"Enter",
"(",
"\"",
"\"",
")",
"\n",
"defer",
"p",
".",
"Exit",
"(",
")",
"\n\n",
"kp",
".",
"fix",
"(... | // Filters the KeyBindings, returning a new KeyBindings object containing
// a subset of matches for the given key press. | [
"Filters",
"the",
"KeyBindings",
"returning",
"a",
"new",
"KeyBindings",
"object",
"containing",
"a",
"subset",
"of",
"matches",
"for",
"the",
"given",
"key",
"press",
"."
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/keys/keybinding.go#L127-L142 |
15,069 | limetext/backend | keys/keybinding.go | Action | 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 currently
// probed for. For example, the binding is for the sequence ['a','b','c'], but
// the user has only pressed ['a','b'] so far.
continue
}
for _, c := range k.Bindings[i].Context {
if !qc(c.Key, c.Operator, c.Operand, c.MatchAll) {
goto skip
}
}
if kb == nil || kb.priority < k.Bindings[i].priority {
kb = k.Bindings[i]
}
skip:
}
if kb != nil || k.parent == nil {
break
}
k = k.parent.KeyBindings()
}
return
} | go | 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 currently
// probed for. For example, the binding is for the sequence ['a','b','c'], but
// the user has only pressed ['a','b'] so far.
continue
}
for _, c := range k.Bindings[i].Context {
if !qc(c.Key, c.Operator, c.Operand, c.MatchAll) {
goto skip
}
}
if kb == nil || kb.priority < k.Bindings[i].priority {
kb = k.Bindings[i]
}
skip:
}
if kb != nil || k.parent == nil {
break
}
k = k.parent.KeyBindings()
}
return
} | [
"func",
"(",
"k",
"*",
"KeyBindings",
")",
"Action",
"(",
"qc",
"func",
"(",
"key",
"string",
",",
"operator",
"Op",
",",
"operand",
"interface",
"{",
"}",
",",
"match_all",
"bool",
")",
"bool",
")",
"(",
"kb",
"*",
"KeyBinding",
")",
"{",
"p",
":=... | // Tries to resolve all the current KeyBindings in k to a single
// action. If any action is appropriate as determined by context,
// the return value will be the specific KeyBinding that is possible
// to execute now, otherwise it is nil. | [
"Tries",
"to",
"resolve",
"all",
"the",
"current",
"KeyBindings",
"in",
"k",
"to",
"a",
"single",
"action",
".",
"If",
"any",
"action",
"is",
"appropriate",
"as",
"determined",
"by",
"context",
"the",
"return",
"value",
"will",
"be",
"the",
"specific",
"Ke... | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/keys/keybinding.go#L148-L176 |
15,070 | limetext/backend | keys/keypress.go | IsCharacter | func (k KeyPress) IsCharacter() bool {
return unicode.IsPrint(rune(k.Key)) && !k.Super && !k.Ctrl
} | go | func (k KeyPress) IsCharacter() bool {
return unicode.IsPrint(rune(k.Key)) && !k.Super && !k.Ctrl
} | [
"func",
"(",
"k",
"KeyPress",
")",
"IsCharacter",
"(",
")",
"bool",
"{",
"return",
"unicode",
".",
"IsPrint",
"(",
"rune",
"(",
"k",
".",
"Key",
")",
")",
"&&",
"!",
"k",
".",
"Super",
"&&",
"!",
"k",
".",
"Ctrl",
"\n",
"}"
] | // Returns whether this KeyPress is a print character or not. | [
"Returns",
"whether",
"this",
"KeyPress",
"is",
"a",
"print",
"character",
"or",
"not",
"."
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/keys/keypress.go#L45-L47 |
15,071 | limetext/backend | keys/keypress.go | fix | func (k *KeyPress) fix() {
lower := Key(unicode.ToLower(rune(k.Key)))
if lower != k.Key {
k.Shift = true
k.Key = lower
}
} | go | func (k *KeyPress) fix() {
lower := Key(unicode.ToLower(rune(k.Key)))
if lower != k.Key {
k.Shift = true
k.Key = lower
}
} | [
"func",
"(",
"k",
"*",
"KeyPress",
")",
"fix",
"(",
")",
"{",
"lower",
":=",
"Key",
"(",
"unicode",
".",
"ToLower",
"(",
"rune",
"(",
"k",
".",
"Key",
")",
")",
")",
"\n",
"if",
"lower",
"!=",
"k",
".",
"Key",
"{",
"k",
".",
"Shift",
"=",
"... | // Modifies the KeyPress so that it's Key is a unicode lower case
// rune and if it was in uppercase before this modification, the
// "Shift" modifier is also enabled. | [
"Modifies",
"the",
"KeyPress",
"so",
"that",
"it",
"s",
"Key",
"is",
"a",
"unicode",
"lower",
"case",
"rune",
"and",
"if",
"it",
"was",
"in",
"uppercase",
"before",
"this",
"modification",
"the",
"Shift",
"modifier",
"is",
"also",
"enabled",
"."
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/keys/keypress.go#L52-L58 |
15,072 | limetext/backend | packages/json.go | LoadJSON | func LoadJSON(path string, marshal json.Unmarshaler) error {
j := NewJSON(path, marshal)
watch(j)
j.Load()
return j.err
} | go | func LoadJSON(path string, marshal json.Unmarshaler) error {
j := NewJSON(path, marshal)
watch(j)
j.Load()
return j.err
} | [
"func",
"LoadJSON",
"(",
"path",
"string",
",",
"marshal",
"json",
".",
"Unmarshaler",
")",
"error",
"{",
"j",
":=",
"NewJSON",
"(",
"path",
",",
"marshal",
")",
"\n",
"watch",
"(",
"j",
")",
"\n",
"j",
".",
"Load",
"(",
")",
"\n",
"return",
"j",
... | // Won't return the json type itself just watch & load | [
"Won",
"t",
"return",
"the",
"json",
"type",
"itself",
"just",
"watch",
"&",
"load"
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/packages/json.go#L28-L33 |
15,073 | limetext/backend | view.go | reparse | 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 | 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}
}
} | [
"func",
"(",
"v",
"*",
"View",
")",
"reparse",
"(",
"forced",
"bool",
")",
"{",
"if",
"v",
".",
"isClosed",
"(",
")",
"{",
"// No point in issuing a re-parse if the view has been closed",
"return",
"\n",
"}",
"\n",
"if",
"len",
"(",
"v",
".",
"reparseChan",
... | // Send a reparse request via the reparse channel.
// If "forced" is set to true, then a reparse will be made
// even if the Buffer appears to not have changed.
//
// The actual parsing is done in a separate go-routine, for which the
// "lime.syntax.updated" setting will be set once it has finished.
//
// Note that it's presumed that the function calling this function
// has locked the view! | [
"Send",
"a",
"reparse",
"request",
"via",
"the",
"reparse",
"channel",
".",
"If",
"forced",
"is",
"set",
"to",
"true",
"then",
"a",
"reparse",
"will",
"be",
"made",
"even",
"if",
"the",
"Buffer",
"appears",
"to",
"not",
"have",
"changed",
".",
"The",
"... | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/view.go#L236-L244 |
15,074 | limetext/backend | view.go | Erase | func (v *View) Erase(edit *Edit, r text.Region) {
edit.composite.AddExec(text.NewEraseAction(v.buffer, r))
} | go | func (v *View) Erase(edit *Edit, r text.Region) {
edit.composite.AddExec(text.NewEraseAction(v.buffer, r))
} | [
"func",
"(",
"v",
"*",
"View",
")",
"Erase",
"(",
"edit",
"*",
"Edit",
",",
"r",
"text",
".",
"Region",
")",
"{",
"edit",
".",
"composite",
".",
"AddExec",
"(",
"text",
".",
"NewEraseAction",
"(",
"v",
".",
"buffer",
",",
"r",
")",
")",
"\n",
"... | // Adds an Erase action of the given Region to the provided Edit object. | [
"Adds",
"an",
"Erase",
"action",
"of",
"the",
"given",
"Region",
"to",
"the",
"provided",
"Edit",
"object",
"."
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/view.go#L378-L380 |
15,075 | limetext/backend | view.go | Replace | func (v *View) Replace(edit *Edit, r text.Region, value string) {
edit.composite.AddExec(text.NewReplaceAction(v.buffer, r, value))
} | go | func (v *View) Replace(edit *Edit, r text.Region, value string) {
edit.composite.AddExec(text.NewReplaceAction(v.buffer, r, value))
} | [
"func",
"(",
"v",
"*",
"View",
")",
"Replace",
"(",
"edit",
"*",
"Edit",
",",
"r",
"text",
".",
"Region",
",",
"value",
"string",
")",
"{",
"edit",
".",
"composite",
".",
"AddExec",
"(",
"text",
".",
"NewReplaceAction",
"(",
"v",
".",
"buffer",
","... | // Adds a Replace action of the given Region to the provided Edit object. | [
"Adds",
"a",
"Replace",
"action",
"of",
"the",
"given",
"Region",
"to",
"the",
"provided",
"Edit",
"object",
"."
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/view.go#L383-L385 |
15,076 | limetext/backend | view.go | EndEdit | 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, commands, etc are well-behaved the ended edit should be
// last in the stack, but shit happens and we cannot count on this being the case.
i := len(v.editstack) - 1
for i := len(v.editstack) - 1; i >= 0; i-- {
if v.editstack[i] == edit {
break
}
}
if i == -1 {
// TODO(.): Under what instances does this happen again?
log.Error("This edit isn't even in the stack... where did it come from? %v, %v", edit, v.editstack)
return
}
var selection_modified bool
if l := len(v.editstack) - 1; i != l {
// TODO(.): See TODO in BeginEdit
log.Error("This edit wasn't last in the stack... %d != %d: %v, %v", i, l, edit, v.editstack)
}
// Invalidate all Edits "below" and including this Edit.
for j := len(v.editstack) - 1; j >= i; j-- {
current_edit := v.editstack[j]
current_edit.invalid = true
sel_same := reflect.DeepEqual(*v.Sel(), current_edit.savedSel)
buf_same := v.ChangeCount() == current_edit.savedCount
eq := (sel_same && buf_same && current_edit.composite.Len() == 0)
if !eq && !sel_same {
selection_modified = true
}
if v.IsScratch() || current_edit.bypassUndo || eq {
continue
}
switch {
case i == 0:
// Well-behaved, no nested edits!
fallthrough
case j != i:
// BOO! Someone began another Edit without finishing the first one.
// In this instance, the parent Edit ended before the child.
// TODO(.): What would be the correct way to handle this?
v.undoStack.Add(edit)
default:
// BOO! Also poorly-behaved. This Edit object began after the parent began,
// but was finished before the parent finished.
//
// Add it as a child of the parent Edit so that undoing the parent
// will undo this edit as well.
v.editstack[i-1].composite.Add(current_edit)
}
}
// Pop this Edit and all the children off the Edit stack.
v.editstack = v.editstack[:i]
if selection_modified {
OnSelectionModified.Call(v)
}
} | go | 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, commands, etc are well-behaved the ended edit should be
// last in the stack, but shit happens and we cannot count on this being the case.
i := len(v.editstack) - 1
for i := len(v.editstack) - 1; i >= 0; i-- {
if v.editstack[i] == edit {
break
}
}
if i == -1 {
// TODO(.): Under what instances does this happen again?
log.Error("This edit isn't even in the stack... where did it come from? %v, %v", edit, v.editstack)
return
}
var selection_modified bool
if l := len(v.editstack) - 1; i != l {
// TODO(.): See TODO in BeginEdit
log.Error("This edit wasn't last in the stack... %d != %d: %v, %v", i, l, edit, v.editstack)
}
// Invalidate all Edits "below" and including this Edit.
for j := len(v.editstack) - 1; j >= i; j-- {
current_edit := v.editstack[j]
current_edit.invalid = true
sel_same := reflect.DeepEqual(*v.Sel(), current_edit.savedSel)
buf_same := v.ChangeCount() == current_edit.savedCount
eq := (sel_same && buf_same && current_edit.composite.Len() == 0)
if !eq && !sel_same {
selection_modified = true
}
if v.IsScratch() || current_edit.bypassUndo || eq {
continue
}
switch {
case i == 0:
// Well-behaved, no nested edits!
fallthrough
case j != i:
// BOO! Someone began another Edit without finishing the first one.
// In this instance, the parent Edit ended before the child.
// TODO(.): What would be the correct way to handle this?
v.undoStack.Add(edit)
default:
// BOO! Also poorly-behaved. This Edit object began after the parent began,
// but was finished before the parent finished.
//
// Add it as a child of the parent Edit so that undoing the parent
// will undo this edit as well.
v.editstack[i-1].composite.Add(current_edit)
}
}
// Pop this Edit and all the children off the Edit stack.
v.editstack = v.editstack[:i]
if selection_modified {
OnSelectionModified.Call(v)
}
} | [
"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",
"(",
"\"",
"\"",
",",
"edit",
",",
"v... | // Ends the given Edit object. | [
"Ends",
"the",
"given",
"Edit",
"object",
"."
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/view.go#L401-L466 |
15,077 | limetext/backend | view.go | IsDirty | 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 | func (v *View) IsDirty() bool {
if v.IsScratch() {
return false
}
lastSave := v.Settings().Int("lime.last_save_change_count", -1)
return v.ChangeCount() != lastSave
} | [
"func",
"(",
"v",
"*",
"View",
")",
"IsDirty",
"(",
")",
"bool",
"{",
"if",
"v",
".",
"IsScratch",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"lastSave",
":=",
"v",
".",
"Settings",
"(",
")",
".",
"Int",
"(",
"\"",
"\"",
",",
"-",
"1"... | // Returns whether the underlying Buffer has any unsaved modifications.
// Note that Scratch buffers are never considered dirty. | [
"Returns",
"whether",
"the",
"underlying",
"Buffer",
"has",
"any",
"unsaved",
"modifications",
".",
"Note",
"that",
"Scratch",
"buffers",
"are",
"never",
"considered",
"dirty",
"."
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/view.go#L502-L508 |
15,078 | limetext/backend | view.go | SaveAs | 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 {
return err
}
} else {
n, err := ioutil.TempDir(path.Dir(v.FileName()), "lime")
if err != nil {
return err
}
tmpf := path.Join(n, "tmp")
if err := v.nonAtomicSave(tmpf); err != nil {
return err
}
if err := os.Rename(tmpf, name); err != nil {
// When we want to save as a file in another directory
// we can't go with os.Rename so we need to force
// not atomic saving sometimes as 4th test in TestSaveAsOpenFile
if err := v.nonAtomicSave(name); err != nil {
return err
}
}
if err := os.RemoveAll(n); err != nil {
return err
}
}
ed := GetEditor()
if fn := v.FileName(); fn != name {
v.SetFileName(name)
if fn != "" {
ed.UnWatch(fn, v)
}
ed.Watch(name, v)
}
v.Settings().Set("lime.last_save_change_count", v.ChangeCount())
OnPostSave.Call(v)
return nil
} | go | 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 {
return err
}
} else {
n, err := ioutil.TempDir(path.Dir(v.FileName()), "lime")
if err != nil {
return err
}
tmpf := path.Join(n, "tmp")
if err := v.nonAtomicSave(tmpf); err != nil {
return err
}
if err := os.Rename(tmpf, name); err != nil {
// When we want to save as a file in another directory
// we can't go with os.Rename so we need to force
// not atomic saving sometimes as 4th test in TestSaveAsOpenFile
if err := v.nonAtomicSave(name); err != nil {
return err
}
}
if err := os.RemoveAll(n); err != nil {
return err
}
}
ed := GetEditor()
if fn := v.FileName(); fn != name {
v.SetFileName(name)
if fn != "" {
ed.UnWatch(fn, v)
}
ed.Watch(name, v)
}
v.Settings().Set("lime.last_save_change_count", v.ChangeCount())
OnPostSave.Call(v)
return nil
} | [
"func",
"(",
"v",
"*",
"View",
")",
"SaveAs",
"(",
"name",
"string",
")",
"(",
"err",
"error",
")",
"{",
"log",
".",
"Fine",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"v",
".",
"Settings",
"(",
")",
".",
"Set",
"(",
"\"",
"\"",
",",
"true",
... | // Saves the file to the specified filename | [
"Saves",
"the",
"file",
"to",
"the",
"specified",
"filename"
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/view.go#L537-L580 |
15,079 | limetext/backend | view.go | AddRegions | 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 | 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
} | [
"func",
"(",
"v",
"*",
"View",
")",
"AddRegions",
"(",
"key",
"string",
",",
"regions",
"[",
"]",
"text",
".",
"Region",
",",
"scope",
",",
"icon",
"string",
",",
"flags",
"render",
".",
"ViewRegionFlags",
")",
"{",
"vr",
":=",
"render",
".",
"ViewRe... | // AddRegions lets users mark text regions in a view with a scope name, gutter icon and ViewRegionflags
// which are then optionally used to alter the display of those regions.
//
// Typical uses would be to draw squiggly lines under misspelled words, show an icon in the gutter to
// indicate a breakpoint, keeping track of snippet or auto-completion fields, highlight code compilation
// warnings, etc.
//
// The regions will be automatically adjusted as appropriate when the underlying buffer is changed. | [
"AddRegions",
"lets",
"users",
"mark",
"text",
"regions",
"in",
"a",
"view",
"with",
"a",
"scope",
"name",
"gutter",
"icon",
"and",
"ViewRegionflags",
"which",
"are",
"then",
"optionally",
"used",
"to",
"alter",
"the",
"display",
"of",
"those",
"regions",
".... | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/view.go#L629-L636 |
15,080 | limetext/backend | view.go | GetRegions | 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 | 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
} | [
"func",
"(",
"v",
"*",
"View",
")",
"GetRegions",
"(",
"key",
"string",
")",
"(",
"ret",
"[",
"]",
"text",
".",
"Region",
")",
"{",
"v",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"v",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"vr",... | // Returns the Regions associated with the given key. | [
"Returns",
"the",
"Regions",
"associated",
"with",
"the",
"given",
"key",
"."
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/view.go#L639-L647 |
15,081 | limetext/backend | view.go | EraseRegions | func (v *View) EraseRegions(key string) {
v.lock.Lock()
defer v.lock.Unlock()
delete(v.regions, key)
} | go | func (v *View) EraseRegions(key string) {
v.lock.Lock()
defer v.lock.Unlock()
delete(v.regions, key)
} | [
"func",
"(",
"v",
"*",
"View",
")",
"EraseRegions",
"(",
"key",
"string",
")",
"{",
"v",
".",
"lock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"v",
".",
"lock",
".",
"Unlock",
"(",
")",
"\n",
"delete",
"(",
"v",
".",
"regions",
",",
"key",
")",
... | // Removes the Regions associated with the given key from the view. | [
"Removes",
"the",
"Regions",
"associated",
"with",
"the",
"given",
"key",
"from",
"the",
"view",
"."
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/view.go#L650-L654 |
15,082 | limetext/backend | view.go | Close | 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 first while there's still access possible to the underlying
// buffer
OnClose.Call(v)
v.window.remove(v)
// Closing the reparseChan, and setting to nil will eventually clean up other resources
// when the parseThread exits
v.lock.Lock()
defer v.lock.Unlock()
close(v.reparseChan)
v.reparseChan = nil
return true
} | go | 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 first while there's still access possible to the underlying
// buffer
OnClose.Call(v)
v.window.remove(v)
// Closing the reparseChan, and setting to nil will eventually clean up other resources
// when the parseThread exits
v.lock.Lock()
defer v.lock.Unlock()
close(v.reparseChan)
v.reparseChan = nil
return true
} | [
"func",
"(",
"v",
"*",
"View",
")",
"Close",
"(",
")",
"bool",
"{",
"OnPreClose",
".",
"Call",
"(",
"v",
")",
"\n",
"if",
"v",
".",
"IsDirty",
"(",
")",
"{",
"close_anyway",
":=",
"GetEditor",
"(",
")",
".",
"Frontend",
"(",
")",
".",
"OkCancelDi... | // Initiate the "close" operation of this view.
// Returns "true" if the view was closed. Otherwise returns "false". | [
"Initiate",
"the",
"close",
"operation",
"of",
"this",
"view",
".",
"Returns",
"true",
"if",
"the",
"view",
"was",
"closed",
".",
"Otherwise",
"returns",
"false",
"."
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/view.go#L701-L727 |
15,083 | limetext/backend | view.go | FindByClass | 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 {
return p
}
}
} | go | 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 {
return p
}
}
} | [
"func",
"(",
"v",
"*",
"View",
")",
"FindByClass",
"(",
"point",
"int",
",",
"forward",
"bool",
",",
"classes",
"int",
")",
"int",
"{",
"i",
":=",
"-",
"1",
"\n",
"if",
"forward",
"{",
"i",
"=",
"1",
"\n",
"}",
"\n",
"size",
":=",
"v",
".",
"... | // Finds the next location after point that matches the given classes
// Searches backward if forward is false | [
"Finds",
"the",
"next",
"location",
"after",
"point",
"that",
"matches",
"the",
"given",
"classes",
"Searches",
"backward",
"if",
"forward",
"is",
"false"
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/view.go#L880-L898 |
15,084 | limetext/backend | view.go | ExpandByClass | 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
} else if b > size {
b = size
}
for ; a > 0 && (v.Classify(a)&classes == 0); a -= 1 {
}
for ; b < size && (v.Classify(b)&classes == 0); b += 1 {
}
return text.Region{a, b}
} | go | 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
} else if b > size {
b = size
}
for ; a > 0 && (v.Classify(a)&classes == 0); a -= 1 {
}
for ; b < size && (v.Classify(b)&classes == 0); b += 1 {
}
return text.Region{a, b}
} | [
"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... | // Expands the selection until the point on each side matches the given classes | [
"Expands",
"the",
"selection",
"until",
"the",
"point",
"on",
"each",
"side",
"matches",
"the",
"given",
"classes"
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/view.go#L901-L924 |
15,085 | limetext/backend | commandhandler.go | init | 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.PascalCaseToSnakeCase(ft.Name)
fv, ok := args[key]
if !ok {
fv = reflect.Zero(ft.Type).Interface()
if def, ok := cmd.(CustomDefault); ok {
if val := def.Default(key); val != nil {
fv = val
}
}
}
if f.CanAddr() {
if f2, ok := f.Addr().Interface().(CustomSet); ok {
if err := f2.Set(fv); err != nil {
return err
}
continue
}
}
rv := reflect.ValueOf(fv)
rvtype := rv.Type()
ftype := f.Type()
if !rvtype.AssignableTo(ftype) {
if rvtype.ConvertibleTo(ftype) {
rv = rv.Convert(ftype)
} else {
return fmt.Errorf("Command %v arg %v of type %v not assignable or convertable to %v of type %v", t, rv, rvtype, ft.Name, ftype)
}
}
f.Set(rv)
}
return nil
} | go | 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.PascalCaseToSnakeCase(ft.Name)
fv, ok := args[key]
if !ok {
fv = reflect.Zero(ft.Type).Interface()
if def, ok := cmd.(CustomDefault); ok {
if val := def.Default(key); val != nil {
fv = val
}
}
}
if f.CanAddr() {
if f2, ok := f.Addr().Interface().(CustomSet); ok {
if err := f2.Set(fv); err != nil {
return err
}
continue
}
}
rv := reflect.ValueOf(fv)
rvtype := rv.Type()
ftype := f.Type()
if !rvtype.AssignableTo(ftype) {
if rvtype.ConvertibleTo(ftype) {
rv = rv.Convert(ftype)
} else {
return fmt.Errorf("Command %v arg %v of type %v not assignable or convertable to %v of type %v", t, rv, rvtype, ft.Name, ftype)
}
}
f.Set(rv)
}
return nil
} | [
"func",
"(",
"ch",
"*",
"commandHandler",
")",
"init",
"(",
"cmd",
"interface",
"{",
"}",
",",
"args",
"Args",
")",
"error",
"{",
"if",
"in",
",",
"ok",
":=",
"cmd",
".",
"(",
"CustomInit",
")",
";",
"ok",
"{",
"return",
"in",
".",
"Init",
"(",
... | // If the cmd implements the CustomInit interface, its Init function
// is called, otherwise the fields of the cmd's underlying struct type
// will be enumerated and match against the dictionary keys in args,
// or if the key isn't provided in args, the Zero value will be used. | [
"If",
"the",
"cmd",
"implements",
"the",
"CustomInit",
"interface",
"its",
"Init",
"function",
"is",
"called",
"otherwise",
"the",
"fields",
"of",
"the",
"cmd",
"s",
"underlying",
"struct",
"type",
"will",
"be",
"enumerated",
"and",
"match",
"against",
"the",
... | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/commandhandler.go#L49-L92 |
15,086 | limetext/backend | window.go | Close | func (w *Window) Close() bool {
if !w.CloseAllViews() {
return false
}
GetEditor().remove(w)
return true
} | go | func (w *Window) Close() bool {
if !w.CloseAllViews() {
return false
}
GetEditor().remove(w)
return true
} | [
"func",
"(",
"w",
"*",
"Window",
")",
"Close",
"(",
")",
"bool",
"{",
"if",
"!",
"w",
".",
"CloseAllViews",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"GetEditor",
"(",
")",
".",
"remove",
"(",
"w",
")",
"\n\n",
"return",
"true",
"\n",
... | // Closes the Window and all its Views.
// Returns "true" if the Window closed successfully. Otherwise returns "false". | [
"Closes",
"the",
"Window",
"and",
"all",
"its",
"Views",
".",
"Returns",
"true",
"if",
"the",
"Window",
"closed",
"successfully",
".",
"Otherwise",
"returns",
"false",
"."
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/window.go#L116-L123 |
15,087 | limetext/backend | window.go | CloseAllViews | func (w *Window) CloseAllViews() bool {
for len(w.views) > 0 {
if !w.views[0].Close() {
return false
}
}
return true
} | go | func (w *Window) CloseAllViews() bool {
for len(w.views) > 0 {
if !w.views[0].Close() {
return false
}
}
return true
} | [
"func",
"(",
"w",
"*",
"Window",
")",
"CloseAllViews",
"(",
")",
"bool",
"{",
"for",
"len",
"(",
"w",
".",
"views",
")",
">",
"0",
"{",
"if",
"!",
"w",
".",
"views",
"[",
"0",
"]",
".",
"Close",
"(",
")",
"{",
"return",
"false",
"\n",
"}",
... | // Closes all of the Window's Views.
// Returns "true" if all the Views closed successfully. Otherwise returns "false". | [
"Closes",
"all",
"of",
"the",
"Window",
"s",
"Views",
".",
"Returns",
"true",
"if",
"all",
"the",
"Views",
"closed",
"successfully",
".",
"Otherwise",
"returns",
"false",
"."
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/window.go#L127-L135 |
15,088 | limetext/backend | project.go | SaveAs | 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(abs)
}
return nil
} | go | 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(abs)
}
return nil
} | [
"func",
"(",
"p",
"*",
"Project",
")",
"SaveAs",
"(",
"name",
"string",
")",
"error",
"{",
"log",
".",
"Fine",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"if",
"data",
",",
"err",
":=",
"json",
".",
"Marshal",
"(",
"p",
")",
";",
"err",
"!=",
"... | // Marshals project struct to json then writes it to a file with given name | [
"Marshals",
"project",
"struct",
"to",
"json",
"then",
"writes",
"it",
"to",
"a",
"file",
"with",
"given",
"name"
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/project.go#L53-L66 |
15,089 | limetext/backend | events.go | call | func (ie *InitEvent) call() {
log.Debug("OnInit callbacks executing")
defer log.Debug("OnInit callbacks finished")
for _, ev := range *ie {
ev()
}
} | go | func (ie *InitEvent) call() {
log.Debug("OnInit callbacks executing")
defer log.Debug("OnInit callbacks finished")
for _, ev := range *ie {
ev()
}
} | [
"func",
"(",
"ie",
"*",
"InitEvent",
")",
"call",
"(",
")",
"{",
"log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"defer",
"log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"for",
"_",
",",
"ev",
":=",
"range",
"*",
"ie",
"{",
"ev",
"(",
")"... | // Execute the InitEvent. | [
"Execute",
"the",
"InitEvent",
"."
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/events.go#L79-L85 |
15,090 | limetext/backend | watch/watcher.go | flushDir | 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 | 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)
}
}
}
} | [
"func",
"(",
"w",
"*",
"Watcher",
")",
"flushDir",
"(",
"name",
"string",
")",
"{",
"log",
".",
"Finest",
"(",
"\"",
"\"",
",",
"name",
")",
"\n",
"w",
".",
"dirs",
"=",
"append",
"(",
"w",
".",
"dirs",
",",
"name",
")",
"\n",
"for",
"_",
","... | // Remove watchers created on files under this directory because
// one watcher on the parent directory is enough for all of them | [
"Remove",
"watchers",
"created",
"on",
"files",
"under",
"this",
"directory",
"because",
"one",
"watcher",
"on",
"the",
"parent",
"directory",
"is",
"enough",
"for",
"all",
"of",
"them"
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/watch/watcher.go#L152-L162 |
15,091 | limetext/backend | watch/watcher.go | removeDir | 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 = util.Remove(w.dirs, name)
} | go | 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 = util.Remove(w.dirs, name)
} | [
"func",
"(",
"w",
"*",
"Watcher",
")",
"removeDir",
"(",
"name",
"string",
")",
"{",
"for",
"p",
",",
"_",
":=",
"range",
"w",
".",
"watched",
"{",
"if",
"filepath",
".",
"Dir",
"(",
"p",
")",
"==",
"name",
"{",
"stat",
",",
"err",
":=",
"os",
... | // Put back watchers on watching files under the directory | [
"Put",
"back",
"watchers",
"on",
"watching",
"files",
"under",
"the",
"directory"
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/watch/watcher.go#L215-L229 |
15,092 | limetext/backend | watch/watcher.go | observe | 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 | 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)
}
}
} | [
"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",
... | // Observe dispatches notifications received by the watcher. This function will
// return when the watcher is closed. | [
"Observe",
"dispatches",
"notifications",
"received",
"by",
"the",
"watcher",
".",
"This",
"function",
"will",
"return",
"when",
"the",
"watcher",
"is",
"closed",
"."
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/watch/watcher.go#L233-L249 |
15,093 | limetext/backend | undo.go | Redo | 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 | 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++
}
} | [
"func",
"(",
"us",
"*",
"UndoStack",
")",
"Redo",
"(",
"hard",
"bool",
")",
"{",
"if",
"us",
".",
"position",
">=",
"len",
"(",
"us",
".",
"actions",
")",
"{",
"// No more actions to redo",
"return",
"\n",
"}",
"\n",
"to",
":=",
"us",
".",
"index",
... | // Re-applies the next action in the undo stack
// if there are any actions on the stack that had
// been undone.
//
// See comment in Undo regarding the use of "hard". | [
"Re",
"-",
"applies",
"the",
"next",
"action",
"in",
"the",
"undo",
"stack",
"if",
"there",
"are",
"any",
"actions",
"on",
"the",
"stack",
"that",
"had",
"been",
"undone",
".",
"See",
"comment",
"in",
"Undo",
"regarding",
"the",
"use",
"of",
"hard",
".... | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/undo.go#L84-L97 |
15,094 | limetext/backend | undo.go | GlueFrom | 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 {
a := us.actions[i+mark]
entries[i].name = a.command
entries[i].args = a.args
e.composite.Add(a)
}
us.position = mark
us.actions = us.actions[:mark+1]
e.args = make(Args)
e.args["commands"] = entries
us.Add(&e)
} | go | 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 {
a := us.actions[i+mark]
entries[i].name = a.command
entries[i].args = a.args
e.composite.Add(a)
}
us.position = mark
us.actions = us.actions[:mark+1]
e.args = make(Args)
e.args["commands"] = entries
us.Add(&e)
} | [
"func",
"(",
"us",
"*",
"UndoStack",
")",
"GlueFrom",
"(",
"mark",
"int",
")",
"{",
"if",
"mark",
">=",
"us",
".",
"position",
"{",
"return",
"\n",
"}",
"\n",
"var",
"e",
"Edit",
"\n",
"e",
".",
"command",
"=",
"\"",
"\"",
"\n",
"type",
"entry",
... | // Glues all edits from the position given by mark,
// to the current position in the UndoStack, replacing
// them by a single entry which will now be composite
// of all those other actions.
//
// In other words, after the glue operation
// a single "undo" operation will then undo all of those edits
// and a single redo after that will redo them all again. | [
"Glues",
"all",
"edits",
"from",
"the",
"position",
"given",
"by",
"mark",
"to",
"the",
"current",
"position",
"in",
"the",
"UndoStack",
"replacing",
"them",
"by",
"a",
"single",
"entry",
"which",
"will",
"now",
"be",
"composite",
"of",
"all",
"those",
"ot... | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/undo.go#L112-L137 |
15,095 | limetext/backend | packages/watcher.go | watch | func watch(pkg Package) {
if err := watcher.Watch(pkg.Path(), pkg); err != nil {
log.Warn("Couldn't watch %s: %s", pkg.Path(), err)
}
} | go | func watch(pkg Package) {
if err := watcher.Watch(pkg.Path(), pkg); err != nil {
log.Warn("Couldn't watch %s: %s", pkg.Path(), err)
}
} | [
"func",
"watch",
"(",
"pkg",
"Package",
")",
"{",
"if",
"err",
":=",
"watcher",
".",
"Watch",
"(",
"pkg",
".",
"Path",
"(",
")",
",",
"pkg",
")",
";",
"err",
"!=",
"nil",
"{",
"log",
".",
"Warn",
"(",
"\"",
"\"",
",",
"pkg",
".",
"Path",
"(",... | // Helper function for watching a package | [
"Helper",
"function",
"for",
"watching",
"a",
"package"
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/packages/watcher.go#L16-L20 |
15,096 | limetext/backend | packages/watcher.go | watchDir | 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 | 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)
}
} | [
"func",
"watchDir",
"(",
"dir",
"string",
")",
"{",
"log",
".",
"Finest",
"(",
"\"",
"\"",
",",
"dir",
")",
"\n",
"sd",
":=",
"&",
"scanDir",
"{",
"dir",
"}",
"\n",
"if",
"err",
":=",
"watcher",
".",
"Watch",
"(",
"sd",
".",
"path",
",",
"sd",
... | // watches scaned directory | [
"watches",
"scaned",
"directory"
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/packages/watcher.go#L42-L48 |
15,097 | limetext/backend | render/view.go | Cull | 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 | 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)
}
} | [
"func",
"(",
"vrm",
"*",
"ViewRegionMap",
")",
"Cull",
"(",
"viewport",
"text",
".",
"Region",
")",
"{",
"pe",
":=",
"util",
".",
"Prof",
".",
"Enter",
"(",
"\"",
"\"",
")",
"\n",
"defer",
"pe",
".",
"Exit",
"(",
")",
"\n",
"rm",
":=",
"[",
"]"... | // Calls Cull on each ViewRegions object contained in the map,
// removing all entries that are outside of the viewport. | [
"Calls",
"Cull",
"on",
"each",
"ViewRegions",
"object",
"contained",
"in",
"the",
"map",
"removing",
"all",
"entries",
"that",
"are",
"outside",
"of",
"the",
"viewport",
"."
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/render/view.go#L59-L74 |
15,098 | limetext/backend | render/view.go | Cull | 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()
vr.Regions.AddAll(nr)
} | go | 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()
vr.Regions.AddAll(nr)
} | [
"func",
"(",
"vr",
"*",
"ViewRegions",
")",
"Cull",
"(",
"viewport",
"text",
".",
"Region",
")",
"{",
"pe",
":=",
"util",
".",
"Prof",
".",
"Enter",
"(",
"\"",
"\"",
")",
"\n",
"defer",
"pe",
".",
"Exit",
"(",
")",
"\n",
"nr",
":=",
"[",
"]",
... | // Removes any regions that are outside of the given viewport,
// and clips the regions that are intersecting it so that
// all regions remaining are fully contained inside of the viewport. | [
"Removes",
"any",
"regions",
"that",
"are",
"outside",
"of",
"the",
"given",
"viewport",
"and",
"clips",
"the",
"regions",
"that",
"are",
"intersecting",
"it",
"so",
"that",
"all",
"regions",
"remaining",
"are",
"fully",
"contained",
"inside",
"of",
"the",
"... | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/render/view.go#L79-L93 |
15,099 | limetext/backend | render/view.go | Clone | 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 | func (vr *ViewRegions) Clone() *ViewRegions {
ret := ViewRegions{Scope: vr.Scope, Icon: vr.Icon, Flags: vr.Flags}
ret.Regions.AddAll(vr.Regions.Regions())
return &ret
} | [
"func",
"(",
"vr",
"*",
"ViewRegions",
")",
"Clone",
"(",
")",
"*",
"ViewRegions",
"{",
"ret",
":=",
"ViewRegions",
"{",
"Scope",
":",
"vr",
".",
"Scope",
",",
"Icon",
":",
"vr",
".",
"Icon",
",",
"Flags",
":",
"vr",
".",
"Flags",
"}",
"\n",
"ret... | // Creates a copy of this ViewRegions object. | [
"Creates",
"a",
"copy",
"of",
"this",
"ViewRegions",
"object",
"."
] | 3e883f0efc3c38aa32c11c06e2e044086a4129f5 | https://github.com/limetext/backend/blob/3e883f0efc3c38aa32c11c06e2e044086a4129f5/render/view.go#L96-L100 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.