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,700 | proullon/ramsql | engine/predicate.go | Eval | func (p *Predicate) Eval(row virtualRow) (bool, error) {
if p.True {
return true, nil
}
// Find left attribute
left := p.LeftValue.table + "." + p.LeftValue.lexeme
val, ok := row[left]
if !ok {
return false, fmt.Errorf("Attribute [%s] not found in row", left)
}
p.LeftValue.v = val.v
return p.Operator(p.LeftValue, p.RightValue), nil
} | go | func (p *Predicate) Eval(row virtualRow) (bool, error) {
if p.True {
return true, nil
}
// Find left attribute
left := p.LeftValue.table + "." + p.LeftValue.lexeme
val, ok := row[left]
if !ok {
return false, fmt.Errorf("Attribute [%s] not found in row", left)
}
p.LeftValue.v = val.v
return p.Operator(p.LeftValue, p.RightValue), nil
} | [
"func",
"(",
"p",
"*",
"Predicate",
")",
"Eval",
"(",
"row",
"virtualRow",
")",
"(",
"bool",
",",
"error",
")",
"{",
"if",
"p",
".",
"True",
"{",
"return",
"true",
",",
"nil",
"\n",
"}",
"\n\n",
"// Find left attribute",
"left",
":=",
"p",
".",
"Le... | // Eval fetches operand from virtual row and run operator | [
"Eval",
"fetches",
"operand",
"from",
"virtual",
"row",
"and",
"run",
"operator"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/predicate.go#L102-L117 |
15,701 | proullon/ramsql | engine/attribute.go | NewAttribute | func NewAttribute(name string, typeName string, autoIncrement bool) Attribute {
a := Attribute{
name: name,
typeName: typeName,
autoIncrement: autoIncrement,
}
return a
} | go | func NewAttribute(name string, typeName string, autoIncrement bool) Attribute {
a := Attribute{
name: name,
typeName: typeName,
autoIncrement: autoIncrement,
}
return a
} | [
"func",
"NewAttribute",
"(",
"name",
"string",
",",
"typeName",
"string",
",",
"autoIncrement",
"bool",
")",
"Attribute",
"{",
"a",
":=",
"Attribute",
"{",
"name",
":",
"name",
",",
"typeName",
":",
"typeName",
",",
"autoIncrement",
":",
"autoIncrement",
","... | // NewAttribute initialize a new Attribute struct | [
"NewAttribute",
"initialize",
"a",
"new",
"Attribute",
"struct"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/attribute.go#L82-L90 |
15,702 | proullon/ramsql | driver/conn.go | Close | func (c *Conn) Close() error {
log.Debug("Conn.Close")
c.conn.Close()
if c.parent != nil {
c.parent.closingConn()
}
return nil
} | go | func (c *Conn) Close() error {
log.Debug("Conn.Close")
c.conn.Close()
if c.parent != nil {
c.parent.closingConn()
}
return nil
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"Close",
"(",
")",
"error",
"{",
"log",
".",
"Debug",
"(",
"\"",
"\"",
")",
"\n",
"c",
".",
"conn",
".",
"Close",
"(",
")",
"\n\n",
"if",
"c",
".",
"parent",
"!=",
"nil",
"{",
"c",
".",
"parent",
".",
"cl... | // Close invalidates and potentially stops any current
// prepared statements and transactions, marking this
// connection as no longer in use.
//
// Because the sql package maintains a free pool of
// connections and only calls Close when there's a surplus of
// idle connections, it shouldn't be necessary for drivers to
// do their own connection caching. | [
"Close",
"invalidates",
"and",
"potentially",
"stops",
"any",
"current",
"prepared",
"statements",
"and",
"transactions",
"marking",
"this",
"connection",
"as",
"no",
"longer",
"in",
"use",
".",
"Because",
"the",
"sql",
"package",
"maintains",
"a",
"free",
"pool... | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/driver/conn.go#L46-L55 |
15,703 | proullon/ramsql | driver/conn.go | Begin | func (c *Conn) Begin() (driver.Tx, error) {
tx := Tx{
conn: c,
}
return &tx, nil
} | go | func (c *Conn) Begin() (driver.Tx, error) {
tx := Tx{
conn: c,
}
return &tx, nil
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"Begin",
"(",
")",
"(",
"driver",
".",
"Tx",
",",
"error",
")",
"{",
"tx",
":=",
"Tx",
"{",
"conn",
":",
"c",
",",
"}",
"\n\n",
"return",
"&",
"tx",
",",
"nil",
"\n",
"}"
] | // Begin starts and returns a new transaction. | [
"Begin",
"starts",
"and",
"returns",
"a",
"new",
"transaction",
"."
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/driver/conn.go#L58-L65 |
15,704 | proullon/ramsql | cli/cli.go | Run | func Run(db *sql.DB) {
// Readline
reader := bufio.NewReader(os.Stdin)
for {
fmt.Printf("ramsql> ")
buffer, err := reader.ReadBytes(';')
if err != nil {
if err == io.EOF {
fmt.Printf("exit\n")
return
}
fmt.Printf("Reading error\n")
return
}
buffer = buffer[:len(buffer)-1]
if len(buffer) == 0 {
continue
}
stmt := string(buffer)
stmt = strings.Replace(stmt, "\n", "", -1)
// Do things here
if strings.HasPrefix(stmt, "SELECT") {
query(db, stmt)
} else if strings.HasPrefix(stmt, "SHOW") {
query(db, stmt)
} else if strings.HasPrefix(stmt, "DESCRIBE") {
query(db, stmt)
} else {
exec(db, stmt)
}
}
} | go | func Run(db *sql.DB) {
// Readline
reader := bufio.NewReader(os.Stdin)
for {
fmt.Printf("ramsql> ")
buffer, err := reader.ReadBytes(';')
if err != nil {
if err == io.EOF {
fmt.Printf("exit\n")
return
}
fmt.Printf("Reading error\n")
return
}
buffer = buffer[:len(buffer)-1]
if len(buffer) == 0 {
continue
}
stmt := string(buffer)
stmt = strings.Replace(stmt, "\n", "", -1)
// Do things here
if strings.HasPrefix(stmt, "SELECT") {
query(db, stmt)
} else if strings.HasPrefix(stmt, "SHOW") {
query(db, stmt)
} else if strings.HasPrefix(stmt, "DESCRIBE") {
query(db, stmt)
} else {
exec(db, stmt)
}
}
} | [
"func",
"Run",
"(",
"db",
"*",
"sql",
".",
"DB",
")",
"{",
"// Readline",
"reader",
":=",
"bufio",
".",
"NewReader",
"(",
"os",
".",
"Stdin",
")",
"\n\n",
"for",
"{",
"fmt",
".",
"Printf",
"(",
"\"",
"\"",
")",
"\n",
"buffer",
",",
"err",
":=",
... | // Run start a command line interface reading on stdin and execute queries
// on given sql.DB | [
"Run",
"start",
"a",
"command",
"line",
"interface",
"reading",
"on",
"stdin",
"and",
"execute",
"queries",
"on",
"given",
"sql",
".",
"DB"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/cli/cli.go#L100-L137 |
15,705 | proullon/ramsql | engine/protocol/channel.go | Close | func (cdc *ChannelDriverConn) Close() {
if cdc.conn == nil {
return
}
close(cdc.conn)
cdc.conn = nil
} | go | func (cdc *ChannelDriverConn) Close() {
if cdc.conn == nil {
return
}
close(cdc.conn)
cdc.conn = nil
} | [
"func",
"(",
"cdc",
"*",
"ChannelDriverConn",
")",
"Close",
"(",
")",
"{",
"if",
"cdc",
".",
"conn",
"==",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"close",
"(",
"cdc",
".",
"conn",
")",
"\n",
"cdc",
".",
"conn",
"=",
"nil",
"\n",
"}"
] | // Close method closes the connection to RamSQL server | [
"Close",
"method",
"closes",
"the",
"connection",
"to",
"RamSQL",
"server"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/protocol/channel.go#L35-L41 |
15,706 | proullon/ramsql | engine/protocol/channel.go | New | func (cde *ChannelDriverEndpoint) New(uri string) (DriverConn, error) {
if cde.newConnChannel == nil {
return nil, fmt.Errorf("connection closed")
}
channel := make(chan message)
cdc := &ChannelDriverConn{conn: channel}
cde.newConnChannel <- channel
return cdc, nil
} | go | func (cde *ChannelDriverEndpoint) New(uri string) (DriverConn, error) {
if cde.newConnChannel == nil {
return nil, fmt.Errorf("connection closed")
}
channel := make(chan message)
cdc := &ChannelDriverConn{conn: channel}
cde.newConnChannel <- channel
return cdc, nil
} | [
"func",
"(",
"cde",
"*",
"ChannelDriverEndpoint",
")",
"New",
"(",
"uri",
"string",
")",
"(",
"DriverConn",
",",
"error",
")",
"{",
"if",
"cde",
".",
"newConnChannel",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")"... | // New method creates a new DriverConn from DriverEndpoint | [
"New",
"method",
"creates",
"a",
"new",
"DriverConn",
"from",
"DriverEndpoint"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/protocol/channel.go#L44-L54 |
15,707 | proullon/ramsql | engine/protocol/channel.go | Accept | func (cee *ChannelEngineEndpoint) Accept() (EngineConn, error) {
newConn, ok := <-cee.newConnChannel
if !ok {
return nil, io.EOF
}
return NewChannelEngineConn(newConn), nil
} | go | func (cee *ChannelEngineEndpoint) Accept() (EngineConn, error) {
newConn, ok := <-cee.newConnChannel
if !ok {
return nil, io.EOF
}
return NewChannelEngineConn(newConn), nil
} | [
"func",
"(",
"cee",
"*",
"ChannelEngineEndpoint",
")",
"Accept",
"(",
")",
"(",
"EngineConn",
",",
"error",
")",
"{",
"newConn",
",",
"ok",
":=",
"<-",
"cee",
".",
"newConnChannel",
"\n",
"if",
"!",
"ok",
"{",
"return",
"nil",
",",
"io",
".",
"EOF",
... | // Accept read from new channels channel and return an EngineConn | [
"Accept",
"read",
"from",
"new",
"channels",
"channel",
"and",
"return",
"an",
"EngineConn"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/protocol/channel.go#L80-L87 |
15,708 | proullon/ramsql | engine/protocol/channel.go | ReadStatement | func (cec *ChannelEngineConn) ReadStatement() (string, error) {
message, ok := <-cec.conn
if !ok {
cec.conn = nil
return "", io.EOF
}
return message.Value[0], nil
} | go | func (cec *ChannelEngineConn) ReadStatement() (string, error) {
message, ok := <-cec.conn
if !ok {
cec.conn = nil
return "", io.EOF
}
return message.Value[0], nil
} | [
"func",
"(",
"cec",
"*",
"ChannelEngineConn",
")",
"ReadStatement",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"message",
",",
"ok",
":=",
"<-",
"cec",
".",
"conn",
"\n",
"if",
"!",
"ok",
"{",
"cec",
".",
"conn",
"=",
"nil",
"\n",
"return",
... | // ReadStatement get SQL statements from client | [
"ReadStatement",
"get",
"SQL",
"statements",
"from",
"client"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/protocol/channel.go#L108-L116 |
15,709 | proullon/ramsql | engine/protocol/channel.go | WriteResult | func (cec *ChannelEngineConn) WriteResult(lastInsertedID int64, rowsAffected int64) error {
m := message{
Type: resultMessage,
Value: []string{fmt.Sprintf("%d %d", lastInsertedID, rowsAffected)},
}
cec.conn <- m
return nil
} | go | func (cec *ChannelEngineConn) WriteResult(lastInsertedID int64, rowsAffected int64) error {
m := message{
Type: resultMessage,
Value: []string{fmt.Sprintf("%d %d", lastInsertedID, rowsAffected)},
}
cec.conn <- m
return nil
} | [
"func",
"(",
"cec",
"*",
"ChannelEngineConn",
")",
"WriteResult",
"(",
"lastInsertedID",
"int64",
",",
"rowsAffected",
"int64",
")",
"error",
"{",
"m",
":=",
"message",
"{",
"Type",
":",
"resultMessage",
",",
"Value",
":",
"[",
"]",
"string",
"{",
"fmt",
... | // WriteResult is used to answer to statements other than SELECT | [
"WriteResult",
"is",
"used",
"to",
"answer",
"to",
"statements",
"other",
"than",
"SELECT"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/protocol/channel.go#L119-L127 |
15,710 | proullon/ramsql | engine/protocol/channel.go | WriteError | func (cec *ChannelEngineConn) WriteError(err error) error {
m := message{
Type: errMessage,
Value: []string{err.Error()},
}
cec.conn <- m
return nil
} | go | func (cec *ChannelEngineConn) WriteError(err error) error {
m := message{
Type: errMessage,
Value: []string{err.Error()},
}
cec.conn <- m
return nil
} | [
"func",
"(",
"cec",
"*",
"ChannelEngineConn",
")",
"WriteError",
"(",
"err",
"error",
")",
"error",
"{",
"m",
":=",
"message",
"{",
"Type",
":",
"errMessage",
",",
"Value",
":",
"[",
"]",
"string",
"{",
"err",
".",
"Error",
"(",
")",
"}",
",",
"}",... | // WriteError when error occurs | [
"WriteError",
"when",
"error",
"occurs"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/protocol/channel.go#L130-L139 |
15,711 | proullon/ramsql | engine/protocol/channel.go | WriteRowHeader | func (cec *ChannelEngineConn) WriteRowHeader(header []string) error {
m := message{
Type: rowHeaderMessage,
Value: header,
}
cec.conn <- m
return nil
} | go | func (cec *ChannelEngineConn) WriteRowHeader(header []string) error {
m := message{
Type: rowHeaderMessage,
Value: header,
}
cec.conn <- m
return nil
} | [
"func",
"(",
"cec",
"*",
"ChannelEngineConn",
")",
"WriteRowHeader",
"(",
"header",
"[",
"]",
"string",
")",
"error",
"{",
"m",
":=",
"message",
"{",
"Type",
":",
"rowHeaderMessage",
",",
"Value",
":",
"header",
",",
"}",
"\n\n",
"cec",
".",
"conn",
"<... | // WriteRowHeader indicates that rows are coming next | [
"WriteRowHeader",
"indicates",
"that",
"rows",
"are",
"coming",
"next"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/protocol/channel.go#L142-L151 |
15,712 | proullon/ramsql | engine/protocol/channel.go | WriteRow | func (cec *ChannelEngineConn) WriteRow(row []string) error {
m := message{
Type: rowValueMessage,
Value: row,
}
cec.conn <- m
return nil
} | go | func (cec *ChannelEngineConn) WriteRow(row []string) error {
m := message{
Type: rowValueMessage,
Value: row,
}
cec.conn <- m
return nil
} | [
"func",
"(",
"cec",
"*",
"ChannelEngineConn",
")",
"WriteRow",
"(",
"row",
"[",
"]",
"string",
")",
"error",
"{",
"m",
":=",
"message",
"{",
"Type",
":",
"rowValueMessage",
",",
"Value",
":",
"row",
",",
"}",
"\n\n",
"cec",
".",
"conn",
"<-",
"m",
... | // WriteRow must be called after WriteRowHeader and before WriteRowEnd | [
"WriteRow",
"must",
"be",
"called",
"after",
"WriteRowHeader",
"and",
"before",
"WriteRowEnd"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/protocol/channel.go#L154-L162 |
15,713 | proullon/ramsql | engine/protocol/channel.go | WriteRowEnd | func (cec *ChannelEngineConn) WriteRowEnd() error {
m := message{
Type: rowEndMessage,
}
cec.conn <- m
return nil
} | go | func (cec *ChannelEngineConn) WriteRowEnd() error {
m := message{
Type: rowEndMessage,
}
cec.conn <- m
return nil
} | [
"func",
"(",
"cec",
"*",
"ChannelEngineConn",
")",
"WriteRowEnd",
"(",
")",
"error",
"{",
"m",
":=",
"message",
"{",
"Type",
":",
"rowEndMessage",
",",
"}",
"\n\n",
"cec",
".",
"conn",
"<-",
"m",
"\n",
"return",
"nil",
"\n",
"}"
] | // WriteRowEnd indicates that query is done | [
"WriteRowEnd",
"indicates",
"that",
"query",
"is",
"done"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/protocol/channel.go#L165-L172 |
15,714 | proullon/ramsql | engine/protocol/channel.go | WriteQuery | func (cdc *ChannelDriverConn) WriteQuery(query string) error {
if cdc.conn == nil {
return fmt.Errorf("connection closed")
}
m := message{
Type: queryMessage,
Value: []string{query},
}
cdc.conn <- m
return nil
} | go | func (cdc *ChannelDriverConn) WriteQuery(query string) error {
if cdc.conn == nil {
return fmt.Errorf("connection closed")
}
m := message{
Type: queryMessage,
Value: []string{query},
}
cdc.conn <- m
return nil
} | [
"func",
"(",
"cdc",
"*",
"ChannelDriverConn",
")",
"WriteQuery",
"(",
"query",
"string",
")",
"error",
"{",
"if",
"cdc",
".",
"conn",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"m",
":=",
"message",
"... | // WriteQuery allows client to query the RamSQL server | [
"WriteQuery",
"allows",
"client",
"to",
"query",
"the",
"RamSQL",
"server"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/protocol/channel.go#L175-L187 |
15,715 | proullon/ramsql | engine/protocol/channel.go | WriteExec | func (cdc *ChannelDriverConn) WriteExec(statement string) error {
if cdc.conn == nil {
return fmt.Errorf("connection closed")
}
m := message{
Type: execMessage,
Value: []string{statement},
}
cdc.conn <- m
return nil
} | go | func (cdc *ChannelDriverConn) WriteExec(statement string) error {
if cdc.conn == nil {
return fmt.Errorf("connection closed")
}
m := message{
Type: execMessage,
Value: []string{statement},
}
cdc.conn <- m
return nil
} | [
"func",
"(",
"cdc",
"*",
"ChannelDriverConn",
")",
"WriteExec",
"(",
"statement",
"string",
")",
"error",
"{",
"if",
"cdc",
".",
"conn",
"==",
"nil",
"{",
"return",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n\n",
"m",
":=",
"message",
... | // WriteExec allows client to manipulate the RamSQL server | [
"WriteExec",
"allows",
"client",
"to",
"manipulate",
"the",
"RamSQL",
"server"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/protocol/channel.go#L190-L202 |
15,716 | proullon/ramsql | engine/protocol/channel.go | ReadResult | func (cdc *ChannelDriverConn) ReadResult() (lastInsertedID int64, rowsAffected int64, err error) {
if cdc.conn == nil {
return 0, 0, fmt.Errorf("connection closed")
}
m := <-cdc.conn
if m.Type != resultMessage {
if m.Type == errMessage {
return 0, 0, errors.New(m.Value[0])
}
return 0, 0, fmt.Errorf("Protocal error: ReadResult received %v", m)
}
_, err = fmt.Sscanf(m.Value[0], "%d %d", &lastInsertedID, &rowsAffected)
return lastInsertedID, rowsAffected, err
} | go | func (cdc *ChannelDriverConn) ReadResult() (lastInsertedID int64, rowsAffected int64, err error) {
if cdc.conn == nil {
return 0, 0, fmt.Errorf("connection closed")
}
m := <-cdc.conn
if m.Type != resultMessage {
if m.Type == errMessage {
return 0, 0, errors.New(m.Value[0])
}
return 0, 0, fmt.Errorf("Protocal error: ReadResult received %v", m)
}
_, err = fmt.Sscanf(m.Value[0], "%d %d", &lastInsertedID, &rowsAffected)
return lastInsertedID, rowsAffected, err
} | [
"func",
"(",
"cdc",
"*",
"ChannelDriverConn",
")",
"ReadResult",
"(",
")",
"(",
"lastInsertedID",
"int64",
",",
"rowsAffected",
"int64",
",",
"err",
"error",
")",
"{",
"if",
"cdc",
".",
"conn",
"==",
"nil",
"{",
"return",
"0",
",",
"0",
",",
"fmt",
"... | // ReadResult when Exec has been used | [
"ReadResult",
"when",
"Exec",
"has",
"been",
"used"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/protocol/channel.go#L205-L220 |
15,717 | proullon/ramsql | engine/protocol/channel.go | ReadRows | func (cdc *ChannelDriverConn) ReadRows() (chan []string, error) {
if cdc.conn == nil {
return nil, fmt.Errorf("connection closed")
}
m := <-cdc.conn
if m.Type == errMessage {
return nil, errors.New(m.Value[0])
}
if m.Type != rowHeaderMessage {
return nil, errors.New("not a rows header")
}
return UnlimitedRowsChannel(cdc.conn, m), nil
} | go | func (cdc *ChannelDriverConn) ReadRows() (chan []string, error) {
if cdc.conn == nil {
return nil, fmt.Errorf("connection closed")
}
m := <-cdc.conn
if m.Type == errMessage {
return nil, errors.New(m.Value[0])
}
if m.Type != rowHeaderMessage {
return nil, errors.New("not a rows header")
}
return UnlimitedRowsChannel(cdc.conn, m), nil
} | [
"func",
"(",
"cdc",
"*",
"ChannelDriverConn",
")",
"ReadRows",
"(",
")",
"(",
"chan",
"[",
"]",
"string",
",",
"error",
")",
"{",
"if",
"cdc",
".",
"conn",
"==",
"nil",
"{",
"return",
"nil",
",",
"fmt",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
... | // ReadRows when Query has been used | [
"ReadRows",
"when",
"Query",
"has",
"been",
"used"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/protocol/channel.go#L223-L238 |
15,718 | proullon/ramsql | engine/relation.go | Insert | func (r *Relation) Insert(t *Tuple) error {
// Maybe do somthing like lock read/write here
// Maybe index
r.rows = append(r.rows, t)
return nil
} | go | func (r *Relation) Insert(t *Tuple) error {
// Maybe do somthing like lock read/write here
// Maybe index
r.rows = append(r.rows, t)
return nil
} | [
"func",
"(",
"r",
"*",
"Relation",
")",
"Insert",
"(",
"t",
"*",
"Tuple",
")",
"error",
"{",
"// Maybe do somthing like lock read/write here",
"// Maybe index",
"r",
".",
"rows",
"=",
"append",
"(",
"r",
".",
"rows",
",",
"t",
")",
"\n",
"return",
"nil",
... | // Insert a tuple in relation | [
"Insert",
"a",
"tuple",
"in",
"relation"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/relation.go#L25-L30 |
15,719 | proullon/ramsql | driver/stmt.go | Exec | func (s *Stmt) Exec(args []driver.Value) (r driver.Result, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("fatalf error: %s", r)
return
}
}()
defer s.conn.mutex.Unlock()
if s.query == "" {
return nil, fmt.Errorf("empty statement")
}
var finalQuery string
// replace $* by arguments in query string
finalQuery = replaceArguments(s.query, args)
log.Info("Exec <%s>\n", finalQuery)
// Send query to server
err = s.conn.conn.WriteExec(finalQuery)
if err != nil {
log.Warning("Exec: Cannot send query to server: %s", err)
return nil, fmt.Errorf("Cannot send query to server: %s", err)
}
// Get answer from server
lastInsertedID, rowsAffected, err := s.conn.conn.ReadResult()
if err != nil {
return nil, err
}
// Create a driver.Result
return newResult(lastInsertedID, rowsAffected), nil
} | go | func (s *Stmt) Exec(args []driver.Value) (r driver.Result, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("fatalf error: %s", r)
return
}
}()
defer s.conn.mutex.Unlock()
if s.query == "" {
return nil, fmt.Errorf("empty statement")
}
var finalQuery string
// replace $* by arguments in query string
finalQuery = replaceArguments(s.query, args)
log.Info("Exec <%s>\n", finalQuery)
// Send query to server
err = s.conn.conn.WriteExec(finalQuery)
if err != nil {
log.Warning("Exec: Cannot send query to server: %s", err)
return nil, fmt.Errorf("Cannot send query to server: %s", err)
}
// Get answer from server
lastInsertedID, rowsAffected, err := s.conn.conn.ReadResult()
if err != nil {
return nil, err
}
// Create a driver.Result
return newResult(lastInsertedID, rowsAffected), nil
} | [
"func",
"(",
"s",
"*",
"Stmt",
")",
"Exec",
"(",
"args",
"[",
"]",
"driver",
".",
"Value",
")",
"(",
"r",
"driver",
".",
"Result",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
... | // Exec executes a query that doesn't return rows, such
// as an INSERT or UPDATE. | [
"Exec",
"executes",
"a",
"query",
"that",
"doesn",
"t",
"return",
"rows",
"such",
"as",
"an",
"INSERT",
"or",
"UPDATE",
"."
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/driver/stmt.go#L75-L109 |
15,720 | proullon/ramsql | driver/stmt.go | Query | func (s *Stmt) Query(args []driver.Value) (r driver.Rows, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("fatalf error: %s", r)
return
}
}()
defer s.conn.mutex.Unlock()
if s.query == "" {
return nil, fmt.Errorf("empty statement")
}
finalQuery := replaceArguments(s.query, args)
log.Info("Query < %s >\n", finalQuery)
err = s.conn.conn.WriteQuery(finalQuery)
if err != nil {
return nil, err
}
rowsChannel, err := s.conn.conn.ReadRows()
if err != nil {
return nil, err
}
r = newRows(rowsChannel)
return r, nil
} | go | func (s *Stmt) Query(args []driver.Value) (r driver.Rows, err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("fatalf error: %s", r)
return
}
}()
defer s.conn.mutex.Unlock()
if s.query == "" {
return nil, fmt.Errorf("empty statement")
}
finalQuery := replaceArguments(s.query, args)
log.Info("Query < %s >\n", finalQuery)
err = s.conn.conn.WriteQuery(finalQuery)
if err != nil {
return nil, err
}
rowsChannel, err := s.conn.conn.ReadRows()
if err != nil {
return nil, err
}
r = newRows(rowsChannel)
return r, nil
} | [
"func",
"(",
"s",
"*",
"Stmt",
")",
"Query",
"(",
"args",
"[",
"]",
"driver",
".",
"Value",
")",
"(",
"r",
"driver",
".",
"Rows",
",",
"err",
"error",
")",
"{",
"defer",
"func",
"(",
")",
"{",
"if",
"r",
":=",
"recover",
"(",
")",
";",
"r",
... | // Query executes a query that may return rows, such as a
// SELECT. | [
"Query",
"executes",
"a",
"query",
"that",
"may",
"return",
"rows",
"such",
"as",
"a",
"SELECT",
"."
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/driver/stmt.go#L113-L140 |
15,721 | proullon/ramsql | engine/protocol/buffer.go | UnlimitedRowsChannel | func UnlimitedRowsChannel(bufferThis chan message, firstMessage message) chan []string {
driverChannel := make(chan []string)
rowList := list.New()
rowList.PushBack(firstMessage.Value)
go func() {
for {
// If nothing comes in and nothing is going out...
if rowList.Len() == 0 && bufferThis == nil {
close(driverChannel)
return
}
// Create a copy of driverChannel because if there is nothing to send
// We can disable the case in select with a nil channel and get a chance
// to fetch new data on bufferThis channel
driverChannelNullable := driverChannel
var nextRow []string
if rowList.Len() != 0 {
nextRow = rowList.Front().Value.([]string)
} else {
driverChannelNullable = nil
}
select {
// In case a new row is sent to driver
case driverChannelNullable <- nextRow:
if nextRow != nil {
rowList.Remove(rowList.Front())
}
// In case we receive a new value to buffer from engine channel
case newRow, ok := <-bufferThis:
if !ok || newRow.Type == rowEndMessage {
// Stop listening to bufferThis channel
bufferThis = nil
// If there is nothing more to listen and there is nothing in buffer, exit
// close driverChannel so *Rows knows there is nothing more to read
if rowList.Len() == 0 {
if driverChannel != nil {
close(driverChannel)
}
return
}
if driverChannel == nil {
log.Critical("Unlimited: But there is nobody to read it, exiting")
return
}
} else if newRow.Type == errMessage {
log.Critical("Runtime error: %s", newRow.Value[0])
if driverChannel != nil {
close(driverChannel)
}
return
} else {
// Everything is ok, buffering new value
rowList.PushBack(newRow.Value)
}
case exit := <-driverChannel:
// this means driverChannel is closed
// set driverChannel to nil so we don't try to close it again
driverChannel = nil
_ = exit
}
}
}()
return driverChannel
} | go | func UnlimitedRowsChannel(bufferThis chan message, firstMessage message) chan []string {
driverChannel := make(chan []string)
rowList := list.New()
rowList.PushBack(firstMessage.Value)
go func() {
for {
// If nothing comes in and nothing is going out...
if rowList.Len() == 0 && bufferThis == nil {
close(driverChannel)
return
}
// Create a copy of driverChannel because if there is nothing to send
// We can disable the case in select with a nil channel and get a chance
// to fetch new data on bufferThis channel
driverChannelNullable := driverChannel
var nextRow []string
if rowList.Len() != 0 {
nextRow = rowList.Front().Value.([]string)
} else {
driverChannelNullable = nil
}
select {
// In case a new row is sent to driver
case driverChannelNullable <- nextRow:
if nextRow != nil {
rowList.Remove(rowList.Front())
}
// In case we receive a new value to buffer from engine channel
case newRow, ok := <-bufferThis:
if !ok || newRow.Type == rowEndMessage {
// Stop listening to bufferThis channel
bufferThis = nil
// If there is nothing more to listen and there is nothing in buffer, exit
// close driverChannel so *Rows knows there is nothing more to read
if rowList.Len() == 0 {
if driverChannel != nil {
close(driverChannel)
}
return
}
if driverChannel == nil {
log.Critical("Unlimited: But there is nobody to read it, exiting")
return
}
} else if newRow.Type == errMessage {
log.Critical("Runtime error: %s", newRow.Value[0])
if driverChannel != nil {
close(driverChannel)
}
return
} else {
// Everything is ok, buffering new value
rowList.PushBack(newRow.Value)
}
case exit := <-driverChannel:
// this means driverChannel is closed
// set driverChannel to nil so we don't try to close it again
driverChannel = nil
_ = exit
}
}
}()
return driverChannel
} | [
"func",
"UnlimitedRowsChannel",
"(",
"bufferThis",
"chan",
"message",
",",
"firstMessage",
"message",
")",
"chan",
"[",
"]",
"string",
"{",
"driverChannel",
":=",
"make",
"(",
"chan",
"[",
"]",
"string",
")",
"\n",
"rowList",
":=",
"list",
".",
"New",
"(",... | // UnlimitedRowsChannel buffers incomming message from bufferThis channel and forward them to
// returned channel.
// ONLY CREATED CHANNEL IS CLOSED HERE. | [
"UnlimitedRowsChannel",
"buffers",
"incomming",
"message",
"from",
"bufferThis",
"channel",
"and",
"forward",
"them",
"to",
"returned",
"channel",
".",
"ONLY",
"CREATED",
"CHANNEL",
"IS",
"CLOSED",
"HERE",
"."
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/protocol/buffer.go#L12-L81 |
15,722 | proullon/ramsql | engine/operator.go | NewOperator | func NewOperator(token int, lexeme string) (Operator, error) {
switch token {
case parser.EqualityToken:
return equalityOperator, nil
case parser.LeftDipleToken:
return lessThanOperator, nil
case parser.RightDipleToken:
return greaterThanOperator, nil
case parser.LessOrEqualToken:
return lessOrEqualOperator, nil
case parser.GreaterOrEqualToken:
return greaterOrEqualOperator, nil
}
return nil, fmt.Errorf("Operator '%s' does not exist", lexeme)
} | go | func NewOperator(token int, lexeme string) (Operator, error) {
switch token {
case parser.EqualityToken:
return equalityOperator, nil
case parser.LeftDipleToken:
return lessThanOperator, nil
case parser.RightDipleToken:
return greaterThanOperator, nil
case parser.LessOrEqualToken:
return lessOrEqualOperator, nil
case parser.GreaterOrEqualToken:
return greaterOrEqualOperator, nil
}
return nil, fmt.Errorf("Operator '%s' does not exist", lexeme)
} | [
"func",
"NewOperator",
"(",
"token",
"int",
",",
"lexeme",
"string",
")",
"(",
"Operator",
",",
"error",
")",
"{",
"switch",
"token",
"{",
"case",
"parser",
".",
"EqualityToken",
":",
"return",
"equalityOperator",
",",
"nil",
"\n",
"case",
"parser",
".",
... | // NewOperator initializes the operator matching the Token number | [
"NewOperator",
"initializes",
"the",
"operator",
"matching",
"the",
"Token",
"number"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/operator.go#L15-L30 |
15,723 | proullon/ramsql | engine/operator.go | equalityOperator | func equalityOperator(leftValue Value, rightValue Value) bool {
if fmt.Sprintf("%v", leftValue.v) == rightValue.lexeme {
return true
}
return false
} | go | func equalityOperator(leftValue Value, rightValue Value) bool {
if fmt.Sprintf("%v", leftValue.v) == rightValue.lexeme {
return true
}
return false
} | [
"func",
"equalityOperator",
"(",
"leftValue",
"Value",
",",
"rightValue",
"Value",
")",
"bool",
"{",
"if",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"leftValue",
".",
"v",
")",
"==",
"rightValue",
".",
"lexeme",
"{",
"return",
"true",
"\n",
"}",
"\n... | // EqualityOperator checks if given value are equal | [
"EqualityOperator",
"checks",
"if",
"given",
"value",
"are",
"equal"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/operator.go#L164-L171 |
15,724 | proullon/ramsql | engine/table.go | AddAttribute | func (t *Table) AddAttribute(attr Attribute) error {
t.attributes = append(t.attributes, attr)
return nil
} | go | func (t *Table) AddAttribute(attr Attribute) error {
t.attributes = append(t.attributes, attr)
return nil
} | [
"func",
"(",
"t",
"*",
"Table",
")",
"AddAttribute",
"(",
"attr",
"Attribute",
")",
"error",
"{",
"t",
".",
"attributes",
"=",
"append",
"(",
"t",
".",
"attributes",
",",
"attr",
")",
"\n",
"return",
"nil",
"\n",
"}"
] | // AddAttribute is used by CREATE TABLE and ALTER TABLE
// Want to check that name isn't already taken | [
"AddAttribute",
"is",
"used",
"by",
"CREATE",
"TABLE",
"and",
"ALTER",
"TABLE",
"Want",
"to",
"check",
"that",
"name",
"isn",
"t",
"already",
"taken"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/table.go#L28-L31 |
15,725 | proullon/ramsql | engine/table.go | String | func (t Table) String() string {
stringy := t.name + " ("
for i, a := range t.attributes {
if i != 0 {
stringy += " | "
}
stringy += a.name + " " + a.typeName
}
stringy += ")"
return stringy
} | go | func (t Table) String() string {
stringy := t.name + " ("
for i, a := range t.attributes {
if i != 0 {
stringy += " | "
}
stringy += a.name + " " + a.typeName
}
stringy += ")"
return stringy
} | [
"func",
"(",
"t",
"Table",
")",
"String",
"(",
")",
"string",
"{",
"stringy",
":=",
"t",
".",
"name",
"+",
"\"",
"\"",
"\n",
"for",
"i",
",",
"a",
":=",
"range",
"t",
".",
"attributes",
"{",
"if",
"i",
"!=",
"0",
"{",
"stringy",
"+=",
"\"",
"... | // String returns a printable string with table name and attributes | [
"String",
"returns",
"a",
"printable",
"string",
"with",
"table",
"name",
"and",
"attributes"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/table.go#L34-L44 |
15,726 | proullon/ramsql | engine/log/log.go | Debug | func Debug(format string, values ...interface{}) {
if lvl() <= DebugLevel {
logger.Logf("[DEBUG] "+format, values...)
}
} | go | func Debug(format string, values ...interface{}) {
if lvl() <= DebugLevel {
logger.Logf("[DEBUG] "+format, values...)
}
} | [
"func",
"Debug",
"(",
"format",
"string",
",",
"values",
"...",
"interface",
"{",
"}",
")",
"{",
"if",
"lvl",
"(",
")",
"<=",
"DebugLevel",
"{",
"logger",
".",
"Logf",
"(",
"\"",
"\"",
"+",
"format",
",",
"values",
"...",
")",
"\n",
"}",
"\n",
"}... | // Debug prints debug log | [
"Debug",
"prints",
"debug",
"log"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/log/log.go#L52-L56 |
15,727 | proullon/ramsql | engine/log/log.go | Info | func Info(format string, values ...interface{}) {
if lvl() <= InfoLevel {
logger.Logf("[INFO] "+format, values...)
}
} | go | func Info(format string, values ...interface{}) {
if lvl() <= InfoLevel {
logger.Logf("[INFO] "+format, values...)
}
} | [
"func",
"Info",
"(",
"format",
"string",
",",
"values",
"...",
"interface",
"{",
"}",
")",
"{",
"if",
"lvl",
"(",
")",
"<=",
"InfoLevel",
"{",
"logger",
".",
"Logf",
"(",
"\"",
"\"",
"+",
"format",
",",
"values",
"...",
")",
"\n",
"}",
"\n",
"}"
... | // Info prints information log | [
"Info",
"prints",
"information",
"log"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/log/log.go#L59-L63 |
15,728 | proullon/ramsql | engine/log/log.go | Notice | func Notice(format string, values ...interface{}) {
if lvl() <= NoticeLevel {
logger.Logf("[NOTICE] "+format, values...)
}
} | go | func Notice(format string, values ...interface{}) {
if lvl() <= NoticeLevel {
logger.Logf("[NOTICE] "+format, values...)
}
} | [
"func",
"Notice",
"(",
"format",
"string",
",",
"values",
"...",
"interface",
"{",
"}",
")",
"{",
"if",
"lvl",
"(",
")",
"<=",
"NoticeLevel",
"{",
"logger",
".",
"Logf",
"(",
"\"",
"\"",
"+",
"format",
",",
"values",
"...",
")",
"\n",
"}",
"\n",
... | // Notice prints information that should be seen | [
"Notice",
"prints",
"information",
"that",
"should",
"be",
"seen"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/log/log.go#L66-L70 |
15,729 | proullon/ramsql | engine/log/log.go | Warning | func Warning(format string, values ...interface{}) {
if lvl() <= WarningLevel {
logger.Logf("[WARNING] "+format, values...)
}
} | go | func Warning(format string, values ...interface{}) {
if lvl() <= WarningLevel {
logger.Logf("[WARNING] "+format, values...)
}
} | [
"func",
"Warning",
"(",
"format",
"string",
",",
"values",
"...",
"interface",
"{",
"}",
")",
"{",
"if",
"lvl",
"(",
")",
"<=",
"WarningLevel",
"{",
"logger",
".",
"Logf",
"(",
"\"",
"\"",
"+",
"format",
",",
"values",
"...",
")",
"\n",
"}",
"\n",
... | // Warning prints warnings for user | [
"Warning",
"prints",
"warnings",
"for",
"user"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/log/log.go#L73-L77 |
15,730 | proullon/ramsql | engine/log/log.go | Critical | func Critical(format string, values ...interface{}) {
mu.Lock()
logger.Logf("[CRITICAL] "+format, values...)
mu.Unlock()
} | go | func Critical(format string, values ...interface{}) {
mu.Lock()
logger.Logf("[CRITICAL] "+format, values...)
mu.Unlock()
} | [
"func",
"Critical",
"(",
"format",
"string",
",",
"values",
"...",
"interface",
"{",
"}",
")",
"{",
"mu",
".",
"Lock",
"(",
")",
"\n",
"logger",
".",
"Logf",
"(",
"\"",
"\"",
"+",
"format",
",",
"values",
"...",
")",
"\n",
"mu",
".",
"Unlock",
"(... | // Critical prints error informations | [
"Critical",
"prints",
"error",
"informations"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/log/log.go#L80-L84 |
15,731 | proullon/ramsql | engine/log/log.go | Logf | func (l BaseLogger) Logf(fmt string, values ...interface{}) {
log.Printf(fmt, values...)
} | go | func (l BaseLogger) Logf(fmt string, values ...interface{}) {
log.Printf(fmt, values...)
} | [
"func",
"(",
"l",
"BaseLogger",
")",
"Logf",
"(",
"fmt",
"string",
",",
"values",
"...",
"interface",
"{",
"}",
")",
"{",
"log",
".",
"Printf",
"(",
"fmt",
",",
"values",
"...",
")",
"\n",
"}"
] | // Logf logs on stdout | [
"Logf",
"logs",
"on",
"stdout"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/log/log.go#L91-L93 |
15,732 | proullon/ramsql | engine/log/log.go | Logf | func (l TestLogger) Logf(fmt string, values ...interface{}) {
l.t.Logf(fmt, values...)
} | go | func (l TestLogger) Logf(fmt string, values ...interface{}) {
l.t.Logf(fmt, values...)
} | [
"func",
"(",
"l",
"TestLogger",
")",
"Logf",
"(",
"fmt",
"string",
",",
"values",
"...",
"interface",
"{",
"}",
")",
"{",
"l",
".",
"t",
".",
"Logf",
"(",
"fmt",
",",
"values",
"...",
")",
"\n",
"}"
] | // Logf logs in testing log buffer | [
"Logf",
"logs",
"in",
"testing",
"log",
"buffer"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/log/log.go#L101-L103 |
15,733 | proullon/ramsql | engine/parser/interface.go | ParseInstruction | func ParseInstruction(instruction string) ([]Instruction, error) {
l := lexer{}
tokens, err := l.lex([]byte(instruction))
if err != nil {
return nil, err
}
p := parser{}
instructions, err := p.parse(tokens)
if err != nil {
return nil, err
}
if len(instructions) == 0 {
return nil, errors.New("Error in syntax near " + instruction)
}
return instructions, nil
} | go | func ParseInstruction(instruction string) ([]Instruction, error) {
l := lexer{}
tokens, err := l.lex([]byte(instruction))
if err != nil {
return nil, err
}
p := parser{}
instructions, err := p.parse(tokens)
if err != nil {
return nil, err
}
if len(instructions) == 0 {
return nil, errors.New("Error in syntax near " + instruction)
}
return instructions, nil
} | [
"func",
"ParseInstruction",
"(",
"instruction",
"string",
")",
"(",
"[",
"]",
"Instruction",
",",
"error",
")",
"{",
"l",
":=",
"lexer",
"{",
"}",
"\n",
"tokens",
",",
"err",
":=",
"l",
".",
"lex",
"(",
"[",
"]",
"byte",
"(",
"instruction",
")",
")... | // ParseInstruction calls lexer and parser, then return Decl tree for each instruction | [
"ParseInstruction",
"calls",
"lexer",
"and",
"parser",
"then",
"return",
"Decl",
"tree",
"for",
"each",
"instruction"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/parser/interface.go#L8-L27 |
15,734 | proullon/ramsql | engine/parser/date.go | ParseDate | func ParseDate(data string) (*time.Time, error) {
t, err := time.Parse(DateLongFormat, data)
if err == nil {
return &t, nil
}
t, err = time.Parse(time.RFC3339, data)
if err == nil {
return &t, nil
}
t, err = time.Parse(DateShortFormat, data)
if err == nil {
return &t, nil
}
t, err = time.Parse(DateNumberFormat, data)
if err == nil {
return &t, nil
}
return nil, fmt.Errorf("not a date")
} | go | func ParseDate(data string) (*time.Time, error) {
t, err := time.Parse(DateLongFormat, data)
if err == nil {
return &t, nil
}
t, err = time.Parse(time.RFC3339, data)
if err == nil {
return &t, nil
}
t, err = time.Parse(DateShortFormat, data)
if err == nil {
return &t, nil
}
t, err = time.Parse(DateNumberFormat, data)
if err == nil {
return &t, nil
}
return nil, fmt.Errorf("not a date")
} | [
"func",
"ParseDate",
"(",
"data",
"string",
")",
"(",
"*",
"time",
".",
"Time",
",",
"error",
")",
"{",
"t",
",",
"err",
":=",
"time",
".",
"Parse",
"(",
"DateLongFormat",
",",
"data",
")",
"\n",
"if",
"err",
"==",
"nil",
"{",
"return",
"&",
"t",... | // ParseDate intends to parse all SQL date format | [
"ParseDate",
"intends",
"to",
"parse",
"all",
"SQL",
"date",
"format"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/parser/date.go#L17-L39 |
15,735 | proullon/ramsql | driver/driver.go | Open | func (rs *Driver) Open(dsn string) (conn driver.Conn, err error) {
rs.Lock()
connConf, err := parseConnectionURI(dsn)
if err != nil {
rs.Unlock()
return nil, err
}
dsnServer, exist := rs.servers[dsn]
if !exist {
driverEndpoint, engineEndpoint, err := endpoints(connConf)
if err != nil {
rs.Unlock()
return nil, err
}
server, err := engine.New(engineEndpoint)
if err != nil {
rs.Unlock()
return nil, err
}
driverConn, err := driverEndpoint.New(dsn)
if err != nil {
rs.Unlock()
return nil, err
}
s := &Server{
endpoint: driverEndpoint,
server: server,
}
rs.servers[dsn] = s
rs.Unlock()
return newConn(driverConn, s), nil
}
rs.Unlock()
driverConn, err := dsnServer.endpoint.New(dsn)
return newConn(driverConn, dsnServer), err
} | go | func (rs *Driver) Open(dsn string) (conn driver.Conn, err error) {
rs.Lock()
connConf, err := parseConnectionURI(dsn)
if err != nil {
rs.Unlock()
return nil, err
}
dsnServer, exist := rs.servers[dsn]
if !exist {
driverEndpoint, engineEndpoint, err := endpoints(connConf)
if err != nil {
rs.Unlock()
return nil, err
}
server, err := engine.New(engineEndpoint)
if err != nil {
rs.Unlock()
return nil, err
}
driverConn, err := driverEndpoint.New(dsn)
if err != nil {
rs.Unlock()
return nil, err
}
s := &Server{
endpoint: driverEndpoint,
server: server,
}
rs.servers[dsn] = s
rs.Unlock()
return newConn(driverConn, s), nil
}
rs.Unlock()
driverConn, err := dsnServer.endpoint.New(dsn)
return newConn(driverConn, dsnServer), err
} | [
"func",
"(",
"rs",
"*",
"Driver",
")",
"Open",
"(",
"dsn",
"string",
")",
"(",
"conn",
"driver",
".",
"Conn",
",",
"err",
"error",
")",
"{",
"rs",
".",
"Lock",
"(",
")",
"\n\n",
"connConf",
",",
"err",
":=",
"parseConnectionURI",
"(",
"dsn",
")",
... | // Open return an active connection so RamSQL server
// If there is no connection in pool, start a new server.
// After first instantiation of the server, | [
"Open",
"return",
"an",
"active",
"connection",
"so",
"RamSQL",
"server",
"If",
"there",
"is",
"no",
"connection",
"in",
"pool",
"start",
"a",
"new",
"server",
".",
"After",
"first",
"instantiation",
"of",
"the",
"server"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/driver/driver.go#L62-L104 |
15,736 | proullon/ramsql | driver/rows.go | Close | func (r *Rows) Close() error {
r.Lock()
defer r.Unlock()
if r.rowsChannel == nil {
return nil
}
_, ok := <-r.rowsChannel
if !ok {
return nil
}
// Tels UnlimitedRowsChannel to close itself
//r.rowsChannel <- []string{}
r.rowsChannel = nil
return nil
} | go | func (r *Rows) Close() error {
r.Lock()
defer r.Unlock()
if r.rowsChannel == nil {
return nil
}
_, ok := <-r.rowsChannel
if !ok {
return nil
}
// Tels UnlimitedRowsChannel to close itself
//r.rowsChannel <- []string{}
r.rowsChannel = nil
return nil
} | [
"func",
"(",
"r",
"*",
"Rows",
")",
"Close",
"(",
")",
"error",
"{",
"r",
".",
"Lock",
"(",
")",
"\n",
"defer",
"r",
".",
"Unlock",
"(",
")",
"\n\n",
"if",
"r",
".",
"rowsChannel",
"==",
"nil",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"_",
",... | // Close closes the rows iterator. | [
"Close",
"closes",
"the",
"rows",
"iterator",
"."
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/driver/rows.go#L43-L60 |
15,737 | proullon/ramsql | engine/protocol/public.go | NewChannelEndpoints | func NewChannelEndpoints() (DriverEndpoint, EngineEndpoint) {
channel := make(chan chan message)
return NewChannelDriverEndpoint(channel), NewChannelEngineEndpoint(channel)
} | go | func NewChannelEndpoints() (DriverEndpoint, EngineEndpoint) {
channel := make(chan chan message)
return NewChannelDriverEndpoint(channel), NewChannelEngineEndpoint(channel)
} | [
"func",
"NewChannelEndpoints",
"(",
")",
"(",
"DriverEndpoint",
",",
"EngineEndpoint",
")",
"{",
"channel",
":=",
"make",
"(",
"chan",
"chan",
"message",
")",
"\n\n",
"return",
"NewChannelDriverEndpoint",
"(",
"channel",
")",
",",
"NewChannelEngineEndpoint",
"(",
... | // NewChannelEndpoints instanciates a Driver and
// Engine channel endpoints | [
"NewChannelEndpoints",
"instanciates",
"a",
"Driver",
"and",
"Engine",
"channel",
"endpoints"
] | 817cee58a24456db9e01091be07f562703408ca3 | https://github.com/proullon/ramsql/blob/817cee58a24456db9e01091be07f562703408ca3/engine/protocol/public.go#L39-L43 |
15,738 | gortc/sdp | sdp.go | Equal | func (l Line) Equal(b Line) bool {
if l.Type != b.Type {
return false
}
return bytes.Equal(l.Value, b.Value)
} | go | func (l Line) Equal(b Line) bool {
if l.Type != b.Type {
return false
}
return bytes.Equal(l.Value, b.Value)
} | [
"func",
"(",
"l",
"Line",
")",
"Equal",
"(",
"b",
"Line",
")",
"bool",
"{",
"if",
"l",
".",
"Type",
"!=",
"b",
".",
"Type",
"{",
"return",
"false",
"\n",
"}",
"\n",
"return",
"bytes",
".",
"Equal",
"(",
"l",
".",
"Value",
",",
"b",
".",
"Valu... | // Equal returns true if l == b. | [
"Equal",
"returns",
"true",
"if",
"l",
"==",
"b",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/sdp.go#L48-L53 |
15,739 | gortc/sdp | sdp.go | Decode | func (l *Line) Decode(b []byte) error {
delimiter := bytes.IndexRune(b, lineDelimiter)
if delimiter == -1 {
reason := `delimiter "=" not found`
err := newDecodeError("line", reason)
return errors.Wrap(err, "failed to decode")
}
if len(b) <= (delimiter + 1) {
reason := fmt.Sprintf(
"len(b) %d < (%d + 1), no value found after delimiter",
len(b), delimiter,
)
err := newDecodeError("line", reason)
return errors.Wrap(err, "failed to decode")
}
r, _ := utf8.DecodeRune(b[:delimiter])
l.Type = Type(r)
l.Value = append(l.Value, b[delimiter+1:]...)
return nil
} | go | func (l *Line) Decode(b []byte) error {
delimiter := bytes.IndexRune(b, lineDelimiter)
if delimiter == -1 {
reason := `delimiter "=" not found`
err := newDecodeError("line", reason)
return errors.Wrap(err, "failed to decode")
}
if len(b) <= (delimiter + 1) {
reason := fmt.Sprintf(
"len(b) %d < (%d + 1), no value found after delimiter",
len(b), delimiter,
)
err := newDecodeError("line", reason)
return errors.Wrap(err, "failed to decode")
}
r, _ := utf8.DecodeRune(b[:delimiter])
l.Type = Type(r)
l.Value = append(l.Value, b[delimiter+1:]...)
return nil
} | [
"func",
"(",
"l",
"*",
"Line",
")",
"Decode",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"delimiter",
":=",
"bytes",
".",
"IndexRune",
"(",
"b",
",",
"lineDelimiter",
")",
"\n",
"if",
"delimiter",
"==",
"-",
"1",
"{",
"reason",
":=",
"`delimite... | // Decode parses b into l and returns error if any.
//
// Decode does not reuse b, so it is safe to corrupt it. | [
"Decode",
"parses",
"b",
"into",
"l",
"and",
"returns",
"error",
"if",
"any",
".",
"Decode",
"does",
"not",
"reuse",
"b",
"so",
"it",
"is",
"safe",
"to",
"corrupt",
"it",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/sdp.go#L58-L77 |
15,740 | gortc/sdp | sdp.go | AppendTo | func (l Line) AppendTo(b []byte) []byte {
b = l.Type.appendTo(b)
b = appendRune(b, lineDelimiter)
return append(b, l.Value...)
} | go | func (l Line) AppendTo(b []byte) []byte {
b = l.Type.appendTo(b)
b = appendRune(b, lineDelimiter)
return append(b, l.Value...)
} | [
"func",
"(",
"l",
"Line",
")",
"AppendTo",
"(",
"b",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"b",
"=",
"l",
".",
"Type",
".",
"appendTo",
"(",
"b",
")",
"\n",
"b",
"=",
"appendRune",
"(",
"b",
",",
"lineDelimiter",
")",
"\n",
"return",
... | // AppendTo appends Line encoded value to b. | [
"AppendTo",
"appends",
"Line",
"encoded",
"value",
"to",
"b",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/sdp.go#L100-L104 |
15,741 | gortc/sdp | sdp.go | AppendTo | func (s Session) AppendTo(b []byte) []byte {
for _, l := range s {
b = l.AppendTo(b)
b = appendCLRF(b)
}
return b
} | go | func (s Session) AppendTo(b []byte) []byte {
for _, l := range s {
b = l.AppendTo(b)
b = appendCLRF(b)
}
return b
} | [
"func",
"(",
"s",
"Session",
")",
"AppendTo",
"(",
"b",
"[",
"]",
"byte",
")",
"[",
"]",
"byte",
"{",
"for",
"_",
",",
"l",
":=",
"range",
"s",
"{",
"b",
"=",
"l",
".",
"AppendTo",
"(",
"b",
")",
"\n",
"b",
"=",
"appendCLRF",
"(",
"b",
")",... | // AppendTo appends all session lines to b and returns b. | [
"AppendTo",
"appends",
"all",
"session",
"lines",
"to",
"b",
"and",
"returns",
"b",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/sdp.go#L167-L173 |
15,742 | gortc/sdp | sdp.go | Equal | func (s Session) Equal(b Session) bool {
if len(s) != len(b) {
return false
}
for i := range s {
if !s[i].Equal(b[i]) {
return false
}
}
return true
} | go | func (s Session) Equal(b Session) bool {
if len(s) != len(b) {
return false
}
for i := range s {
if !s[i].Equal(b[i]) {
return false
}
}
return true
} | [
"func",
"(",
"s",
"Session",
")",
"Equal",
"(",
"b",
"Session",
")",
"bool",
"{",
"if",
"len",
"(",
"s",
")",
"!=",
"len",
"(",
"b",
")",
"{",
"return",
"false",
"\n",
"}",
"\n",
"for",
"i",
":=",
"range",
"s",
"{",
"if",
"!",
"s",
"[",
"i"... | // Equal returns true if b == s. | [
"Equal",
"returns",
"true",
"if",
"b",
"==",
"s",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/sdp.go#L176-L186 |
15,743 | gortc/sdp | message.go | Value | func (a Attributes) Value(attribute string) string {
for _, v := range a {
if v.Key == attribute {
return v.Value
}
}
return blank
} | go | func (a Attributes) Value(attribute string) string {
for _, v := range a {
if v.Key == attribute {
return v.Value
}
}
return blank
} | [
"func",
"(",
"a",
"Attributes",
")",
"Value",
"(",
"attribute",
"string",
")",
"string",
"{",
"for",
"_",
",",
"v",
":=",
"range",
"a",
"{",
"if",
"v",
".",
"Key",
"==",
"attribute",
"{",
"return",
"v",
".",
"Value",
"\n",
"}",
"\n",
"}",
"\n",
... | // Value returns value of first attribute. | [
"Value",
"returns",
"value",
"of",
"first",
"attribute",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/message.go#L18-L25 |
15,744 | gortc/sdp | message.go | Values | func (a Attributes) Values(attribute string) []string {
var values []string
for _, v := range a {
if v.Key == attribute {
values = append(values, v.Value)
}
}
return values
} | go | func (a Attributes) Values(attribute string) []string {
var values []string
for _, v := range a {
if v.Key == attribute {
values = append(values, v.Value)
}
}
return values
} | [
"func",
"(",
"a",
"Attributes",
")",
"Values",
"(",
"attribute",
"string",
")",
"[",
"]",
"string",
"{",
"var",
"values",
"[",
"]",
"string",
"\n",
"for",
"_",
",",
"v",
":=",
"range",
"a",
"{",
"if",
"v",
".",
"Key",
"==",
"attribute",
"{",
"val... | // Values returns list of values associated to attribute. | [
"Values",
"returns",
"list",
"of",
"values",
"associated",
"to",
"attribute",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/message.go#L28-L36 |
15,745 | gortc/sdp | message.go | Start | func (m *Message) Start() time.Time {
if len(m.Timing) == 0 {
return time.Time{}
}
return m.Timing[0].Start
} | go | func (m *Message) Start() time.Time {
if len(m.Timing) == 0 {
return time.Time{}
}
return m.Timing[0].Start
} | [
"func",
"(",
"m",
"*",
"Message",
")",
"Start",
"(",
")",
"time",
".",
"Time",
"{",
"if",
"len",
"(",
"m",
".",
"Timing",
")",
"==",
"0",
"{",
"return",
"time",
".",
"Time",
"{",
"}",
"\n",
"}",
"\n",
"return",
"m",
".",
"Timing",
"[",
"0",
... | // Start returns start of session. | [
"Start",
"returns",
"start",
"of",
"session",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/message.go#L77-L82 |
15,746 | gortc/sdp | message.go | End | func (m *Message) End() time.Time {
if len(m.Timing) == 0 {
return time.Time{}
}
return m.Timing[0].End
} | go | func (m *Message) End() time.Time {
if len(m.Timing) == 0 {
return time.Time{}
}
return m.Timing[0].End
} | [
"func",
"(",
"m",
"*",
"Message",
")",
"End",
"(",
")",
"time",
".",
"Time",
"{",
"if",
"len",
"(",
"m",
".",
"Timing",
")",
"==",
"0",
"{",
"return",
"time",
".",
"Time",
"{",
"}",
"\n",
"}",
"\n",
"return",
"m",
".",
"Timing",
"[",
"0",
"... | // End returns end of session. | [
"End",
"returns",
"end",
"of",
"session",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/message.go#L85-L90 |
15,747 | gortc/sdp | message.go | PayloadFormat | func (m *Media) PayloadFormat(payloadType string) string {
for _, v := range m.Attributes.Values("rtpmap") {
if strings.HasPrefix(v, payloadType) {
return strings.TrimSpace(
strings.TrimPrefix(v, payloadType),
)
}
}
return ""
} | go | func (m *Media) PayloadFormat(payloadType string) string {
for _, v := range m.Attributes.Values("rtpmap") {
if strings.HasPrefix(v, payloadType) {
return strings.TrimSpace(
strings.TrimPrefix(v, payloadType),
)
}
}
return ""
} | [
"func",
"(",
"m",
"*",
"Media",
")",
"PayloadFormat",
"(",
"payloadType",
"string",
")",
"string",
"{",
"for",
"_",
",",
"v",
":=",
"range",
"m",
".",
"Attributes",
".",
"Values",
"(",
"\"",
"\"",
")",
"{",
"if",
"strings",
".",
"HasPrefix",
"(",
"... | // PayloadFormat returns payload format from a=rtpmap.
// See RFC 4566 Section 6. | [
"PayloadFormat",
"returns",
"payload",
"format",
"from",
"a",
"=",
"rtpmap",
".",
"See",
"RFC",
"4566",
"Section",
"6",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/message.go#L152-L161 |
15,748 | gortc/sdp | fields.go | appendUint | func appendUint(dst []byte, n int) []byte {
if n < 0 {
panic("BUG: n should be positive")
}
var b [20]byte
buf := b[:]
i := len(buf)
var q int
for n >= 10 {
i--
q = n / 10
buf[i] = '0' + byte(n-q*10)
n = q
}
i--
buf[i] = '0' + byte(n)
dst = append(dst, buf[i:]...)
return dst
} | go | func appendUint(dst []byte, n int) []byte {
if n < 0 {
panic("BUG: n should be positive")
}
var b [20]byte
buf := b[:]
i := len(buf)
var q int
for n >= 10 {
i--
q = n / 10
buf[i] = '0' + byte(n-q*10)
n = q
}
i--
buf[i] = '0' + byte(n)
dst = append(dst, buf[i:]...)
return dst
} | [
"func",
"appendUint",
"(",
"dst",
"[",
"]",
"byte",
",",
"n",
"int",
")",
"[",
"]",
"byte",
"{",
"if",
"n",
"<",
"0",
"{",
"panic",
"(",
"\"",
"\"",
")",
"\n",
"}",
"\n",
"var",
"b",
"[",
"20",
"]",
"byte",
"\n",
"buf",
":=",
"b",
"[",
":... | // AppendUint appends n to dst and returns the extended dst. | [
"AppendUint",
"appends",
"n",
"to",
"dst",
"and",
"returns",
"the",
"extended",
"dst",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L27-L45 |
15,749 | gortc/sdp | fields.go | AddRaw | func (s Session) AddRaw(k rune, v string) Session {
return s.appendString(Type(k), v)
} | go | func (s Session) AddRaw(k rune, v string) Session {
return s.appendString(Type(k), v)
} | [
"func",
"(",
"s",
"Session",
")",
"AddRaw",
"(",
"k",
"rune",
",",
"v",
"string",
")",
"Session",
"{",
"return",
"s",
".",
"appendString",
"(",
"Type",
"(",
"k",
")",
",",
"v",
")",
"\n",
"}"
] | // AddRaw appends k=v to Session. | [
"AddRaw",
"appends",
"k",
"=",
"v",
"to",
"Session",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L85-L87 |
15,750 | gortc/sdp | fields.go | AddLine | func (s Session) AddLine(t Type, v string) Session {
return s.appendString(t, v)
} | go | func (s Session) AddLine(t Type, v string) Session {
return s.appendString(t, v)
} | [
"func",
"(",
"s",
"Session",
")",
"AddLine",
"(",
"t",
"Type",
",",
"v",
"string",
")",
"Session",
"{",
"return",
"s",
".",
"appendString",
"(",
"t",
",",
"v",
")",
"\n",
"}"
] | // AddLine appends t=v to Session. | [
"AddLine",
"appends",
"t",
"=",
"v",
"to",
"Session",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L90-L92 |
15,751 | gortc/sdp | fields.go | AddVersion | func (s Session) AddVersion(version int) Session {
v := make([]byte, 0, 64)
v = appendInt(v, version)
return s.append(TypeProtocolVersion, v)
} | go | func (s Session) AddVersion(version int) Session {
v := make([]byte, 0, 64)
v = appendInt(v, version)
return s.append(TypeProtocolVersion, v)
} | [
"func",
"(",
"s",
"Session",
")",
"AddVersion",
"(",
"version",
"int",
")",
"Session",
"{",
"v",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"64",
")",
"\n",
"v",
"=",
"appendInt",
"(",
"v",
",",
"version",
")",
"\n",
"return",
"s",
"."... | // AddVersion appends Version field to Session. | [
"AddVersion",
"appends",
"Version",
"field",
"to",
"Session",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L95-L99 |
15,752 | gortc/sdp | fields.go | AddPhone | func (s Session) AddPhone(phone string) Session {
return s.appendString(TypePhone, phone)
} | go | func (s Session) AddPhone(phone string) Session {
return s.appendString(TypePhone, phone)
} | [
"func",
"(",
"s",
"Session",
")",
"AddPhone",
"(",
"phone",
"string",
")",
"Session",
"{",
"return",
"s",
".",
"appendString",
"(",
"TypePhone",
",",
"phone",
")",
"\n",
"}"
] | // AddPhone appends Phone Address field to Session. | [
"AddPhone",
"appends",
"Phone",
"Address",
"field",
"to",
"Session",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L102-L104 |
15,753 | gortc/sdp | fields.go | AddEmail | func (s Session) AddEmail(email string) Session {
return s.appendString(TypeEmail, email)
} | go | func (s Session) AddEmail(email string) Session {
return s.appendString(TypeEmail, email)
} | [
"func",
"(",
"s",
"Session",
")",
"AddEmail",
"(",
"email",
"string",
")",
"Session",
"{",
"return",
"s",
".",
"appendString",
"(",
"TypeEmail",
",",
"email",
")",
"\n",
"}"
] | // AddEmail appends Email Address field to Session. | [
"AddEmail",
"appends",
"Email",
"Address",
"field",
"to",
"Session",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L107-L109 |
15,754 | gortc/sdp | fields.go | AddConnectionData | func (s Session) AddConnectionData(data ConnectionData) Session {
v := make([]byte, 0, 512)
v = append(v, data.getNetworkType()...)
v = appendSpace(v)
v = append(v, data.getAddressType()...)
v = appendSpace(v)
v = data.appendAddress(v)
return s.append(TypeConnectionData, v)
} | go | func (s Session) AddConnectionData(data ConnectionData) Session {
v := make([]byte, 0, 512)
v = append(v, data.getNetworkType()...)
v = appendSpace(v)
v = append(v, data.getAddressType()...)
v = appendSpace(v)
v = data.appendAddress(v)
return s.append(TypeConnectionData, v)
} | [
"func",
"(",
"s",
"Session",
")",
"AddConnectionData",
"(",
"data",
"ConnectionData",
")",
"Session",
"{",
"v",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"512",
")",
"\n",
"v",
"=",
"append",
"(",
"v",
",",
"data",
".",
"getNetworkType",
... | // AddConnectionData appends Connection Data field to Session
// using ConnectionData struct with sensible defaults. | [
"AddConnectionData",
"appends",
"Connection",
"Data",
"field",
"to",
"Session",
"using",
"ConnectionData",
"struct",
"with",
"sensible",
"defaults",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L113-L121 |
15,755 | gortc/sdp | fields.go | AddConnectionDataIP | func (s Session) AddConnectionDataIP(ip net.IP) Session {
return s.AddConnectionData(ConnectionData{
IP: ip,
})
} | go | func (s Session) AddConnectionDataIP(ip net.IP) Session {
return s.AddConnectionData(ConnectionData{
IP: ip,
})
} | [
"func",
"(",
"s",
"Session",
")",
"AddConnectionDataIP",
"(",
"ip",
"net",
".",
"IP",
")",
"Session",
"{",
"return",
"s",
".",
"AddConnectionData",
"(",
"ConnectionData",
"{",
"IP",
":",
"ip",
",",
"}",
")",
"\n",
"}"
] | // AddConnectionDataIP appends Connection Data field using only ip address. | [
"AddConnectionDataIP",
"appends",
"Connection",
"Data",
"field",
"using",
"only",
"ip",
"address",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L124-L128 |
15,756 | gortc/sdp | fields.go | AddSessionName | func (s Session) AddSessionName(name string) Session {
return s.appendString(TypeSessionName, name)
} | go | func (s Session) AddSessionName(name string) Session {
return s.appendString(TypeSessionName, name)
} | [
"func",
"(",
"s",
"Session",
")",
"AddSessionName",
"(",
"name",
"string",
")",
"Session",
"{",
"return",
"s",
".",
"appendString",
"(",
"TypeSessionName",
",",
"name",
")",
"\n",
"}"
] | // AddSessionName appends Session Name field to Session. | [
"AddSessionName",
"appends",
"Session",
"Name",
"field",
"to",
"Session",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L131-L133 |
15,757 | gortc/sdp | fields.go | AddSessionInfo | func (s Session) AddSessionInfo(info string) Session {
return s.appendString(TypeSessionInformation, info)
} | go | func (s Session) AddSessionInfo(info string) Session {
return s.appendString(TypeSessionInformation, info)
} | [
"func",
"(",
"s",
"Session",
")",
"AddSessionInfo",
"(",
"info",
"string",
")",
"Session",
"{",
"return",
"s",
".",
"appendString",
"(",
"TypeSessionInformation",
",",
"info",
")",
"\n",
"}"
] | // AddSessionInfo appends Session Information field to Session. | [
"AddSessionInfo",
"appends",
"Session",
"Information",
"field",
"to",
"Session",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L136-L138 |
15,758 | gortc/sdp | fields.go | AddURI | func (s Session) AddURI(uri string) Session {
return s.appendString(TypeURI, uri)
} | go | func (s Session) AddURI(uri string) Session {
return s.appendString(TypeURI, uri)
} | [
"func",
"(",
"s",
"Session",
")",
"AddURI",
"(",
"uri",
"string",
")",
"Session",
"{",
"return",
"s",
".",
"appendString",
"(",
"TypeURI",
",",
"uri",
")",
"\n",
"}"
] | // AddURI appends Uniform Resource Identifier field to Session. | [
"AddURI",
"appends",
"Uniform",
"Resource",
"Identifier",
"field",
"to",
"Session",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L141-L143 |
15,759 | gortc/sdp | fields.go | Equal | func (c ConnectionData) Equal(b ConnectionData) bool {
if c.NetworkType != b.NetworkType {
return false
}
if c.AddressType != b.AddressType {
return false
}
if !c.IP.Equal(b.IP) {
return false
}
if c.TTL != b.TTL {
return false
}
if c.Addresses != b.Addresses {
return false
}
return true
} | go | func (c ConnectionData) Equal(b ConnectionData) bool {
if c.NetworkType != b.NetworkType {
return false
}
if c.AddressType != b.AddressType {
return false
}
if !c.IP.Equal(b.IP) {
return false
}
if c.TTL != b.TTL {
return false
}
if c.Addresses != b.Addresses {
return false
}
return true
} | [
"func",
"(",
"c",
"ConnectionData",
")",
"Equal",
"(",
"b",
"ConnectionData",
")",
"bool",
"{",
"if",
"c",
".",
"NetworkType",
"!=",
"b",
".",
"NetworkType",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"c",
".",
"AddressType",
"!=",
"b",
".",
"Add... | // Equal returns c == b. | [
"Equal",
"returns",
"c",
"==",
"b",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L162-L179 |
15,760 | gortc/sdp | fields.go | Equal | func (o *Origin) Equal(b Origin) bool {
if o.Username != b.Username {
return false
}
if o.SessionID != b.SessionID {
return false
}
if o.SessionVersion != b.SessionVersion {
return false
}
if o.NetworkType != b.NetworkType {
return false
}
if o.AddressType != b.AddressType {
return false
}
if o.Address != b.Address {
return false
}
return true
} | go | func (o *Origin) Equal(b Origin) bool {
if o.Username != b.Username {
return false
}
if o.SessionID != b.SessionID {
return false
}
if o.SessionVersion != b.SessionVersion {
return false
}
if o.NetworkType != b.NetworkType {
return false
}
if o.AddressType != b.AddressType {
return false
}
if o.Address != b.Address {
return false
}
return true
} | [
"func",
"(",
"o",
"*",
"Origin",
")",
"Equal",
"(",
"b",
"Origin",
")",
"bool",
"{",
"if",
"o",
".",
"Username",
"!=",
"b",
".",
"Username",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"o",
".",
"SessionID",
"!=",
"b",
".",
"SessionID",
"{",
... | // Equal returns b == o. | [
"Equal",
"returns",
"b",
"==",
"o",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L283-L303 |
15,761 | gortc/sdp | fields.go | AddOrigin | func (s Session) AddOrigin(o Origin) Session {
v := make([]byte, 0, 2048)
v = appendSpace(append(v, o.Username...))
v = appendSpace(appendInt(v, o.SessionID))
v = appendSpace(appendInt(v, o.SessionVersion))
v = appendSpace(append(v, o.getNetworkType()...))
v = appendSpace(append(v, o.getAddressType()...))
v = append(v, o.Address...)
return s.append(TypeOrigin, v)
} | go | func (s Session) AddOrigin(o Origin) Session {
v := make([]byte, 0, 2048)
v = appendSpace(append(v, o.Username...))
v = appendSpace(appendInt(v, o.SessionID))
v = appendSpace(appendInt(v, o.SessionVersion))
v = appendSpace(append(v, o.getNetworkType()...))
v = appendSpace(append(v, o.getAddressType()...))
v = append(v, o.Address...)
return s.append(TypeOrigin, v)
} | [
"func",
"(",
"s",
"Session",
")",
"AddOrigin",
"(",
"o",
"Origin",
")",
"Session",
"{",
"v",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"2048",
")",
"\n",
"v",
"=",
"appendSpace",
"(",
"append",
"(",
"v",
",",
"o",
".",
"Username",
"..... | // AddOrigin appends Origin field to Session. | [
"AddOrigin",
"appends",
"Origin",
"field",
"to",
"Session",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L306-L315 |
15,762 | gortc/sdp | fields.go | TimeToNTP | func TimeToNTP(t time.Time) uint64 {
if t.IsZero() {
return 0
}
return uint64(t.Unix()) + ntpDelta
} | go | func TimeToNTP(t time.Time) uint64 {
if t.IsZero() {
return 0
}
return uint64(t.Unix()) + ntpDelta
} | [
"func",
"TimeToNTP",
"(",
"t",
"time",
".",
"Time",
")",
"uint64",
"{",
"if",
"t",
".",
"IsZero",
"(",
")",
"{",
"return",
"0",
"\n",
"}",
"\n",
"return",
"uint64",
"(",
"t",
".",
"Unix",
"(",
")",
")",
"+",
"ntpDelta",
"\n",
"}"
] | // TimeToNTP converts time.Time to NTP timestamp with special case for Zero
// time, that is interpreted as 0 timestamp. | [
"TimeToNTP",
"converts",
"time",
".",
"Time",
"to",
"NTP",
"timestamp",
"with",
"special",
"case",
"for",
"Zero",
"time",
"that",
"is",
"interpreted",
"as",
"0",
"timestamp",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L324-L329 |
15,763 | gortc/sdp | fields.go | NTPToTime | func NTPToTime(v uint64) time.Time {
if v == 0 {
return time.Time{}
}
return time.Unix(int64(v-ntpDelta), 0)
} | go | func NTPToTime(v uint64) time.Time {
if v == 0 {
return time.Time{}
}
return time.Unix(int64(v-ntpDelta), 0)
} | [
"func",
"NTPToTime",
"(",
"v",
"uint64",
")",
"time",
".",
"Time",
"{",
"if",
"v",
"==",
"0",
"{",
"return",
"time",
".",
"Time",
"{",
"}",
"\n",
"}",
"\n",
"return",
"time",
".",
"Unix",
"(",
"int64",
"(",
"v",
"-",
"ntpDelta",
")",
",",
"0",
... | // NTPToTime converts NTP timestamp to time.Time with special case for Zero
// time, that is interpreted as 0 timestamp. | [
"NTPToTime",
"converts",
"NTP",
"timestamp",
"to",
"time",
".",
"Time",
"with",
"special",
"case",
"for",
"Zero",
"time",
"that",
"is",
"interpreted",
"as",
"0",
"timestamp",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L333-L338 |
15,764 | gortc/sdp | fields.go | AddTiming | func (s Session) AddTiming(start, end time.Time) Session {
v := make([]byte, 0, 256)
v = appendUint64(v, TimeToNTP(start))
v = appendSpace(v)
v = appendUint64(v, TimeToNTP(end))
return s.append(TypeTiming, v)
} | go | func (s Session) AddTiming(start, end time.Time) Session {
v := make([]byte, 0, 256)
v = appendUint64(v, TimeToNTP(start))
v = appendSpace(v)
v = appendUint64(v, TimeToNTP(end))
return s.append(TypeTiming, v)
} | [
"func",
"(",
"s",
"Session",
")",
"AddTiming",
"(",
"start",
",",
"end",
"time",
".",
"Time",
")",
"Session",
"{",
"v",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"256",
")",
"\n",
"v",
"=",
"appendUint64",
"(",
"v",
",",
"TimeToNTP",
... | // AddTiming appends Timing field to Session. Both start and end can be zero. | [
"AddTiming",
"appends",
"Timing",
"field",
"to",
"Session",
".",
"Both",
"start",
"and",
"end",
"can",
"be",
"zero",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L345-L351 |
15,765 | gortc/sdp | fields.go | AddTimingNTP | func (s Session) AddTimingNTP(start, end uint64) Session {
return s.AddTiming(NTPToTime(start), NTPToTime(end))
} | go | func (s Session) AddTimingNTP(start, end uint64) Session {
return s.AddTiming(NTPToTime(start), NTPToTime(end))
} | [
"func",
"(",
"s",
"Session",
")",
"AddTimingNTP",
"(",
"start",
",",
"end",
"uint64",
")",
"Session",
"{",
"return",
"s",
".",
"AddTiming",
"(",
"NTPToTime",
"(",
"start",
")",
",",
"NTPToTime",
"(",
"end",
")",
")",
"\n",
"}"
] | // AddTimingNTP appends Timing field to Session with NTP timestamps as input.
// It is just wrapper for AddTiming and NTPToTime. | [
"AddTimingNTP",
"appends",
"Timing",
"field",
"to",
"Session",
"with",
"NTP",
"timestamps",
"as",
"input",
".",
"It",
"is",
"just",
"wrapper",
"for",
"AddTiming",
"and",
"NTPToTime",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L355-L357 |
15,766 | gortc/sdp | fields.go | AddBandwidth | func (s Session) AddBandwidth(t BandwidthType, bandwidth int) Session {
v := make([]byte, 0, 128)
v = append(v, string(t)...)
v = appendRune(v, ':')
v = appendInt(v, bandwidth)
return s.append(TypeBandwidth, v)
} | go | func (s Session) AddBandwidth(t BandwidthType, bandwidth int) Session {
v := make([]byte, 0, 128)
v = append(v, string(t)...)
v = appendRune(v, ':')
v = appendInt(v, bandwidth)
return s.append(TypeBandwidth, v)
} | [
"func",
"(",
"s",
"Session",
")",
"AddBandwidth",
"(",
"t",
"BandwidthType",
",",
"bandwidth",
"int",
")",
"Session",
"{",
"v",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"128",
")",
"\n",
"v",
"=",
"append",
"(",
"v",
",",
"string",
"("... | // AddBandwidth appends Bandwidth field to Session. | [
"AddBandwidth",
"appends",
"Bandwidth",
"field",
"to",
"Session",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L390-L396 |
15,767 | gortc/sdp | fields.go | AddRepeatTimes | func (s Session) AddRepeatTimes(interval, duration time.Duration,
offsets ...time.Duration) Session {
return s.addRepeatTimes(false, interval, duration, offsets...)
} | go | func (s Session) AddRepeatTimes(interval, duration time.Duration,
offsets ...time.Duration) Session {
return s.addRepeatTimes(false, interval, duration, offsets...)
} | [
"func",
"(",
"s",
"Session",
")",
"AddRepeatTimes",
"(",
"interval",
",",
"duration",
"time",
".",
"Duration",
",",
"offsets",
"...",
"time",
".",
"Duration",
")",
"Session",
"{",
"return",
"s",
".",
"addRepeatTimes",
"(",
"false",
",",
"interval",
",",
... | // AddRepeatTimes appends Repeat Times field to Session. | [
"AddRepeatTimes",
"appends",
"Repeat",
"Times",
"field",
"to",
"Session",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L451-L454 |
15,768 | gortc/sdp | fields.go | AddRepeatTimesCompact | func (s Session) AddRepeatTimesCompact(interval, duration time.Duration,
offsets ...time.Duration) Session {
return s.addRepeatTimes(true, interval, duration, offsets...)
} | go | func (s Session) AddRepeatTimesCompact(interval, duration time.Duration,
offsets ...time.Duration) Session {
return s.addRepeatTimes(true, interval, duration, offsets...)
} | [
"func",
"(",
"s",
"Session",
")",
"AddRepeatTimesCompact",
"(",
"interval",
",",
"duration",
"time",
".",
"Duration",
",",
"offsets",
"...",
"time",
".",
"Duration",
")",
"Session",
"{",
"return",
"s",
".",
"addRepeatTimes",
"(",
"true",
",",
"interval",
"... | // AddRepeatTimesCompact appends Repeat Times field to Session using "compact"
// syntax. | [
"AddRepeatTimesCompact",
"appends",
"Repeat",
"Times",
"field",
"to",
"Session",
"using",
"compact",
"syntax",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L458-L461 |
15,769 | gortc/sdp | fields.go | Equal | func (m MediaDescription) Equal(b MediaDescription) bool {
if m.Type != b.Type {
return false
}
if m.Port != b.Port {
return false
}
if m.PortsNumber != b.PortsNumber {
return false
}
if m.Protocol != b.Protocol {
return false
}
if len(m.Formats) != len(b.Formats) {
return false
}
for i := range m.Formats {
if m.Formats[i] != b.Formats[i] {
return false
}
}
return true
} | go | func (m MediaDescription) Equal(b MediaDescription) bool {
if m.Type != b.Type {
return false
}
if m.Port != b.Port {
return false
}
if m.PortsNumber != b.PortsNumber {
return false
}
if m.Protocol != b.Protocol {
return false
}
if len(m.Formats) != len(b.Formats) {
return false
}
for i := range m.Formats {
if m.Formats[i] != b.Formats[i] {
return false
}
}
return true
} | [
"func",
"(",
"m",
"MediaDescription",
")",
"Equal",
"(",
"b",
"MediaDescription",
")",
"bool",
"{",
"if",
"m",
".",
"Type",
"!=",
"b",
".",
"Type",
"{",
"return",
"false",
"\n",
"}",
"\n",
"if",
"m",
".",
"Port",
"!=",
"b",
".",
"Port",
"{",
"ret... | // Equal returns true if b equals to m. | [
"Equal",
"returns",
"true",
"if",
"b",
"equals",
"to",
"m",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L473-L495 |
15,770 | gortc/sdp | fields.go | AddMediaDescription | func (s Session) AddMediaDescription(m MediaDescription) Session {
v := make([]byte, 0, 512)
v = appendSpace(append(v, m.Type...))
v = appendInt(v, m.Port)
if m.PortsNumber != 0 {
v = appendRune(v, '/')
v = appendInt(v, m.PortsNumber)
}
v = appendSpace(v)
v = appendSpace(append(v, m.Protocol...))
for i := range m.Formats {
v = append(v, m.Formats[i]...)
if i != len(m.Formats)-1 {
v = appendRune(v, fieldsDelimiter)
}
}
return s.append(TypeMediaDescription, v)
} | go | func (s Session) AddMediaDescription(m MediaDescription) Session {
v := make([]byte, 0, 512)
v = appendSpace(append(v, m.Type...))
v = appendInt(v, m.Port)
if m.PortsNumber != 0 {
v = appendRune(v, '/')
v = appendInt(v, m.PortsNumber)
}
v = appendSpace(v)
v = appendSpace(append(v, m.Protocol...))
for i := range m.Formats {
v = append(v, m.Formats[i]...)
if i != len(m.Formats)-1 {
v = appendRune(v, fieldsDelimiter)
}
}
return s.append(TypeMediaDescription, v)
} | [
"func",
"(",
"s",
"Session",
")",
"AddMediaDescription",
"(",
"m",
"MediaDescription",
")",
"Session",
"{",
"v",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"512",
")",
"\n",
"v",
"=",
"appendSpace",
"(",
"append",
"(",
"v",
",",
"m",
".",
... | // AddMediaDescription appends Media Description field to Session. | [
"AddMediaDescription",
"appends",
"Media",
"Description",
"field",
"to",
"Session",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L498-L515 |
15,771 | gortc/sdp | fields.go | AddEncryption | func (s Session) AddEncryption(e Encryption) Session {
return s.AddEncryptionKey(e.Method, e.Key)
} | go | func (s Session) AddEncryption(e Encryption) Session {
return s.AddEncryptionKey(e.Method, e.Key)
} | [
"func",
"(",
"s",
"Session",
")",
"AddEncryption",
"(",
"e",
"Encryption",
")",
"Session",
"{",
"return",
"s",
".",
"AddEncryptionKey",
"(",
"e",
".",
"Method",
",",
"e",
".",
"Key",
")",
"\n",
"}"
] | // AddEncryption appends Encryption and is shorthand for AddEncryptionKey. | [
"AddEncryption",
"appends",
"Encryption",
"and",
"is",
"shorthand",
"for",
"AddEncryptionKey",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L518-L520 |
15,772 | gortc/sdp | fields.go | AddTimeZones | func (s Session) AddTimeZones(zones ...TimeZone) Session {
v := make([]byte, 0, 512)
for i, zone := range zones {
v = zone.append(v)
if i != len(zones)-1 {
v = appendSpace(v)
}
}
return s.append(TypeTimeZones, v)
} | go | func (s Session) AddTimeZones(zones ...TimeZone) Session {
v := make([]byte, 0, 512)
for i, zone := range zones {
v = zone.append(v)
if i != len(zones)-1 {
v = appendSpace(v)
}
}
return s.append(TypeTimeZones, v)
} | [
"func",
"(",
"s",
"Session",
")",
"AddTimeZones",
"(",
"zones",
"...",
"TimeZone",
")",
"Session",
"{",
"v",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"0",
",",
"512",
")",
"\n",
"for",
"i",
",",
"zone",
":=",
"range",
"zones",
"{",
"v",
"=",
"... | // AddTimeZones append TimeZones field to Session. | [
"AddTimeZones",
"append",
"TimeZones",
"field",
"to",
"Session",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/fields.go#L558-L567 |
15,773 | gortc/sdp | decoder.go | isKnown | func isKnown(t Type) bool {
switch t {
case TypeProtocolVersion,
TypeOrigin, TypeSessionName,
TypeSessionInformation, TypeURI,
TypeEmail, TypePhone,
TypeConnectionData, TypeBandwidth,
TypeTiming, TypeRepeatTimes,
TypeTimeZones, TypeEncryptionKey,
TypeAttribute, TypeMediaDescription:
return true
default:
return false
}
} | go | func isKnown(t Type) bool {
switch t {
case TypeProtocolVersion,
TypeOrigin, TypeSessionName,
TypeSessionInformation, TypeURI,
TypeEmail, TypePhone,
TypeConnectionData, TypeBandwidth,
TypeTiming, TypeRepeatTimes,
TypeTimeZones, TypeEncryptionKey,
TypeAttribute, TypeMediaDescription:
return true
default:
return false
}
} | [
"func",
"isKnown",
"(",
"t",
"Type",
")",
"bool",
"{",
"switch",
"t",
"{",
"case",
"TypeProtocolVersion",
",",
"TypeOrigin",
",",
"TypeSessionName",
",",
"TypeSessionInformation",
",",
"TypeURI",
",",
"TypeEmail",
",",
"TypePhone",
",",
"TypeConnectionData",
","... | // isKnown returns true if t is defined in RFC 4566. | [
"isKnown",
"returns",
"true",
"if",
"t",
"is",
"defined",
"in",
"RFC",
"4566",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/decoder.go#L111-L125 |
15,774 | gortc/sdp | decoder.go | isExpected | func isExpected(t Type, s section, pos int) error {
o := getOrdering(s)
if len(o) > pos {
for _, expected := range o[pos:] {
if expected == t {
return nil
}
if isOptional(expected) {
continue
}
}
}
// Checking possible section transitions.
switch s {
case sectionSession:
if pos < orderingAfterTime && isExpected(t, sectionTime, 0) == nil {
return nil
}
if isExpected(t, sectionMedia, 0) == nil {
return nil
}
case sectionTime:
if isExpected(t, sectionSession, orderingAfterTime) == nil {
return nil
}
case sectionMedia:
if pos != 0 && isExpected(t, sectionMedia, 0) == nil {
return nil
}
}
if !isKnown(t) {
return errUnknownType
}
// Attribute is known, but out of order.
msg := fmt.Sprintf("no matches in ordering array at %s[%d] for %s",
s, pos, t,
)
err := newSectionDecodeError(s, msg)
return errors.Wrapf(err, "field %s is unexpected", t)
} | go | func isExpected(t Type, s section, pos int) error {
o := getOrdering(s)
if len(o) > pos {
for _, expected := range o[pos:] {
if expected == t {
return nil
}
if isOptional(expected) {
continue
}
}
}
// Checking possible section transitions.
switch s {
case sectionSession:
if pos < orderingAfterTime && isExpected(t, sectionTime, 0) == nil {
return nil
}
if isExpected(t, sectionMedia, 0) == nil {
return nil
}
case sectionTime:
if isExpected(t, sectionSession, orderingAfterTime) == nil {
return nil
}
case sectionMedia:
if pos != 0 && isExpected(t, sectionMedia, 0) == nil {
return nil
}
}
if !isKnown(t) {
return errUnknownType
}
// Attribute is known, but out of order.
msg := fmt.Sprintf("no matches in ordering array at %s[%d] for %s",
s, pos, t,
)
err := newSectionDecodeError(s, msg)
return errors.Wrapf(err, "field %s is unexpected", t)
} | [
"func",
"isExpected",
"(",
"t",
"Type",
",",
"s",
"section",
",",
"pos",
"int",
")",
"error",
"{",
"o",
":=",
"getOrdering",
"(",
"s",
")",
"\n",
"if",
"len",
"(",
"o",
")",
">",
"pos",
"{",
"for",
"_",
",",
"expected",
":=",
"range",
"o",
"[",... | // isExpected determines if t is expected on pos in s section and returns nil,
// if it is expected and DecodeError if not. | [
"isExpected",
"determines",
"if",
"t",
"is",
"expected",
"on",
"pos",
"in",
"s",
"section",
"and",
"returns",
"nil",
"if",
"it",
"is",
"expected",
"and",
"DecodeError",
"if",
"not",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/decoder.go#L129-L169 |
15,775 | gortc/sdp | encoder.go | Append | func (m *Message) Append(s Session) Session {
s = s.AddVersion(m.Version)
s = s.AddOrigin(m.Origin)
s = s.AddSessionName(m.Name)
if len(m.Info) > 0 {
s = s.AddSessionInfo(m.Info)
}
if len(m.URI) > 0 {
s = s.AddURI(m.URI)
}
if len(m.Email) > 0 {
s = s.AddEmail(m.Email)
}
if len(m.Phone) > 0 {
s = s.AddPhone(m.Phone)
}
if !m.Connection.Blank() {
s = s.AddConnectionData(m.Connection)
}
for t, v := range m.Bandwidths {
s = s.AddBandwidth(t, v)
}
// One or more time descriptions ("t=" and "r=" lines)
for _, t := range m.Timing {
s = s.AddTiming(t.Start, t.End)
if len(t.Offsets) > 0 {
s = s.AddRepeatTimesCompact(t.Repeat, t.Active, t.Offsets...)
}
}
if len(m.TZAdjustments) > 0 {
s = s.AddTimeZones(m.TZAdjustments...)
}
if !m.Encryption.Blank() {
s = s.AddEncryption(m.Encryption)
}
s = s.appendAttributes(m.Attributes)
for i := range m.Medias {
s = s.AddMediaDescription(m.Medias[i].Description)
if len(m.Medias[i].Title) > 0 {
s = s.AddSessionInfo(m.Medias[i].Title)
}
if !m.Medias[i].Connection.Blank() {
s = s.AddConnectionData(m.Medias[i].Connection)
}
for t, v := range m.Medias[i].Bandwidths {
s = s.AddBandwidth(t, v)
}
if !m.Medias[i].Encryption.Blank() {
s = s.AddEncryption(m.Medias[i].Encryption)
}
s = s.appendAttributes(m.Medias[i].Attributes)
}
return s
} | go | func (m *Message) Append(s Session) Session {
s = s.AddVersion(m.Version)
s = s.AddOrigin(m.Origin)
s = s.AddSessionName(m.Name)
if len(m.Info) > 0 {
s = s.AddSessionInfo(m.Info)
}
if len(m.URI) > 0 {
s = s.AddURI(m.URI)
}
if len(m.Email) > 0 {
s = s.AddEmail(m.Email)
}
if len(m.Phone) > 0 {
s = s.AddPhone(m.Phone)
}
if !m.Connection.Blank() {
s = s.AddConnectionData(m.Connection)
}
for t, v := range m.Bandwidths {
s = s.AddBandwidth(t, v)
}
// One or more time descriptions ("t=" and "r=" lines)
for _, t := range m.Timing {
s = s.AddTiming(t.Start, t.End)
if len(t.Offsets) > 0 {
s = s.AddRepeatTimesCompact(t.Repeat, t.Active, t.Offsets...)
}
}
if len(m.TZAdjustments) > 0 {
s = s.AddTimeZones(m.TZAdjustments...)
}
if !m.Encryption.Blank() {
s = s.AddEncryption(m.Encryption)
}
s = s.appendAttributes(m.Attributes)
for i := range m.Medias {
s = s.AddMediaDescription(m.Medias[i].Description)
if len(m.Medias[i].Title) > 0 {
s = s.AddSessionInfo(m.Medias[i].Title)
}
if !m.Medias[i].Connection.Blank() {
s = s.AddConnectionData(m.Medias[i].Connection)
}
for t, v := range m.Medias[i].Bandwidths {
s = s.AddBandwidth(t, v)
}
if !m.Medias[i].Encryption.Blank() {
s = s.AddEncryption(m.Medias[i].Encryption)
}
s = s.appendAttributes(m.Medias[i].Attributes)
}
return s
} | [
"func",
"(",
"m",
"*",
"Message",
")",
"Append",
"(",
"s",
"Session",
")",
"Session",
"{",
"s",
"=",
"s",
".",
"AddVersion",
"(",
"m",
".",
"Version",
")",
"\n",
"s",
"=",
"s",
".",
"AddOrigin",
"(",
"m",
".",
"Origin",
")",
"\n",
"s",
"=",
"... | // Append encodes message to Session and returns result.
//
// See RFC 4566 Section 5. | [
"Append",
"encodes",
"message",
"to",
"Session",
"and",
"returns",
"result",
".",
"See",
"RFC",
"4566",
"Section",
"5",
"."
] | d420057ced39eaa53ebd2e5465bce76045e848a5 | https://github.com/gortc/sdp/blob/d420057ced39eaa53ebd2e5465bce76045e848a5/encoder.go#L17-L71 |
15,776 | mna/pigeon | builder/builder.go | Optimize | func Optimize(optimize bool) Option {
return func(b *builder) Option {
prev := b.optimize
b.optimize = optimize
return Optimize(prev)
}
} | go | func Optimize(optimize bool) Option {
return func(b *builder) Option {
prev := b.optimize
b.optimize = optimize
return Optimize(prev)
}
} | [
"func",
"Optimize",
"(",
"optimize",
"bool",
")",
"Option",
"{",
"return",
"func",
"(",
"b",
"*",
"builder",
")",
"Option",
"{",
"prev",
":=",
"b",
".",
"optimize",
"\n",
"b",
".",
"optimize",
"=",
"optimize",
"\n",
"return",
"Optimize",
"(",
"prev",
... | // Optimize returns an option that specifies the optimize option
// If optimize is true, the Debug and Memoize code is completely
// removed from the resulting parser | [
"Optimize",
"returns",
"an",
"option",
"that",
"specifies",
"the",
"optimize",
"option",
"If",
"optimize",
"is",
"true",
"the",
"Debug",
"and",
"Memoize",
"code",
"is",
"completely",
"removed",
"from",
"the",
"resulting",
"parser"
] | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/builder/builder.go#L73-L79 |
15,777 | mna/pigeon | builder/builder.go | BuildParser | func BuildParser(w io.Writer, g *ast.Grammar, opts ...Option) error {
b := &builder{w: w, recvName: "c"}
b.setOptions(opts)
return b.buildParser(g)
} | go | func BuildParser(w io.Writer, g *ast.Grammar, opts ...Option) error {
b := &builder{w: w, recvName: "c"}
b.setOptions(opts)
return b.buildParser(g)
} | [
"func",
"BuildParser",
"(",
"w",
"io",
".",
"Writer",
",",
"g",
"*",
"ast",
".",
"Grammar",
",",
"opts",
"...",
"Option",
")",
"error",
"{",
"b",
":=",
"&",
"builder",
"{",
"w",
":",
"w",
",",
"recvName",
":",
"\"",
"\"",
"}",
"\n",
"b",
".",
... | // BuildParser builds the PEG parser using the provider grammar. The code is
// written to the specified w. | [
"BuildParser",
"builds",
"the",
"PEG",
"parser",
"using",
"the",
"provider",
"grammar",
".",
"The",
"code",
"is",
"written",
"to",
"the",
"specified",
"w",
"."
] | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/builder/builder.go#L106-L110 |
15,778 | mna/pigeon | builder/builder.go | BasicLatinLookup | func BasicLatinLookup(chars, ranges []rune, unicodeClasses []string, ignoreCase bool) (basicLatinChars [128]bool) {
for _, rn := range chars {
if rn < 128 {
basicLatinChars[rn] = true
if ignoreCase {
if unicode.IsLower(rn) {
basicLatinChars[unicode.ToUpper(rn)] = true
} else {
basicLatinChars[unicode.ToLower(rn)] = true
}
}
}
}
for i := 0; i < len(ranges); i += 2 {
if ranges[i] < 128 {
for j := ranges[i]; j < 128 && j <= ranges[i+1]; j++ {
basicLatinChars[j] = true
if ignoreCase {
if unicode.IsLower(j) {
basicLatinChars[unicode.ToUpper(j)] = true
} else {
basicLatinChars[unicode.ToLower(j)] = true
}
}
}
}
}
for _, cl := range unicodeClasses {
rt := rangeTable(cl)
for r := rune(0); r < 128; r++ {
if unicode.Is(rt, r) {
basicLatinChars[r] = true
}
}
}
return
} | go | func BasicLatinLookup(chars, ranges []rune, unicodeClasses []string, ignoreCase bool) (basicLatinChars [128]bool) {
for _, rn := range chars {
if rn < 128 {
basicLatinChars[rn] = true
if ignoreCase {
if unicode.IsLower(rn) {
basicLatinChars[unicode.ToUpper(rn)] = true
} else {
basicLatinChars[unicode.ToLower(rn)] = true
}
}
}
}
for i := 0; i < len(ranges); i += 2 {
if ranges[i] < 128 {
for j := ranges[i]; j < 128 && j <= ranges[i+1]; j++ {
basicLatinChars[j] = true
if ignoreCase {
if unicode.IsLower(j) {
basicLatinChars[unicode.ToUpper(j)] = true
} else {
basicLatinChars[unicode.ToLower(j)] = true
}
}
}
}
}
for _, cl := range unicodeClasses {
rt := rangeTable(cl)
for r := rune(0); r < 128; r++ {
if unicode.Is(rt, r) {
basicLatinChars[r] = true
}
}
}
return
} | [
"func",
"BasicLatinLookup",
"(",
"chars",
",",
"ranges",
"[",
"]",
"rune",
",",
"unicodeClasses",
"[",
"]",
"string",
",",
"ignoreCase",
"bool",
")",
"(",
"basicLatinChars",
"[",
"128",
"]",
"bool",
")",
"{",
"for",
"_",
",",
"rn",
":=",
"range",
"char... | // BasicLatinLookup calculates the decision results for the first 256 characters of the UTF-8 character
// set for a given set of chars, ranges and unicodeClasses to speedup the CharClassMatcher. | [
"BasicLatinLookup",
"calculates",
"the",
"decision",
"results",
"for",
"the",
"first",
"256",
"characters",
"of",
"the",
"UTF",
"-",
"8",
"character",
"set",
"for",
"a",
"given",
"set",
"of",
"chars",
"ranges",
"and",
"unicodeClasses",
"to",
"speedup",
"the",
... | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/builder/builder.go#L339-L375 |
15,779 | mna/pigeon | main.go | argError | func argError(exitCode int, msg string, args ...interface{}) {
fmt.Fprintf(os.Stderr, msg, args...)
fmt.Fprintln(os.Stderr)
usage()
exit(exitCode)
} | go | func argError(exitCode int, msg string, args ...interface{}) {
fmt.Fprintf(os.Stderr, msg, args...)
fmt.Fprintln(os.Stderr)
usage()
exit(exitCode)
} | [
"func",
"argError",
"(",
"exitCode",
"int",
",",
"msg",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"fmt",
".",
"Fprintf",
"(",
"os",
".",
"Stderr",
",",
"msg",
",",
"args",
"...",
")",
"\n",
"fmt",
".",
"Fprintln",
"(",
"os",
... | // argError prints an error message to stderr, prints the command usage
// and exits with the specified exit code. | [
"argError",
"prints",
"an",
"error",
"message",
"to",
"stderr",
"prints",
"the",
"command",
"usage",
"and",
"exits",
"with",
"the",
"specified",
"exit",
"code",
"."
] | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/main.go#L221-L226 |
15,780 | mna/pigeon | main.go | input | func input(filename string) (nm string, rc io.ReadCloser) {
nm = "stdin"
inf := os.Stdin
if filename != "" {
f, err := os.Open(filename)
if err != nil {
fmt.Fprintln(os.Stderr, err)
exit(2)
}
inf = f
nm = filename
}
r := bufio.NewReader(inf)
return nm, makeReadCloser(r, inf)
} | go | func input(filename string) (nm string, rc io.ReadCloser) {
nm = "stdin"
inf := os.Stdin
if filename != "" {
f, err := os.Open(filename)
if err != nil {
fmt.Fprintln(os.Stderr, err)
exit(2)
}
inf = f
nm = filename
}
r := bufio.NewReader(inf)
return nm, makeReadCloser(r, inf)
} | [
"func",
"input",
"(",
"filename",
"string",
")",
"(",
"nm",
"string",
",",
"rc",
"io",
".",
"ReadCloser",
")",
"{",
"nm",
"=",
"\"",
"\"",
"\n",
"inf",
":=",
"os",
".",
"Stdin",
"\n",
"if",
"filename",
"!=",
"\"",
"\"",
"{",
"f",
",",
"err",
":... | // input gets the name and reader to get input text from. | [
"input",
"gets",
"the",
"name",
"and",
"reader",
"to",
"get",
"input",
"text",
"from",
"."
] | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/main.go#L229-L243 |
15,781 | mna/pigeon | main.go | output | func output(filename string) io.WriteCloser {
out := os.Stdout
if filename != "" {
f, err := os.Create(filename)
if err != nil {
fmt.Fprintln(os.Stderr, err)
exit(4)
}
out = f
}
return out
} | go | func output(filename string) io.WriteCloser {
out := os.Stdout
if filename != "" {
f, err := os.Create(filename)
if err != nil {
fmt.Fprintln(os.Stderr, err)
exit(4)
}
out = f
}
return out
} | [
"func",
"output",
"(",
"filename",
"string",
")",
"io",
".",
"WriteCloser",
"{",
"out",
":=",
"os",
".",
"Stdout",
"\n",
"if",
"filename",
"!=",
"\"",
"\"",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Create",
"(",
"filename",
")",
"\n",
"if",
"err",
... | // output gets the writer to write the generated parser to. | [
"output",
"gets",
"the",
"writer",
"to",
"write",
"the",
"generated",
"parser",
"to",
"."
] | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/main.go#L246-L257 |
15,782 | mna/pigeon | main.go | makeReadCloser | func makeReadCloser(r io.Reader, c io.Closer) io.ReadCloser {
rc := struct {
io.Reader
io.Closer
}{r, c}
return io.ReadCloser(rc)
} | go | func makeReadCloser(r io.Reader, c io.Closer) io.ReadCloser {
rc := struct {
io.Reader
io.Closer
}{r, c}
return io.ReadCloser(rc)
} | [
"func",
"makeReadCloser",
"(",
"r",
"io",
".",
"Reader",
",",
"c",
"io",
".",
"Closer",
")",
"io",
".",
"ReadCloser",
"{",
"rc",
":=",
"struct",
"{",
"io",
".",
"Reader",
"\n",
"io",
".",
"Closer",
"\n",
"}",
"{",
"r",
",",
"c",
"}",
"\n",
"ret... | // create a ReadCloser that reads from r and closes c. | [
"create",
"a",
"ReadCloser",
"that",
"reads",
"from",
"r",
"and",
"closes",
"c",
"."
] | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/main.go#L260-L266 |
15,783 | mna/pigeon | main.go | astPos | func (c *current) astPos() ast.Pos {
return ast.Pos{Line: c.pos.line, Col: c.pos.col, Off: c.pos.offset}
} | go | func (c *current) astPos() ast.Pos {
return ast.Pos{Line: c.pos.line, Col: c.pos.col, Off: c.pos.offset}
} | [
"func",
"(",
"c",
"*",
"current",
")",
"astPos",
"(",
")",
"ast",
".",
"Pos",
"{",
"return",
"ast",
".",
"Pos",
"{",
"Line",
":",
"c",
".",
"pos",
".",
"line",
",",
"Col",
":",
"c",
".",
"pos",
".",
"col",
",",
"Off",
":",
"c",
".",
"pos",
... | // astPos is a helper method for the PEG grammar parser. It returns the
// position of the current match as an ast.Pos. | [
"astPos",
"is",
"a",
"helper",
"method",
"for",
"the",
"PEG",
"grammar",
"parser",
".",
"It",
"returns",
"the",
"position",
"of",
"the",
"current",
"match",
"as",
"an",
"ast",
".",
"Pos",
"."
] | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/main.go#L270-L272 |
15,784 | mna/pigeon | ast/ast.go | String | func (p Pos) String() string {
if p.Filename != "" {
return fmt.Sprintf("%s:%d:%d (%d)", p.Filename, p.Line, p.Col, p.Off)
}
return fmt.Sprintf("%d:%d (%d)", p.Line, p.Col, p.Off)
} | go | func (p Pos) String() string {
if p.Filename != "" {
return fmt.Sprintf("%s:%d:%d (%d)", p.Filename, p.Line, p.Col, p.Off)
}
return fmt.Sprintf("%d:%d (%d)", p.Line, p.Col, p.Off)
} | [
"func",
"(",
"p",
"Pos",
")",
"String",
"(",
")",
"string",
"{",
"if",
"p",
".",
"Filename",
"!=",
"\"",
"\"",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"p",
".",
"Filename",
",",
"p",
".",
"Line",
",",
"p",
".",
"Col",
",",... | // String returns the textual representation of a position. | [
"String",
"returns",
"the",
"textual",
"representation",
"of",
"a",
"position",
"."
] | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/ast/ast.go#L24-L29 |
15,785 | mna/pigeon | ast/ast.go | NewRule | func NewRule(p Pos, name *Identifier) *Rule {
return &Rule{p: p, Name: name}
} | go | func NewRule(p Pos, name *Identifier) *Rule {
return &Rule{p: p, Name: name}
} | [
"func",
"NewRule",
"(",
"p",
"Pos",
",",
"name",
"*",
"Identifier",
")",
"*",
"Rule",
"{",
"return",
"&",
"Rule",
"{",
"p",
":",
"p",
",",
"Name",
":",
"name",
"}",
"\n",
"}"
] | // NewRule creates a rule with at the specified position and with the
// specified name as identifier. | [
"NewRule",
"creates",
"a",
"rule",
"with",
"at",
"the",
"specified",
"position",
"and",
"with",
"the",
"specified",
"name",
"as",
"identifier",
"."
] | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/ast/ast.go#L70-L72 |
15,786 | mna/pigeon | ast/ast.go | NewLitMatcher | func NewLitMatcher(p Pos, v string) *LitMatcher {
return &LitMatcher{posValue: posValue{p: p, Val: v}}
} | go | func NewLitMatcher(p Pos, v string) *LitMatcher {
return &LitMatcher{posValue: posValue{p: p, Val: v}}
} | [
"func",
"NewLitMatcher",
"(",
"p",
"Pos",
",",
"v",
"string",
")",
"*",
"LitMatcher",
"{",
"return",
"&",
"LitMatcher",
"{",
"posValue",
":",
"posValue",
"{",
"p",
":",
"p",
",",
"Val",
":",
"v",
"}",
"}",
"\n",
"}"
] | // NewLitMatcher creates a new literal matcher at the specified position and
// with the specified value. | [
"NewLitMatcher",
"creates",
"a",
"new",
"literal",
"matcher",
"at",
"the",
"specified",
"position",
"and",
"with",
"the",
"specified",
"value",
"."
] | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/ast/ast.go#L436-L438 |
15,787 | mna/pigeon | ast/ast.go | NewCharClassMatcher | func NewCharClassMatcher(p Pos, raw string) *CharClassMatcher {
c := &CharClassMatcher{posValue: posValue{p: p, Val: raw}}
c.parse()
return c
} | go | func NewCharClassMatcher(p Pos, raw string) *CharClassMatcher {
c := &CharClassMatcher{posValue: posValue{p: p, Val: raw}}
c.parse()
return c
} | [
"func",
"NewCharClassMatcher",
"(",
"p",
"Pos",
",",
"raw",
"string",
")",
"*",
"CharClassMatcher",
"{",
"c",
":=",
"&",
"CharClassMatcher",
"{",
"posValue",
":",
"posValue",
"{",
"p",
":",
"p",
",",
"Val",
":",
"raw",
"}",
"}",
"\n",
"c",
".",
"pars... | // NewCharClassMatcher creates a new character class matcher at the specified
// position and with the specified raw value. It parses the raw value into
// the list of characters, ranges and Unicode classes. | [
"NewCharClassMatcher",
"creates",
"a",
"new",
"character",
"class",
"matcher",
"at",
"the",
"specified",
"position",
"and",
"with",
"the",
"specified",
"raw",
"value",
".",
"It",
"parses",
"the",
"raw",
"value",
"into",
"the",
"list",
"of",
"characters",
"rang... | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/ast/ast.go#L463-L467 |
15,788 | mna/pigeon | ast/ast.go | NewAnyMatcher | func NewAnyMatcher(p Pos, v string) *AnyMatcher {
return &AnyMatcher{posValue{p, v}}
} | go | func NewAnyMatcher(p Pos, v string) *AnyMatcher {
return &AnyMatcher{posValue{p, v}}
} | [
"func",
"NewAnyMatcher",
"(",
"p",
"Pos",
",",
"v",
"string",
")",
"*",
"AnyMatcher",
"{",
"return",
"&",
"AnyMatcher",
"{",
"posValue",
"{",
"p",
",",
"v",
"}",
"}",
"\n",
"}"
] | // NewAnyMatcher creates a new any matcher at the specified position. The
// value is provided for completeness' sake, but it is always the dot. | [
"NewAnyMatcher",
"creates",
"a",
"new",
"any",
"matcher",
"at",
"the",
"specified",
"position",
".",
"The",
"value",
"is",
"provided",
"for",
"completeness",
"sake",
"but",
"it",
"is",
"always",
"the",
"dot",
"."
] | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/ast/ast.go#L590-L592 |
15,789 | mna/pigeon | ast/ast.go | NewCodeBlock | func NewCodeBlock(p Pos, code string) *CodeBlock {
return &CodeBlock{posValue{p, code}}
} | go | func NewCodeBlock(p Pos, code string) *CodeBlock {
return &CodeBlock{posValue{p, code}}
} | [
"func",
"NewCodeBlock",
"(",
"p",
"Pos",
",",
"code",
"string",
")",
"*",
"CodeBlock",
"{",
"return",
"&",
"CodeBlock",
"{",
"posValue",
"{",
"p",
",",
"code",
"}",
"}",
"\n",
"}"
] | // NewCodeBlock creates a new code block at the specified position and with
// the specified value. The value includes the outer braces. | [
"NewCodeBlock",
"creates",
"a",
"new",
"code",
"block",
"at",
"the",
"specified",
"position",
"and",
"with",
"the",
"specified",
"value",
".",
"The",
"value",
"includes",
"the",
"outer",
"braces",
"."
] | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/ast/ast.go#L609-L611 |
15,790 | mna/pigeon | ast/ast.go | NewIdentifier | func NewIdentifier(p Pos, name string) *Identifier {
return &Identifier{posValue{p: p, Val: name}}
} | go | func NewIdentifier(p Pos, name string) *Identifier {
return &Identifier{posValue{p: p, Val: name}}
} | [
"func",
"NewIdentifier",
"(",
"p",
"Pos",
",",
"name",
"string",
")",
"*",
"Identifier",
"{",
"return",
"&",
"Identifier",
"{",
"posValue",
"{",
"p",
":",
"p",
",",
"Val",
":",
"name",
"}",
"}",
"\n",
"}"
] | // NewIdentifier creates a new identifier at the specified position and
// with the specified name. | [
"NewIdentifier",
"creates",
"a",
"new",
"identifier",
"at",
"the",
"specified",
"position",
"and",
"with",
"the",
"specified",
"name",
"."
] | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/ast/ast.go#L628-L630 |
15,791 | mna/pigeon | ast/ast.go | NewStringLit | func NewStringLit(p Pos, val string) *StringLit {
return &StringLit{posValue{p: p, Val: val}}
} | go | func NewStringLit(p Pos, val string) *StringLit {
return &StringLit{posValue{p: p, Val: val}}
} | [
"func",
"NewStringLit",
"(",
"p",
"Pos",
",",
"val",
"string",
")",
"*",
"StringLit",
"{",
"return",
"&",
"StringLit",
"{",
"posValue",
"{",
"p",
":",
"p",
",",
"Val",
":",
"val",
"}",
"}",
"\n",
"}"
] | // NewStringLit creates a new string literal at the specified position and
// with the specified value. | [
"NewStringLit",
"creates",
"a",
"new",
"string",
"literal",
"at",
"the",
"specified",
"position",
"and",
"with",
"the",
"specified",
"value",
"."
] | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/ast/ast.go#L647-L649 |
15,792 | mna/pigeon | bootstrap/scan.go | Init | func (s *Scanner) Init(filename string, r io.Reader, errh func(ast.Pos, error)) {
s.r = runeReader(r)
s.errh = errh
s.eof = false
s.cpos = ast.Pos{
Filename: filename,
Line: 1,
}
s.cur, s.cw = -1, 0
s.tok.Reset()
} | go | func (s *Scanner) Init(filename string, r io.Reader, errh func(ast.Pos, error)) {
s.r = runeReader(r)
s.errh = errh
s.eof = false
s.cpos = ast.Pos{
Filename: filename,
Line: 1,
}
s.cur, s.cw = -1, 0
s.tok.Reset()
} | [
"func",
"(",
"s",
"*",
"Scanner",
")",
"Init",
"(",
"filename",
"string",
",",
"r",
"io",
".",
"Reader",
",",
"errh",
"func",
"(",
"ast",
".",
"Pos",
",",
"error",
")",
")",
"{",
"s",
".",
"r",
"=",
"runeReader",
"(",
"r",
")",
"\n",
"s",
"."... | // Init initializes the scanner to read and tokenize text from r. | [
"Init",
"initializes",
"the",
"scanner",
"to",
"read",
"and",
"tokenize",
"text",
"from",
"r",
"."
] | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/bootstrap/scan.go#L28-L40 |
15,793 | mna/pigeon | bootstrap/scan.go | read | func (s *Scanner) read() {
if s.eof {
return
}
r, w, err := s.r.ReadRune()
if err != nil {
s.fatalError(err)
return
}
s.cur = r
s.cpos.Off += s.cw
s.cw = w
// newline is '\n' as in Go
if r == '\n' {
s.cpos.Line++
s.cpos.Col = 0
} else {
s.cpos.Col++
}
} | go | func (s *Scanner) read() {
if s.eof {
return
}
r, w, err := s.r.ReadRune()
if err != nil {
s.fatalError(err)
return
}
s.cur = r
s.cpos.Off += s.cw
s.cw = w
// newline is '\n' as in Go
if r == '\n' {
s.cpos.Line++
s.cpos.Col = 0
} else {
s.cpos.Col++
}
} | [
"func",
"(",
"s",
"*",
"Scanner",
")",
"read",
"(",
")",
"{",
"if",
"s",
".",
"eof",
"{",
"return",
"\n",
"}",
"\n\n",
"r",
",",
"w",
",",
"err",
":=",
"s",
".",
"r",
".",
"ReadRune",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"s",
".... | // read advances the Scanner to the next rune. | [
"read",
"advances",
"the",
"Scanner",
"to",
"the",
"next",
"rune",
"."
] | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/bootstrap/scan.go#L465-L487 |
15,794 | mna/pigeon | bootstrap/scan.go | skipWhitespace | func (s *Scanner) skipWhitespace() {
for s.cur == ' ' || s.cur == '\t' || s.cur == '\r' {
s.read()
}
} | go | func (s *Scanner) skipWhitespace() {
for s.cur == ' ' || s.cur == '\t' || s.cur == '\r' {
s.read()
}
} | [
"func",
"(",
"s",
"*",
"Scanner",
")",
"skipWhitespace",
"(",
")",
"{",
"for",
"s",
".",
"cur",
"==",
"' '",
"||",
"s",
".",
"cur",
"==",
"'\\t'",
"||",
"s",
".",
"cur",
"==",
"'\\r'",
"{",
"s",
".",
"read",
"(",
")",
"\n",
"}",
"\n",
"}"
] | // whitespace is the same as Go, except that it doesn't skip newlines,
// those are returned as tokens. | [
"whitespace",
"is",
"the",
"same",
"as",
"Go",
"except",
"that",
"it",
"doesn",
"t",
"skip",
"newlines",
"those",
"are",
"returned",
"as",
"tokens",
"."
] | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/bootstrap/scan.go#L491-L495 |
15,795 | mna/pigeon | bootstrap/scan.go | isLetter | func isLetter(r rune) bool {
return 'a' <= r && r <= 'z' || 'A' <= r && r <= 'Z' || r == '_' ||
r >= 0x80 && unicode.IsLetter(r)
} | go | func isLetter(r rune) bool {
return 'a' <= r && r <= 'z' || 'A' <= r && r <= 'Z' || r == '_' ||
r >= 0x80 && unicode.IsLetter(r)
} | [
"func",
"isLetter",
"(",
"r",
"rune",
")",
"bool",
"{",
"return",
"'a'",
"<=",
"r",
"&&",
"r",
"<=",
"'z'",
"||",
"'A'",
"<=",
"r",
"&&",
"r",
"<=",
"'Z'",
"||",
"r",
"==",
"'_'",
"||",
"r",
">=",
"0x80",
"&&",
"unicode",
".",
"IsLetter",
"(",
... | // isLetter has the same definition as Go. | [
"isLetter",
"has",
"the",
"same",
"definition",
"as",
"Go",
"."
] | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/bootstrap/scan.go#L503-L506 |
15,796 | mna/pigeon | bootstrap/scan.go | isDigit | func isDigit(r rune) bool {
return '0' <= r && r <= '9' || r >= 0x80 && unicode.IsDigit(r)
} | go | func isDigit(r rune) bool {
return '0' <= r && r <= '9' || r >= 0x80 && unicode.IsDigit(r)
} | [
"func",
"isDigit",
"(",
"r",
"rune",
")",
"bool",
"{",
"return",
"'0'",
"<=",
"r",
"&&",
"r",
"<=",
"'9'",
"||",
"r",
">=",
"0x80",
"&&",
"unicode",
".",
"IsDigit",
"(",
"r",
")",
"\n",
"}"
] | // isDigit has the same definition as Go. | [
"isDigit",
"has",
"the",
"same",
"definition",
"as",
"Go",
"."
] | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/bootstrap/scan.go#L509-L511 |
15,797 | mna/pigeon | bootstrap/scan.go | error | func (s *Scanner) error(p ast.Pos, err error) {
if s.errh != nil {
s.errh(p, err)
return
}
fmt.Fprintf(os.Stderr, "%s: %v\n", p, err)
} | go | func (s *Scanner) error(p ast.Pos, err error) {
if s.errh != nil {
s.errh(p, err)
return
}
fmt.Fprintf(os.Stderr, "%s: %v\n", p, err)
} | [
"func",
"(",
"s",
"*",
"Scanner",
")",
"error",
"(",
"p",
"ast",
".",
"Pos",
",",
"err",
"error",
")",
"{",
"if",
"s",
".",
"errh",
"!=",
"nil",
"{",
"s",
".",
"errh",
"(",
"p",
",",
"err",
")",
"\n",
"return",
"\n",
"}",
"\n",
"fmt",
".",
... | // notify the handler of an error. | [
"notify",
"the",
"handler",
"of",
"an",
"error",
"."
] | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/bootstrap/scan.go#L526-L532 |
15,798 | mna/pigeon | bootstrap/scan.go | errorf | func (s *Scanner) errorf(f string, args ...interface{}) {
s.errorpf(s.cpos, f, args...)
} | go | func (s *Scanner) errorf(f string, args ...interface{}) {
s.errorpf(s.cpos, f, args...)
} | [
"func",
"(",
"s",
"*",
"Scanner",
")",
"errorf",
"(",
"f",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"s",
".",
"errorpf",
"(",
"s",
".",
"cpos",
",",
"f",
",",
"args",
"...",
")",
"\n",
"}"
] | // helper to generate and notify of an error. | [
"helper",
"to",
"generate",
"and",
"notify",
"of",
"an",
"error",
"."
] | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/bootstrap/scan.go#L535-L537 |
15,799 | mna/pigeon | bootstrap/scan.go | errorpf | func (s *Scanner) errorpf(p ast.Pos, f string, args ...interface{}) {
s.error(p, fmt.Errorf(f, args...))
} | go | func (s *Scanner) errorpf(p ast.Pos, f string, args ...interface{}) {
s.error(p, fmt.Errorf(f, args...))
} | [
"func",
"(",
"s",
"*",
"Scanner",
")",
"errorpf",
"(",
"p",
"ast",
".",
"Pos",
",",
"f",
"string",
",",
"args",
"...",
"interface",
"{",
"}",
")",
"{",
"s",
".",
"error",
"(",
"p",
",",
"fmt",
".",
"Errorf",
"(",
"f",
",",
"args",
"...",
")",... | // helper to generate and notify of an error at a specific position. | [
"helper",
"to",
"generate",
"and",
"notify",
"of",
"an",
"error",
"at",
"a",
"specific",
"position",
"."
] | 4412d0f0bd75356045e0f757c19b0be1bfff2cf3 | https://github.com/mna/pigeon/blob/4412d0f0bd75356045e0f757c19b0be1bfff2cf3/bootstrap/scan.go#L540-L542 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.