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 list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 | partition stringclasses 1 value |
|---|---|---|---|---|---|---|---|---|---|---|---|
gocraft/dbr | types.go | UnmarshalJSON | func (n *NullString) UnmarshalJSON(b []byte) error {
var s interface{}
if err := json.Unmarshal(b, &s); err != nil {
return err
}
return n.Scan(s)
} | go | func (n *NullString) UnmarshalJSON(b []byte) error {
var s interface{}
if err := json.Unmarshal(b, &s); err != nil {
return err
}
return n.Scan(s)
} | [
"func",
"(",
"n",
"*",
"NullString",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"s",
"interface",
"{",
"}",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"s",
")",
";",
"err",
"!=",
"nil... | // UnmarshalJSON correctly deserializes a NullString from JSON. | [
"UnmarshalJSON",
"correctly",
"deserializes",
"a",
"NullString",
"from",
"JSON",
"."
] | 48a049970bd235145507f94604005bb7eb9c8bb4 | https://github.com/gocraft/dbr/blob/48a049970bd235145507f94604005bb7eb9c8bb4/types.go#L92-L98 | train |
gocraft/dbr | types.go | UnmarshalJSON | func (n *NullInt64) UnmarshalJSON(b []byte) error {
var s json.Number
if err := json.Unmarshal(b, &s); err != nil {
return err
}
if s == "" {
return n.Scan(nil)
}
return n.Scan(s)
} | go | func (n *NullInt64) UnmarshalJSON(b []byte) error {
var s json.Number
if err := json.Unmarshal(b, &s); err != nil {
return err
}
if s == "" {
return n.Scan(nil)
}
return n.Scan(s)
} | [
"func",
"(",
"n",
"*",
"NullInt64",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"var",
"s",
"json",
".",
"Number",
"\n",
"if",
"err",
":=",
"json",
".",
"Unmarshal",
"(",
"b",
",",
"&",
"s",
")",
";",
"err",
"!=",
"nil"... | // UnmarshalJSON correctly deserializes a NullInt64 from JSON. | [
"UnmarshalJSON",
"correctly",
"deserializes",
"a",
"NullInt64",
"from",
"JSON",
"."
] | 48a049970bd235145507f94604005bb7eb9c8bb4 | https://github.com/gocraft/dbr/blob/48a049970bd235145507f94604005bb7eb9c8bb4/types.go#L101-L110 | train |
gocraft/dbr | types.go | UnmarshalJSON | func (n *NullTime) UnmarshalJSON(b []byte) error {
// scan for null
if bytes.Equal(b, nullString) {
return n.Scan(nil)
}
// scan for JSON timestamp
var t time.Time
if err := json.Unmarshal(b, &t); err != nil {
return err
}
return n.Scan(t)
} | go | func (n *NullTime) UnmarshalJSON(b []byte) error {
// scan for null
if bytes.Equal(b, nullString) {
return n.Scan(nil)
}
// scan for JSON timestamp
var t time.Time
if err := json.Unmarshal(b, &t); err != nil {
return err
}
return n.Scan(t)
} | [
"func",
"(",
"n",
"*",
"NullTime",
")",
"UnmarshalJSON",
"(",
"b",
"[",
"]",
"byte",
")",
"error",
"{",
"// scan for null",
"if",
"bytes",
".",
"Equal",
"(",
"b",
",",
"nullString",
")",
"{",
"return",
"n",
".",
"Scan",
"(",
"nil",
")",
"\n",
"}",
... | // UnmarshalJSON correctly deserializes a NullTime from JSON. | [
"UnmarshalJSON",
"correctly",
"deserializes",
"a",
"NullTime",
"from",
"JSON",
"."
] | 48a049970bd235145507f94604005bb7eb9c8bb4 | https://github.com/gocraft/dbr/blob/48a049970bd235145507f94604005bb7eb9c8bb4/types.go#L122-L133 | train |
gocraft/dbr | insert.go | Values | func (b *InsertStmt) Values(value ...interface{}) *InsertStmt {
b.Value = append(b.Value, value)
return b
} | go | func (b *InsertStmt) Values(value ...interface{}) *InsertStmt {
b.Value = append(b.Value, value)
return b
} | [
"func",
"(",
"b",
"*",
"InsertStmt",
")",
"Values",
"(",
"value",
"...",
"interface",
"{",
"}",
")",
"*",
"InsertStmt",
"{",
"b",
".",
"Value",
"=",
"append",
"(",
"b",
".",
"Value",
",",
"value",
")",
"\n",
"return",
"b",
"\n",
"}"
] | // Values adds a tuple to be inserted.
// The order of the tuple should match Columns. | [
"Values",
"adds",
"a",
"tuple",
"to",
"be",
"inserted",
".",
"The",
"order",
"of",
"the",
"tuple",
"should",
"match",
"Columns",
"."
] | 48a049970bd235145507f94604005bb7eb9c8bb4 | https://github.com/gocraft/dbr/blob/48a049970bd235145507f94604005bb7eb9c8bb4/insert.go#L140-L143 | train |
gocraft/dbr | insert.go | Record | func (b *InsertStmt) Record(structValue interface{}) *InsertStmt {
v := reflect.Indirect(reflect.ValueOf(structValue))
if v.Kind() == reflect.Struct {
found := make([]interface{}, len(b.Column)+1)
// ID is recommended by golint here
s := newTagStore()
s.findValueByName(v, append(b.Column, "id"), found, false)
value := found[:len(found)-1]
for i, v := range value {
if v != nil {
value[i] = v.(reflect.Value).Interface()
}
}
if v.CanSet() {
switch idField := found[len(found)-1].(type) {
case reflect.Value:
if idField.Kind() == reflect.Int64 {
b.RecordID = idField.Addr().Interface().(*int64)
}
}
}
b.Values(value...)
}
return b
} | go | func (b *InsertStmt) Record(structValue interface{}) *InsertStmt {
v := reflect.Indirect(reflect.ValueOf(structValue))
if v.Kind() == reflect.Struct {
found := make([]interface{}, len(b.Column)+1)
// ID is recommended by golint here
s := newTagStore()
s.findValueByName(v, append(b.Column, "id"), found, false)
value := found[:len(found)-1]
for i, v := range value {
if v != nil {
value[i] = v.(reflect.Value).Interface()
}
}
if v.CanSet() {
switch idField := found[len(found)-1].(type) {
case reflect.Value:
if idField.Kind() == reflect.Int64 {
b.RecordID = idField.Addr().Interface().(*int64)
}
}
}
b.Values(value...)
}
return b
} | [
"func",
"(",
"b",
"*",
"InsertStmt",
")",
"Record",
"(",
"structValue",
"interface",
"{",
"}",
")",
"*",
"InsertStmt",
"{",
"v",
":=",
"reflect",
".",
"Indirect",
"(",
"reflect",
".",
"ValueOf",
"(",
"structValue",
")",
")",
"\n\n",
"if",
"v",
".",
"... | // Record adds a tuple for columns from a struct.
//
// If there is a field called "Id" or "ID" in the struct,
// it will be set to LastInsertId. | [
"Record",
"adds",
"a",
"tuple",
"for",
"columns",
"from",
"a",
"struct",
".",
"If",
"there",
"is",
"a",
"field",
"called",
"Id",
"or",
"ID",
"in",
"the",
"struct",
"it",
"will",
"be",
"set",
"to",
"LastInsertId",
"."
] | 48a049970bd235145507f94604005bb7eb9c8bb4 | https://github.com/gocraft/dbr/blob/48a049970bd235145507f94604005bb7eb9c8bb4/insert.go#L149-L176 | train |
gocraft/dbr | dbr.go | Open | func Open(driver, dsn string, log EventReceiver) (*Connection, error) {
if log == nil {
log = nullReceiver
}
conn, err := sql.Open(driver, dsn)
if err != nil {
return nil, err
}
var d Dialect
switch driver {
case "mysql":
d = dialect.MySQL
case "postgres":
d = dialect.PostgreSQL
case "sqlite3":
d = dialect.SQLite3
default:
return nil, ErrNotSupported
}
return &Connection{DB: conn, EventReceiver: log, Dialect: d}, nil
} | go | func Open(driver, dsn string, log EventReceiver) (*Connection, error) {
if log == nil {
log = nullReceiver
}
conn, err := sql.Open(driver, dsn)
if err != nil {
return nil, err
}
var d Dialect
switch driver {
case "mysql":
d = dialect.MySQL
case "postgres":
d = dialect.PostgreSQL
case "sqlite3":
d = dialect.SQLite3
default:
return nil, ErrNotSupported
}
return &Connection{DB: conn, EventReceiver: log, Dialect: d}, nil
} | [
"func",
"Open",
"(",
"driver",
",",
"dsn",
"string",
",",
"log",
"EventReceiver",
")",
"(",
"*",
"Connection",
",",
"error",
")",
"{",
"if",
"log",
"==",
"nil",
"{",
"log",
"=",
"nullReceiver",
"\n",
"}",
"\n",
"conn",
",",
"err",
":=",
"sql",
".",... | // Open creates a Connection.
// log can be nil to ignore logging. | [
"Open",
"creates",
"a",
"Connection",
".",
"log",
"can",
"be",
"nil",
"to",
"ignore",
"logging",
"."
] | 48a049970bd235145507f94604005bb7eb9c8bb4 | https://github.com/gocraft/dbr/blob/48a049970bd235145507f94604005bb7eb9c8bb4/dbr.go#L15-L35 | train |
gocraft/dbr | dbr.go | NewSession | func (conn *Connection) NewSession(log EventReceiver) *Session {
if log == nil {
log = conn.EventReceiver // Use parent instrumentation
}
return &Session{Connection: conn, EventReceiver: log}
} | go | func (conn *Connection) NewSession(log EventReceiver) *Session {
if log == nil {
log = conn.EventReceiver // Use parent instrumentation
}
return &Session{Connection: conn, EventReceiver: log}
} | [
"func",
"(",
"conn",
"*",
"Connection",
")",
"NewSession",
"(",
"log",
"EventReceiver",
")",
"*",
"Session",
"{",
"if",
"log",
"==",
"nil",
"{",
"log",
"=",
"conn",
".",
"EventReceiver",
"// Use parent instrumentation",
"\n",
"}",
"\n",
"return",
"&",
"Ses... | // NewSession instantiates a Session from Connection.
// If log is nil, Connection EventReceiver is used. | [
"NewSession",
"instantiates",
"a",
"Session",
"from",
"Connection",
".",
"If",
"log",
"is",
"nil",
"Connection",
"EventReceiver",
"is",
"used",
"."
] | 48a049970bd235145507f94604005bb7eb9c8bb4 | https://github.com/gocraft/dbr/blob/48a049970bd235145507f94604005bb7eb9c8bb4/dbr.go#L71-L76 | train |
gocraft/dbr | now.go | Value | func (n nowSentinel) Value() (driver.Value, error) {
now := time.Now().UTC().Format(timeFormat)
return now, nil
} | go | func (n nowSentinel) Value() (driver.Value, error) {
now := time.Now().UTC().Format(timeFormat)
return now, nil
} | [
"func",
"(",
"n",
"nowSentinel",
")",
"Value",
"(",
")",
"(",
"driver",
".",
"Value",
",",
"error",
")",
"{",
"now",
":=",
"time",
".",
"Now",
"(",
")",
".",
"UTC",
"(",
")",
".",
"Format",
"(",
"timeFormat",
")",
"\n",
"return",
"now",
",",
"n... | // Value implements a valuer for compatibility | [
"Value",
"implements",
"a",
"valuer",
"for",
"compatibility"
] | 48a049970bd235145507f94604005bb7eb9c8bb4 | https://github.com/gocraft/dbr/blob/48a049970bd235145507f94604005bb7eb9c8bb4/now.go#L16-L19 | train |
gocraft/dbr | update.go | Set | func (b *UpdateStmt) Set(column string, value interface{}) *UpdateStmt {
b.Value[column] = value
return b
} | go | func (b *UpdateStmt) Set(column string, value interface{}) *UpdateStmt {
b.Value[column] = value
return b
} | [
"func",
"(",
"b",
"*",
"UpdateStmt",
")",
"Set",
"(",
"column",
"string",
",",
"value",
"interface",
"{",
"}",
")",
"*",
"UpdateStmt",
"{",
"b",
".",
"Value",
"[",
"column",
"]",
"=",
"value",
"\n",
"return",
"b",
"\n",
"}"
] | // Set updates column with value. | [
"Set",
"updates",
"column",
"with",
"value",
"."
] | 48a049970bd235145507f94604005bb7eb9c8bb4 | https://github.com/gocraft/dbr/blob/48a049970bd235145507f94604005bb7eb9c8bb4/update.go#L158-L161 | train |
gocraft/dbr | select_return.go | ReturnInt64 | func (b *SelectStmt) ReturnInt64() (int64, error) {
var v int64
err := b.LoadOne(&v)
return v, err
} | go | func (b *SelectStmt) ReturnInt64() (int64, error) {
var v int64
err := b.LoadOne(&v)
return v, err
} | [
"func",
"(",
"b",
"*",
"SelectStmt",
")",
"ReturnInt64",
"(",
")",
"(",
"int64",
",",
"error",
")",
"{",
"var",
"v",
"int64",
"\n",
"err",
":=",
"b",
".",
"LoadOne",
"(",
"&",
"v",
")",
"\n",
"return",
"v",
",",
"err",
"\n",
"}"
] | // ReturnInt64 executes the SelectStmt and returns the value as an int64. | [
"ReturnInt64",
"executes",
"the",
"SelectStmt",
"and",
"returns",
"the",
"value",
"as",
"an",
"int64",
"."
] | 48a049970bd235145507f94604005bb7eb9c8bb4 | https://github.com/gocraft/dbr/blob/48a049970bd235145507f94604005bb7eb9c8bb4/select_return.go#L4-L8 | train |
gocraft/dbr | select_return.go | ReturnInt64s | func (b *SelectStmt) ReturnInt64s() ([]int64, error) {
var v []int64
_, err := b.Load(&v)
return v, err
} | go | func (b *SelectStmt) ReturnInt64s() ([]int64, error) {
var v []int64
_, err := b.Load(&v)
return v, err
} | [
"func",
"(",
"b",
"*",
"SelectStmt",
")",
"ReturnInt64s",
"(",
")",
"(",
"[",
"]",
"int64",
",",
"error",
")",
"{",
"var",
"v",
"[",
"]",
"int64",
"\n",
"_",
",",
"err",
":=",
"b",
".",
"Load",
"(",
"&",
"v",
")",
"\n",
"return",
"v",
",",
... | // ReturnInt64s executes the SelectStmt and returns the value as a slice of int64s. | [
"ReturnInt64s",
"executes",
"the",
"SelectStmt",
"and",
"returns",
"the",
"value",
"as",
"a",
"slice",
"of",
"int64s",
"."
] | 48a049970bd235145507f94604005bb7eb9c8bb4 | https://github.com/gocraft/dbr/blob/48a049970bd235145507f94604005bb7eb9c8bb4/select_return.go#L11-L15 | train |
gocraft/dbr | select_return.go | ReturnUint64 | func (b *SelectStmt) ReturnUint64() (uint64, error) {
var v uint64
err := b.LoadOne(&v)
return v, err
} | go | func (b *SelectStmt) ReturnUint64() (uint64, error) {
var v uint64
err := b.LoadOne(&v)
return v, err
} | [
"func",
"(",
"b",
"*",
"SelectStmt",
")",
"ReturnUint64",
"(",
")",
"(",
"uint64",
",",
"error",
")",
"{",
"var",
"v",
"uint64",
"\n",
"err",
":=",
"b",
".",
"LoadOne",
"(",
"&",
"v",
")",
"\n",
"return",
"v",
",",
"err",
"\n",
"}"
] | // ReturnUint64 executes the SelectStmt and returns the value as an uint64. | [
"ReturnUint64",
"executes",
"the",
"SelectStmt",
"and",
"returns",
"the",
"value",
"as",
"an",
"uint64",
"."
] | 48a049970bd235145507f94604005bb7eb9c8bb4 | https://github.com/gocraft/dbr/blob/48a049970bd235145507f94604005bb7eb9c8bb4/select_return.go#L18-L22 | train |
gocraft/dbr | select_return.go | ReturnUint64s | func (b *SelectStmt) ReturnUint64s() ([]uint64, error) {
var v []uint64
_, err := b.Load(&v)
return v, err
} | go | func (b *SelectStmt) ReturnUint64s() ([]uint64, error) {
var v []uint64
_, err := b.Load(&v)
return v, err
} | [
"func",
"(",
"b",
"*",
"SelectStmt",
")",
"ReturnUint64s",
"(",
")",
"(",
"[",
"]",
"uint64",
",",
"error",
")",
"{",
"var",
"v",
"[",
"]",
"uint64",
"\n",
"_",
",",
"err",
":=",
"b",
".",
"Load",
"(",
"&",
"v",
")",
"\n",
"return",
"v",
",",... | // ReturnUint64s executes the SelectStmt and returns the value as a slice of uint64s. | [
"ReturnUint64s",
"executes",
"the",
"SelectStmt",
"and",
"returns",
"the",
"value",
"as",
"a",
"slice",
"of",
"uint64s",
"."
] | 48a049970bd235145507f94604005bb7eb9c8bb4 | https://github.com/gocraft/dbr/blob/48a049970bd235145507f94604005bb7eb9c8bb4/select_return.go#L25-L29 | train |
gocraft/dbr | select_return.go | ReturnString | func (b *SelectStmt) ReturnString() (string, error) {
var v string
err := b.LoadOne(&v)
return v, err
} | go | func (b *SelectStmt) ReturnString() (string, error) {
var v string
err := b.LoadOne(&v)
return v, err
} | [
"func",
"(",
"b",
"*",
"SelectStmt",
")",
"ReturnString",
"(",
")",
"(",
"string",
",",
"error",
")",
"{",
"var",
"v",
"string",
"\n",
"err",
":=",
"b",
".",
"LoadOne",
"(",
"&",
"v",
")",
"\n",
"return",
"v",
",",
"err",
"\n",
"}"
] | // ReturnString executes the SelectStmt and returns the value as a string. | [
"ReturnString",
"executes",
"the",
"SelectStmt",
"and",
"returns",
"the",
"value",
"as",
"a",
"string",
"."
] | 48a049970bd235145507f94604005bb7eb9c8bb4 | https://github.com/gocraft/dbr/blob/48a049970bd235145507f94604005bb7eb9c8bb4/select_return.go#L32-L36 | train |
gocraft/dbr | select_return.go | ReturnStrings | func (b *SelectStmt) ReturnStrings() ([]string, error) {
var v []string
_, err := b.Load(&v)
return v, err
} | go | func (b *SelectStmt) ReturnStrings() ([]string, error) {
var v []string
_, err := b.Load(&v)
return v, err
} | [
"func",
"(",
"b",
"*",
"SelectStmt",
")",
"ReturnStrings",
"(",
")",
"(",
"[",
"]",
"string",
",",
"error",
")",
"{",
"var",
"v",
"[",
"]",
"string",
"\n",
"_",
",",
"err",
":=",
"b",
".",
"Load",
"(",
"&",
"v",
")",
"\n",
"return",
"v",
",",... | // ReturnStrings executes the SelectStmt and returns the value as a slice of strings. | [
"ReturnStrings",
"executes",
"the",
"SelectStmt",
"and",
"returns",
"the",
"value",
"as",
"a",
"slice",
"of",
"strings",
"."
] | 48a049970bd235145507f94604005bb7eb9c8bb4 | https://github.com/gocraft/dbr/blob/48a049970bd235145507f94604005bb7eb9c8bb4/select_return.go#L39-L43 | train |
gocraft/dbr | transaction.go | BeginTx | func (sess *Session) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) {
tx, err := sess.Connection.BeginTx(ctx, opts)
if err != nil {
return nil, sess.EventErr("dbr.begin.error", err)
}
sess.Event("dbr.begin")
return &Tx{
EventReceiver: sess.EventReceiver,
Dialect: sess.Dialect,
Tx: tx,
Timeout: sess.GetTimeout(),
}, nil
} | go | func (sess *Session) BeginTx(ctx context.Context, opts *sql.TxOptions) (*Tx, error) {
tx, err := sess.Connection.BeginTx(ctx, opts)
if err != nil {
return nil, sess.EventErr("dbr.begin.error", err)
}
sess.Event("dbr.begin")
return &Tx{
EventReceiver: sess.EventReceiver,
Dialect: sess.Dialect,
Tx: tx,
Timeout: sess.GetTimeout(),
}, nil
} | [
"func",
"(",
"sess",
"*",
"Session",
")",
"BeginTx",
"(",
"ctx",
"context",
".",
"Context",
",",
"opts",
"*",
"sql",
".",
"TxOptions",
")",
"(",
"*",
"Tx",
",",
"error",
")",
"{",
"tx",
",",
"err",
":=",
"sess",
".",
"Connection",
".",
"BeginTx",
... | // BeginTx creates a transaction with TxOptions. | [
"BeginTx",
"creates",
"a",
"transaction",
"with",
"TxOptions",
"."
] | 48a049970bd235145507f94604005bb7eb9c8bb4 | https://github.com/gocraft/dbr/blob/48a049970bd235145507f94604005bb7eb9c8bb4/transaction.go#L23-L36 | train |
gocraft/dbr | transaction.go | Begin | func (sess *Session) Begin() (*Tx, error) {
return sess.BeginTx(context.Background(), nil)
} | go | func (sess *Session) Begin() (*Tx, error) {
return sess.BeginTx(context.Background(), nil)
} | [
"func",
"(",
"sess",
"*",
"Session",
")",
"Begin",
"(",
")",
"(",
"*",
"Tx",
",",
"error",
")",
"{",
"return",
"sess",
".",
"BeginTx",
"(",
"context",
".",
"Background",
"(",
")",
",",
"nil",
")",
"\n",
"}"
] | // Begin creates a transaction for the given session. | [
"Begin",
"creates",
"a",
"transaction",
"for",
"the",
"given",
"session",
"."
] | 48a049970bd235145507f94604005bb7eb9c8bb4 | https://github.com/gocraft/dbr/blob/48a049970bd235145507f94604005bb7eb9c8bb4/transaction.go#L39-L41 | train |
gocraft/dbr | transaction.go | Commit | func (tx *Tx) Commit() error {
err := tx.Tx.Commit()
if err != nil {
return tx.EventErr("dbr.commit.error", err)
}
tx.Event("dbr.commit")
return nil
} | go | func (tx *Tx) Commit() error {
err := tx.Tx.Commit()
if err != nil {
return tx.EventErr("dbr.commit.error", err)
}
tx.Event("dbr.commit")
return nil
} | [
"func",
"(",
"tx",
"*",
"Tx",
")",
"Commit",
"(",
")",
"error",
"{",
"err",
":=",
"tx",
".",
"Tx",
".",
"Commit",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"tx",
".",
"EventErr",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",
"... | // Commit finishes the transaction. | [
"Commit",
"finishes",
"the",
"transaction",
"."
] | 48a049970bd235145507f94604005bb7eb9c8bb4 | https://github.com/gocraft/dbr/blob/48a049970bd235145507f94604005bb7eb9c8bb4/transaction.go#L44-L51 | train |
gocraft/dbr | transaction.go | Rollback | func (tx *Tx) Rollback() error {
err := tx.Tx.Rollback()
if err != nil {
return tx.EventErr("dbr.rollback", err)
}
tx.Event("dbr.rollback")
return nil
} | go | func (tx *Tx) Rollback() error {
err := tx.Tx.Rollback()
if err != nil {
return tx.EventErr("dbr.rollback", err)
}
tx.Event("dbr.rollback")
return nil
} | [
"func",
"(",
"tx",
"*",
"Tx",
")",
"Rollback",
"(",
")",
"error",
"{",
"err",
":=",
"tx",
".",
"Tx",
".",
"Rollback",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"tx",
".",
"EventErr",
"(",
"\"",
"\"",
",",
"err",
")",
"\n",
"}",... | // Rollback cancels the transaction. | [
"Rollback",
"cancels",
"the",
"transaction",
"."
] | 48a049970bd235145507f94604005bb7eb9c8bb4 | https://github.com/gocraft/dbr/blob/48a049970bd235145507f94604005bb7eb9c8bb4/transaction.go#L54-L61 | train |
ceph/go-ceph | rados/ioctx.go | Stat | func (ioctx *IOContext) Stat(object string) (stat ObjectStat, err error) {
var c_psize C.uint64_t
var c_pmtime C.time_t
c_object := C.CString(object)
defer C.free(unsafe.Pointer(c_object))
ret := C.rados_stat(
ioctx.ioctx,
c_object,
&c_psize,
&c_pmtime)
if ret < 0 {
return ObjectStat{}, GetRadosError(int(ret))
} else {
return ObjectStat{
Size: uint64(c_psize),
ModTime: time.Unix(int64(c_pmtime), 0),
}, nil
}
} | go | func (ioctx *IOContext) Stat(object string) (stat ObjectStat, err error) {
var c_psize C.uint64_t
var c_pmtime C.time_t
c_object := C.CString(object)
defer C.free(unsafe.Pointer(c_object))
ret := C.rados_stat(
ioctx.ioctx,
c_object,
&c_psize,
&c_pmtime)
if ret < 0 {
return ObjectStat{}, GetRadosError(int(ret))
} else {
return ObjectStat{
Size: uint64(c_psize),
ModTime: time.Unix(int64(c_pmtime), 0),
}, nil
}
} | [
"func",
"(",
"ioctx",
"*",
"IOContext",
")",
"Stat",
"(",
"object",
"string",
")",
"(",
"stat",
"ObjectStat",
",",
"err",
"error",
")",
"{",
"var",
"c_psize",
"C",
".",
"uint64_t",
"\n",
"var",
"c_pmtime",
"C",
".",
"time_t",
"\n",
"c_object",
":=",
... | // Stat returns the size of the object and its last modification time | [
"Stat",
"returns",
"the",
"size",
"of",
"the",
"object",
"and",
"its",
"last",
"modification",
"time"
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/ioctx.go#L264-L284 | train |
ceph/go-ceph | rados/ioctx.go | GetXattr | func (ioctx *IOContext) GetXattr(object string, name string, data []byte) (int, error) {
c_object := C.CString(object)
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_object))
defer C.free(unsafe.Pointer(c_name))
ret := C.rados_getxattr(
ioctx.ioctx,
c_object,
c_name,
(*C.char)(unsafe.Pointer(&data[0])),
(C.size_t)(len(data)))
if ret >= 0 {
return int(ret), nil
} else {
return 0, GetRadosError(int(ret))
}
} | go | func (ioctx *IOContext) GetXattr(object string, name string, data []byte) (int, error) {
c_object := C.CString(object)
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_object))
defer C.free(unsafe.Pointer(c_name))
ret := C.rados_getxattr(
ioctx.ioctx,
c_object,
c_name,
(*C.char)(unsafe.Pointer(&data[0])),
(C.size_t)(len(data)))
if ret >= 0 {
return int(ret), nil
} else {
return 0, GetRadosError(int(ret))
}
} | [
"func",
"(",
"ioctx",
"*",
"IOContext",
")",
"GetXattr",
"(",
"object",
"string",
",",
"name",
"string",
",",
"data",
"[",
"]",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"c_object",
":=",
"C",
".",
"CString",
"(",
"object",
")",
"\n",
"c_nam... | // GetXattr gets an xattr with key `name`, it returns the length of
// the key read or an error if not successful | [
"GetXattr",
"gets",
"an",
"xattr",
"with",
"key",
"name",
"it",
"returns",
"the",
"length",
"of",
"the",
"key",
"read",
"or",
"an",
"error",
"if",
"not",
"successful"
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/ioctx.go#L288-L306 | train |
ceph/go-ceph | rados/ioctx.go | RmOmapKeys | func (ioctx *IOContext) RmOmapKeys(oid string, keys []string) error {
c_oid := C.CString(oid)
defer C.free(unsafe.Pointer(c_oid))
var c *C.char
ptrSize := unsafe.Sizeof(c)
c_keys := C.malloc(C.size_t(len(keys)) * C.size_t(ptrSize))
defer C.free(unsafe.Pointer(c_keys))
i := 0
for _, key := range keys {
c_key_ptr := (**C.char)(unsafe.Pointer(uintptr(c_keys) + uintptr(i)*ptrSize))
*c_key_ptr = C.CString(key)
defer C.free(unsafe.Pointer(*c_key_ptr))
i++
}
op := C.rados_create_write_op()
C.rados_write_op_omap_rm_keys(
op,
(**C.char)(c_keys),
C.size_t(len(keys)))
ret := C.rados_write_op_operate(op, ioctx.ioctx, c_oid, nil, 0)
C.rados_release_write_op(op)
return GetRadosError(int(ret))
} | go | func (ioctx *IOContext) RmOmapKeys(oid string, keys []string) error {
c_oid := C.CString(oid)
defer C.free(unsafe.Pointer(c_oid))
var c *C.char
ptrSize := unsafe.Sizeof(c)
c_keys := C.malloc(C.size_t(len(keys)) * C.size_t(ptrSize))
defer C.free(unsafe.Pointer(c_keys))
i := 0
for _, key := range keys {
c_key_ptr := (**C.char)(unsafe.Pointer(uintptr(c_keys) + uintptr(i)*ptrSize))
*c_key_ptr = C.CString(key)
defer C.free(unsafe.Pointer(*c_key_ptr))
i++
}
op := C.rados_create_write_op()
C.rados_write_op_omap_rm_keys(
op,
(**C.char)(c_keys),
C.size_t(len(keys)))
ret := C.rados_write_op_operate(op, ioctx.ioctx, c_oid, nil, 0)
C.rados_release_write_op(op)
return GetRadosError(int(ret))
} | [
"func",
"(",
"ioctx",
"*",
"IOContext",
")",
"RmOmapKeys",
"(",
"oid",
"string",
",",
"keys",
"[",
"]",
"string",
")",
"error",
"{",
"c_oid",
":=",
"C",
".",
"CString",
"(",
"oid",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer"... | // Remove the specified `keys` from the omap `oid` | [
"Remove",
"the",
"specified",
"keys",
"from",
"the",
"omap",
"oid"
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/ioctx.go#L545-L573 | train |
ceph/go-ceph | rados/ioctx.go | CleanOmap | func (ioctx *IOContext) CleanOmap(oid string) error {
c_oid := C.CString(oid)
defer C.free(unsafe.Pointer(c_oid))
op := C.rados_create_write_op()
C.rados_write_op_omap_clear(op)
ret := C.rados_write_op_operate(op, ioctx.ioctx, c_oid, nil, 0)
C.rados_release_write_op(op)
return GetRadosError(int(ret))
} | go | func (ioctx *IOContext) CleanOmap(oid string) error {
c_oid := C.CString(oid)
defer C.free(unsafe.Pointer(c_oid))
op := C.rados_create_write_op()
C.rados_write_op_omap_clear(op)
ret := C.rados_write_op_operate(op, ioctx.ioctx, c_oid, nil, 0)
C.rados_release_write_op(op)
return GetRadosError(int(ret))
} | [
"func",
"(",
"ioctx",
"*",
"IOContext",
")",
"CleanOmap",
"(",
"oid",
"string",
")",
"error",
"{",
"c_oid",
":=",
"C",
".",
"CString",
"(",
"oid",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_oid",
")",
")",
"\n\n",
... | // Clear the omap `oid` | [
"Clear",
"the",
"omap",
"oid"
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/ioctx.go#L576-L587 | train |
ceph/go-ceph | rados/ioctx.go | Iter | func (ioctx *IOContext) Iter() (*Iter, error) {
iter := Iter{}
if cerr := C.rados_nobjects_list_open(ioctx.ioctx, &iter.ctx); cerr < 0 {
return nil, GetRadosError(int(cerr))
}
return &iter, nil
} | go | func (ioctx *IOContext) Iter() (*Iter, error) {
iter := Iter{}
if cerr := C.rados_nobjects_list_open(ioctx.ioctx, &iter.ctx); cerr < 0 {
return nil, GetRadosError(int(cerr))
}
return &iter, nil
} | [
"func",
"(",
"ioctx",
"*",
"IOContext",
")",
"Iter",
"(",
")",
"(",
"*",
"Iter",
",",
"error",
")",
"{",
"iter",
":=",
"Iter",
"{",
"}",
"\n",
"if",
"cerr",
":=",
"C",
".",
"rados_nobjects_list_open",
"(",
"ioctx",
".",
"ioctx",
",",
"&",
"iter",
... | // Return a Iterator object that can be used to list the object names in the current pool | [
"Return",
"a",
"Iterator",
"object",
"that",
"can",
"be",
"used",
"to",
"list",
"the",
"object",
"names",
"in",
"the",
"current",
"pool"
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/ioctx.go#L599-L605 | train |
ceph/go-ceph | rados/ioctx.go | Err | func (iter *Iter) Err() error {
if iter.err == RadosErrorNotFound {
return nil
}
return iter.err
} | go | func (iter *Iter) Err() error {
if iter.err == RadosErrorNotFound {
return nil
}
return iter.err
} | [
"func",
"(",
"iter",
"*",
"Iter",
")",
"Err",
"(",
")",
"error",
"{",
"if",
"iter",
".",
"err",
"==",
"RadosErrorNotFound",
"{",
"return",
"nil",
"\n",
"}",
"\n",
"return",
"iter",
".",
"err",
"\n",
"}"
] | // Checks whether the iterator has encountered an error. | [
"Checks",
"whether",
"the",
"iterator",
"has",
"encountered",
"an",
"error",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/ioctx.go#L659-L664 | train |
ceph/go-ceph | rados/ioctx.go | LockExclusive | func (ioctx *IOContext) LockExclusive(oid, name, cookie, desc string, duration time.Duration, flags *byte) (int, error) {
c_oid := C.CString(oid)
c_name := C.CString(name)
c_cookie := C.CString(cookie)
c_desc := C.CString(desc)
var c_duration C.struct_timeval
if duration != 0 {
tv := syscall.NsecToTimeval(duration.Nanoseconds())
c_duration = C.struct_timeval{tv_sec: C.ceph_time_t(tv.Sec), tv_usec: C.ceph_suseconds_t(tv.Usec)}
}
var c_flags C.uint8_t
if flags != nil {
c_flags = C.uint8_t(*flags)
}
defer C.free(unsafe.Pointer(c_oid))
defer C.free(unsafe.Pointer(c_name))
defer C.free(unsafe.Pointer(c_cookie))
defer C.free(unsafe.Pointer(c_desc))
ret := C.rados_lock_exclusive(
ioctx.ioctx,
c_oid,
c_name,
c_cookie,
c_desc,
&c_duration,
c_flags)
// 0 on success, negative error code on failure
// -EBUSY if the lock is already held by another (client, cookie) pair
// -EEXIST if the lock is already held by the same (client, cookie) pair
switch ret {
case 0:
return int(ret), nil
case -C.EBUSY:
return int(ret), nil
case -C.EEXIST:
return int(ret), nil
default:
return int(ret), RadosError(int(ret))
}
} | go | func (ioctx *IOContext) LockExclusive(oid, name, cookie, desc string, duration time.Duration, flags *byte) (int, error) {
c_oid := C.CString(oid)
c_name := C.CString(name)
c_cookie := C.CString(cookie)
c_desc := C.CString(desc)
var c_duration C.struct_timeval
if duration != 0 {
tv := syscall.NsecToTimeval(duration.Nanoseconds())
c_duration = C.struct_timeval{tv_sec: C.ceph_time_t(tv.Sec), tv_usec: C.ceph_suseconds_t(tv.Usec)}
}
var c_flags C.uint8_t
if flags != nil {
c_flags = C.uint8_t(*flags)
}
defer C.free(unsafe.Pointer(c_oid))
defer C.free(unsafe.Pointer(c_name))
defer C.free(unsafe.Pointer(c_cookie))
defer C.free(unsafe.Pointer(c_desc))
ret := C.rados_lock_exclusive(
ioctx.ioctx,
c_oid,
c_name,
c_cookie,
c_desc,
&c_duration,
c_flags)
// 0 on success, negative error code on failure
// -EBUSY if the lock is already held by another (client, cookie) pair
// -EEXIST if the lock is already held by the same (client, cookie) pair
switch ret {
case 0:
return int(ret), nil
case -C.EBUSY:
return int(ret), nil
case -C.EEXIST:
return int(ret), nil
default:
return int(ret), RadosError(int(ret))
}
} | [
"func",
"(",
"ioctx",
"*",
"IOContext",
")",
"LockExclusive",
"(",
"oid",
",",
"name",
",",
"cookie",
",",
"desc",
"string",
",",
"duration",
"time",
".",
"Duration",
",",
"flags",
"*",
"byte",
")",
"(",
"int",
",",
"error",
")",
"{",
"c_oid",
":=",
... | // Take an exclusive lock on an object. | [
"Take",
"an",
"exclusive",
"lock",
"on",
"an",
"object",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/ioctx.go#L673-L718 | train |
ceph/go-ceph | rados/ioctx.go | Unlock | func (ioctx *IOContext) Unlock(oid, name, cookie string) (int, error) {
c_oid := C.CString(oid)
c_name := C.CString(name)
c_cookie := C.CString(cookie)
defer C.free(unsafe.Pointer(c_oid))
defer C.free(unsafe.Pointer(c_name))
defer C.free(unsafe.Pointer(c_cookie))
// 0 on success, negative error code on failure
// -ENOENT if the lock is not held by the specified (client, cookie) pair
ret := C.rados_unlock(
ioctx.ioctx,
c_oid,
c_name,
c_cookie)
switch ret {
case 0:
return int(ret), nil
case -C.ENOENT:
return int(ret), nil
default:
return int(ret), RadosError(int(ret))
}
} | go | func (ioctx *IOContext) Unlock(oid, name, cookie string) (int, error) {
c_oid := C.CString(oid)
c_name := C.CString(name)
c_cookie := C.CString(cookie)
defer C.free(unsafe.Pointer(c_oid))
defer C.free(unsafe.Pointer(c_name))
defer C.free(unsafe.Pointer(c_cookie))
// 0 on success, negative error code on failure
// -ENOENT if the lock is not held by the specified (client, cookie) pair
ret := C.rados_unlock(
ioctx.ioctx,
c_oid,
c_name,
c_cookie)
switch ret {
case 0:
return int(ret), nil
case -C.ENOENT:
return int(ret), nil
default:
return int(ret), RadosError(int(ret))
}
} | [
"func",
"(",
"ioctx",
"*",
"IOContext",
")",
"Unlock",
"(",
"oid",
",",
"name",
",",
"cookie",
"string",
")",
"(",
"int",
",",
"error",
")",
"{",
"c_oid",
":=",
"C",
".",
"CString",
"(",
"oid",
")",
"\n",
"c_name",
":=",
"C",
".",
"CString",
"(",... | // Release a shared or exclusive lock on an object. | [
"Release",
"a",
"shared",
"or",
"exclusive",
"lock",
"on",
"an",
"object",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/ioctx.go#L772-L798 | train |
ceph/go-ceph | rados/ioctx.go | ListLockers | func (ioctx *IOContext) ListLockers(oid, name string) (*LockInfo, error) {
c_oid := C.CString(oid)
c_name := C.CString(name)
c_tag := (*C.char)(C.malloc(C.size_t(1024)))
c_clients := (*C.char)(C.malloc(C.size_t(1024)))
c_cookies := (*C.char)(C.malloc(C.size_t(1024)))
c_addrs := (*C.char)(C.malloc(C.size_t(1024)))
var c_exclusive C.int
c_tag_len := C.size_t(1024)
c_clients_len := C.size_t(1024)
c_cookies_len := C.size_t(1024)
c_addrs_len := C.size_t(1024)
defer C.free(unsafe.Pointer(c_oid))
defer C.free(unsafe.Pointer(c_name))
defer C.free(unsafe.Pointer(c_tag))
defer C.free(unsafe.Pointer(c_clients))
defer C.free(unsafe.Pointer(c_cookies))
defer C.free(unsafe.Pointer(c_addrs))
ret := C.rados_list_lockers(
ioctx.ioctx,
c_oid,
c_name,
&c_exclusive,
c_tag,
&c_tag_len,
c_clients,
&c_clients_len,
c_cookies,
&c_cookies_len,
c_addrs,
&c_addrs_len)
splitCString := func(items *C.char, itemsLen C.size_t) []string {
currLen := 0
clients := []string{}
for currLen < int(itemsLen) {
client := C.GoString(C.nextChunk(&items))
clients = append(clients, client)
currLen += len(client) + 1
}
return clients
}
if ret < 0 {
return nil, RadosError(int(ret))
} else {
return &LockInfo{int(ret), c_exclusive == 1, C.GoString(c_tag), splitCString(c_clients, c_clients_len), splitCString(c_cookies, c_cookies_len), splitCString(c_addrs, c_addrs_len)}, nil
}
} | go | func (ioctx *IOContext) ListLockers(oid, name string) (*LockInfo, error) {
c_oid := C.CString(oid)
c_name := C.CString(name)
c_tag := (*C.char)(C.malloc(C.size_t(1024)))
c_clients := (*C.char)(C.malloc(C.size_t(1024)))
c_cookies := (*C.char)(C.malloc(C.size_t(1024)))
c_addrs := (*C.char)(C.malloc(C.size_t(1024)))
var c_exclusive C.int
c_tag_len := C.size_t(1024)
c_clients_len := C.size_t(1024)
c_cookies_len := C.size_t(1024)
c_addrs_len := C.size_t(1024)
defer C.free(unsafe.Pointer(c_oid))
defer C.free(unsafe.Pointer(c_name))
defer C.free(unsafe.Pointer(c_tag))
defer C.free(unsafe.Pointer(c_clients))
defer C.free(unsafe.Pointer(c_cookies))
defer C.free(unsafe.Pointer(c_addrs))
ret := C.rados_list_lockers(
ioctx.ioctx,
c_oid,
c_name,
&c_exclusive,
c_tag,
&c_tag_len,
c_clients,
&c_clients_len,
c_cookies,
&c_cookies_len,
c_addrs,
&c_addrs_len)
splitCString := func(items *C.char, itemsLen C.size_t) []string {
currLen := 0
clients := []string{}
for currLen < int(itemsLen) {
client := C.GoString(C.nextChunk(&items))
clients = append(clients, client)
currLen += len(client) + 1
}
return clients
}
if ret < 0 {
return nil, RadosError(int(ret))
} else {
return &LockInfo{int(ret), c_exclusive == 1, C.GoString(c_tag), splitCString(c_clients, c_clients_len), splitCString(c_cookies, c_cookies_len), splitCString(c_addrs, c_addrs_len)}, nil
}
} | [
"func",
"(",
"ioctx",
"*",
"IOContext",
")",
"ListLockers",
"(",
"oid",
",",
"name",
"string",
")",
"(",
"*",
"LockInfo",
",",
"error",
")",
"{",
"c_oid",
":=",
"C",
".",
"CString",
"(",
"oid",
")",
"\n",
"c_name",
":=",
"C",
".",
"CString",
"(",
... | // List clients that have locked the named object lock and information about the lock.
// The number of bytes required in each buffer is put in the corresponding size out parameter.
// If any of the provided buffers are too short, -ERANGE is returned after these sizes are filled in. | [
"List",
"clients",
"that",
"have",
"locked",
"the",
"named",
"object",
"lock",
"and",
"information",
"about",
"the",
"lock",
".",
"The",
"number",
"of",
"bytes",
"required",
"in",
"each",
"buffer",
"is",
"put",
"in",
"the",
"corresponding",
"size",
"out",
... | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/ioctx.go#L803-L855 | train |
ceph/go-ceph | rados/ioctx.go | BreakLock | func (ioctx *IOContext) BreakLock(oid, name, client, cookie string) (int, error) {
c_oid := C.CString(oid)
c_name := C.CString(name)
c_client := C.CString(client)
c_cookie := C.CString(cookie)
defer C.free(unsafe.Pointer(c_oid))
defer C.free(unsafe.Pointer(c_name))
defer C.free(unsafe.Pointer(c_client))
defer C.free(unsafe.Pointer(c_cookie))
// 0 on success, negative error code on failure
// -ENOENT if the lock is not held by the specified (client, cookie) pair
// -EINVAL if the client cannot be parsed
ret := C.rados_break_lock(
ioctx.ioctx,
c_oid,
c_name,
c_client,
c_cookie)
switch ret {
case 0:
return int(ret), nil
case -C.ENOENT:
return int(ret), nil
case -C.EINVAL: // -EINVAL
return int(ret), nil
default:
return int(ret), RadosError(int(ret))
}
} | go | func (ioctx *IOContext) BreakLock(oid, name, client, cookie string) (int, error) {
c_oid := C.CString(oid)
c_name := C.CString(name)
c_client := C.CString(client)
c_cookie := C.CString(cookie)
defer C.free(unsafe.Pointer(c_oid))
defer C.free(unsafe.Pointer(c_name))
defer C.free(unsafe.Pointer(c_client))
defer C.free(unsafe.Pointer(c_cookie))
// 0 on success, negative error code on failure
// -ENOENT if the lock is not held by the specified (client, cookie) pair
// -EINVAL if the client cannot be parsed
ret := C.rados_break_lock(
ioctx.ioctx,
c_oid,
c_name,
c_client,
c_cookie)
switch ret {
case 0:
return int(ret), nil
case -C.ENOENT:
return int(ret), nil
case -C.EINVAL: // -EINVAL
return int(ret), nil
default:
return int(ret), RadosError(int(ret))
}
} | [
"func",
"(",
"ioctx",
"*",
"IOContext",
")",
"BreakLock",
"(",
"oid",
",",
"name",
",",
"client",
",",
"cookie",
"string",
")",
"(",
"int",
",",
"error",
")",
"{",
"c_oid",
":=",
"C",
".",
"CString",
"(",
"oid",
")",
"\n",
"c_name",
":=",
"C",
".... | // Releases a shared or exclusive lock on an object, which was taken by the specified client. | [
"Releases",
"a",
"shared",
"or",
"exclusive",
"lock",
"on",
"an",
"object",
"which",
"was",
"taken",
"by",
"the",
"specified",
"client",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/ioctx.go#L858-L890 | train |
ceph/go-ceph | rbd/rbd.go | GetTrashList | func GetTrashList(ioctx *rados.IOContext) ([]TrashInfo, error) {
var num_entries C.size_t
// Call rbd_trash_list with nil pointer to get number of trash entries.
if C.rbd_trash_list(C.rados_ioctx_t(ioctx.Pointer()), nil, &num_entries); num_entries == 0 {
return nil, nil
}
c_entries := make([]C.rbd_trash_image_info_t, num_entries)
trashList := make([]TrashInfo, num_entries)
if ret := C.rbd_trash_list(C.rados_ioctx_t(ioctx.Pointer()), &c_entries[0], &num_entries); ret < 0 {
return nil, RBDError(ret)
}
for i, ti := range c_entries {
trashList[i] = TrashInfo{
Id: C.GoString(ti.id),
Name: C.GoString(ti.name),
DeletionTime: time.Unix(int64(ti.deletion_time), 0),
DefermentEndTime: time.Unix(int64(ti.deferment_end_time), 0),
}
}
// Free rbd_trash_image_info_t pointers
C.rbd_trash_list_cleanup(&c_entries[0], num_entries)
return trashList, nil
} | go | func GetTrashList(ioctx *rados.IOContext) ([]TrashInfo, error) {
var num_entries C.size_t
// Call rbd_trash_list with nil pointer to get number of trash entries.
if C.rbd_trash_list(C.rados_ioctx_t(ioctx.Pointer()), nil, &num_entries); num_entries == 0 {
return nil, nil
}
c_entries := make([]C.rbd_trash_image_info_t, num_entries)
trashList := make([]TrashInfo, num_entries)
if ret := C.rbd_trash_list(C.rados_ioctx_t(ioctx.Pointer()), &c_entries[0], &num_entries); ret < 0 {
return nil, RBDError(ret)
}
for i, ti := range c_entries {
trashList[i] = TrashInfo{
Id: C.GoString(ti.id),
Name: C.GoString(ti.name),
DeletionTime: time.Unix(int64(ti.deletion_time), 0),
DefermentEndTime: time.Unix(int64(ti.deferment_end_time), 0),
}
}
// Free rbd_trash_image_info_t pointers
C.rbd_trash_list_cleanup(&c_entries[0], num_entries)
return trashList, nil
} | [
"func",
"GetTrashList",
"(",
"ioctx",
"*",
"rados",
".",
"IOContext",
")",
"(",
"[",
"]",
"TrashInfo",
",",
"error",
")",
"{",
"var",
"num_entries",
"C",
".",
"size_t",
"\n\n",
"// Call rbd_trash_list with nil pointer to get number of trash entries.",
"if",
"C",
"... | // GetTrashList returns a slice of TrashInfo structs, containing information about all RBD images
// currently residing in the trash. | [
"GetTrashList",
"returns",
"a",
"slice",
"of",
"TrashInfo",
"structs",
"containing",
"information",
"about",
"all",
"RBD",
"images",
"currently",
"residing",
"in",
"the",
"trash",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rbd/rbd.go#L944-L972 | train |
ceph/go-ceph | rbd/rbd.go | TrashRemove | func TrashRemove(ioctx *rados.IOContext, id string, force bool) error {
c_id := C.CString(id)
defer C.free(unsafe.Pointer(c_id))
return GetError(C.rbd_trash_remove(C.rados_ioctx_t(ioctx.Pointer()), c_id, C.bool(force)))
} | go | func TrashRemove(ioctx *rados.IOContext, id string, force bool) error {
c_id := C.CString(id)
defer C.free(unsafe.Pointer(c_id))
return GetError(C.rbd_trash_remove(C.rados_ioctx_t(ioctx.Pointer()), c_id, C.bool(force)))
} | [
"func",
"TrashRemove",
"(",
"ioctx",
"*",
"rados",
".",
"IOContext",
",",
"id",
"string",
",",
"force",
"bool",
")",
"error",
"{",
"c_id",
":=",
"C",
".",
"CString",
"(",
"id",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(... | // TrashRemove permanently deletes the trashed RBD with the specified id. | [
"TrashRemove",
"permanently",
"deletes",
"the",
"trashed",
"RBD",
"with",
"the",
"specified",
"id",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rbd/rbd.go#L975-L980 | train |
ceph/go-ceph | rbd/rbd.go | TrashRestore | func TrashRestore(ioctx *rados.IOContext, id, name string) error {
c_id := C.CString(id)
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_id))
defer C.free(unsafe.Pointer(c_name))
return GetError(C.rbd_trash_restore(C.rados_ioctx_t(ioctx.Pointer()), c_id, c_name))
} | go | func TrashRestore(ioctx *rados.IOContext, id, name string) error {
c_id := C.CString(id)
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_id))
defer C.free(unsafe.Pointer(c_name))
return GetError(C.rbd_trash_restore(C.rados_ioctx_t(ioctx.Pointer()), c_id, c_name))
} | [
"func",
"TrashRestore",
"(",
"ioctx",
"*",
"rados",
".",
"IOContext",
",",
"id",
",",
"name",
"string",
")",
"error",
"{",
"c_id",
":=",
"C",
".",
"CString",
"(",
"id",
")",
"\n",
"c_name",
":=",
"C",
".",
"CString",
"(",
"name",
")",
"\n",
"defer"... | // TrashRestore restores the trashed RBD with the specified id back to the pool from whence it
// came, with the specified new name. | [
"TrashRestore",
"restores",
"the",
"trashed",
"RBD",
"with",
"the",
"specified",
"id",
"back",
"to",
"the",
"pool",
"from",
"whence",
"it",
"came",
"with",
"the",
"specified",
"new",
"name",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rbd/rbd.go#L984-L991 | train |
ceph/go-ceph | rados/rados.go | Version | func Version() (int, int, int) {
var c_major, c_minor, c_patch C.int
C.rados_version(&c_major, &c_minor, &c_patch)
return int(c_major), int(c_minor), int(c_patch)
} | go | func Version() (int, int, int) {
var c_major, c_minor, c_patch C.int
C.rados_version(&c_major, &c_minor, &c_patch)
return int(c_major), int(c_minor), int(c_patch)
} | [
"func",
"Version",
"(",
")",
"(",
"int",
",",
"int",
",",
"int",
")",
"{",
"var",
"c_major",
",",
"c_minor",
",",
"c_patch",
"C",
".",
"int",
"\n",
"C",
".",
"rados_version",
"(",
"&",
"c_major",
",",
"&",
"c_minor",
",",
"&",
"c_patch",
")",
"\n... | // Version returns the major, minor, and patch components of the version of
// the RADOS library linked against. | [
"Version",
"returns",
"the",
"major",
"minor",
"and",
"patch",
"components",
"of",
"the",
"version",
"of",
"the",
"RADOS",
"library",
"linked",
"against",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/rados.go#L34-L38 | train |
ceph/go-ceph | rados/rados.go | NewConnWithClusterAndUser | func NewConnWithClusterAndUser(clusterName string, userName string) (*Conn, error) {
c_cluster_name := C.CString(clusterName)
defer C.free(unsafe.Pointer(c_cluster_name))
c_name := C.CString(userName)
defer C.free(unsafe.Pointer(c_name))
conn := makeConn()
ret := C.rados_create2(&conn.cluster, c_cluster_name, c_name, 0)
if ret == 0 {
return conn, nil
} else {
return nil, RadosError(int(ret))
}
} | go | func NewConnWithClusterAndUser(clusterName string, userName string) (*Conn, error) {
c_cluster_name := C.CString(clusterName)
defer C.free(unsafe.Pointer(c_cluster_name))
c_name := C.CString(userName)
defer C.free(unsafe.Pointer(c_name))
conn := makeConn()
ret := C.rados_create2(&conn.cluster, c_cluster_name, c_name, 0)
if ret == 0 {
return conn, nil
} else {
return nil, RadosError(int(ret))
}
} | [
"func",
"NewConnWithClusterAndUser",
"(",
"clusterName",
"string",
",",
"userName",
"string",
")",
"(",
"*",
"Conn",
",",
"error",
")",
"{",
"c_cluster_name",
":=",
"C",
".",
"CString",
"(",
"clusterName",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe... | // NewConnWithClusterAndUser creates a new connection object for a specific cluster and username.
// It returns the connection and an error, if any. | [
"NewConnWithClusterAndUser",
"creates",
"a",
"new",
"connection",
"object",
"for",
"a",
"specific",
"cluster",
"and",
"username",
".",
"It",
"returns",
"the",
"connection",
"and",
"an",
"error",
"if",
"any",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/rados.go#L71-L85 | train |
ceph/go-ceph | cephfs/cephfs.go | CreateMount | func CreateMount() (*MountInfo, error) {
mount := &MountInfo{}
ret := C.ceph_create(&mount.mount, nil)
if ret != 0 {
log.Errorf("CreateMount: Failed to create mount")
return nil, cephError(ret)
}
return mount, nil
} | go | func CreateMount() (*MountInfo, error) {
mount := &MountInfo{}
ret := C.ceph_create(&mount.mount, nil)
if ret != 0 {
log.Errorf("CreateMount: Failed to create mount")
return nil, cephError(ret)
}
return mount, nil
} | [
"func",
"CreateMount",
"(",
")",
"(",
"*",
"MountInfo",
",",
"error",
")",
"{",
"mount",
":=",
"&",
"MountInfo",
"{",
"}",
"\n",
"ret",
":=",
"C",
".",
"ceph_create",
"(",
"&",
"mount",
".",
"mount",
",",
"nil",
")",
"\n",
"if",
"ret",
"!=",
"0",... | // CreateMount creates a mount handle for interacting with Ceph. | [
"CreateMount",
"creates",
"a",
"mount",
"handle",
"for",
"interacting",
"with",
"Ceph",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L35-L43 | train |
ceph/go-ceph | cephfs/cephfs.go | ReadDefaultConfigFile | func (mount *MountInfo) ReadDefaultConfigFile() error {
ret := C.ceph_conf_read_file(mount.mount, nil)
if ret != 0 {
log.Errorf("ReadDefaultConfigFile: Failed to read ceph config")
return cephError(ret)
}
return nil
} | go | func (mount *MountInfo) ReadDefaultConfigFile() error {
ret := C.ceph_conf_read_file(mount.mount, nil)
if ret != 0 {
log.Errorf("ReadDefaultConfigFile: Failed to read ceph config")
return cephError(ret)
}
return nil
} | [
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"ReadDefaultConfigFile",
"(",
")",
"error",
"{",
"ret",
":=",
"C",
".",
"ceph_conf_read_file",
"(",
"mount",
".",
"mount",
",",
"nil",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"log",
".",
"Errorf",
"(",
"\"... | // ReadDefaultConfigFile loads the ceph configuration from the specified config file. | [
"ReadDefaultConfigFile",
"loads",
"the",
"ceph",
"configuration",
"from",
"the",
"specified",
"config",
"file",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L46-L53 | train |
ceph/go-ceph | cephfs/cephfs.go | Mount | func (mount *MountInfo) Mount() error {
ret := C.ceph_mount(mount.mount, nil)
if ret != 0 {
log.Errorf("Mount: Failed to mount")
return cephError(ret)
}
return nil
} | go | func (mount *MountInfo) Mount() error {
ret := C.ceph_mount(mount.mount, nil)
if ret != 0 {
log.Errorf("Mount: Failed to mount")
return cephError(ret)
}
return nil
} | [
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"Mount",
"(",
")",
"error",
"{",
"ret",
":=",
"C",
".",
"ceph_mount",
"(",
"mount",
".",
"mount",
",",
"nil",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",... | // Mount mounts the mount handle. | [
"Mount",
"mounts",
"the",
"mount",
"handle",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L56-L63 | train |
ceph/go-ceph | cephfs/cephfs.go | Unmount | func (mount *MountInfo) Unmount() error {
ret := C.ceph_unmount(mount.mount)
if ret != 0 {
log.Errorf("Unmount: Failed to unmount")
return cephError(ret)
}
return nil
} | go | func (mount *MountInfo) Unmount() error {
ret := C.ceph_unmount(mount.mount)
if ret != 0 {
log.Errorf("Unmount: Failed to unmount")
return cephError(ret)
}
return nil
} | [
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"Unmount",
"(",
")",
"error",
"{",
"ret",
":=",
"C",
".",
"ceph_unmount",
"(",
"mount",
".",
"mount",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",... | // Unmount unmounts the mount handle. | [
"Unmount",
"unmounts",
"the",
"mount",
"handle",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L66-L73 | train |
ceph/go-ceph | cephfs/cephfs.go | Release | func (mount *MountInfo) Release() error {
ret := C.ceph_release(mount.mount)
if ret != 0 {
log.Errorf("Release: Failed to release mount")
return cephError(ret)
}
return nil
} | go | func (mount *MountInfo) Release() error {
ret := C.ceph_release(mount.mount)
if ret != 0 {
log.Errorf("Release: Failed to release mount")
return cephError(ret)
}
return nil
} | [
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"Release",
"(",
")",
"error",
"{",
"ret",
":=",
"C",
".",
"ceph_release",
"(",
"mount",
".",
"mount",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",... | // Release destroys the mount handle. | [
"Release",
"destroys",
"the",
"mount",
"handle",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L76-L83 | train |
ceph/go-ceph | cephfs/cephfs.go | SyncFs | func (mount *MountInfo) SyncFs() error {
ret := C.ceph_sync_fs(mount.mount)
if ret != 0 {
log.Errorf("Mount: Failed to sync filesystem")
return cephError(ret)
}
return nil
} | go | func (mount *MountInfo) SyncFs() error {
ret := C.ceph_sync_fs(mount.mount)
if ret != 0 {
log.Errorf("Mount: Failed to sync filesystem")
return cephError(ret)
}
return nil
} | [
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"SyncFs",
"(",
")",
"error",
"{",
"ret",
":=",
"C",
".",
"ceph_sync_fs",
"(",
"mount",
".",
"mount",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"log",
".",
"Errorf",
"(",
"\"",
"\"",
")",
"\n",
"return",
... | // SyncFs synchronizes all filesystem data to persistent media. | [
"SyncFs",
"synchronizes",
"all",
"filesystem",
"data",
"to",
"persistent",
"media",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L86-L93 | train |
ceph/go-ceph | cephfs/cephfs.go | CurrentDir | func (mount *MountInfo) CurrentDir() string {
cDir := C.ceph_getcwd(mount.mount)
return C.GoString(cDir)
} | go | func (mount *MountInfo) CurrentDir() string {
cDir := C.ceph_getcwd(mount.mount)
return C.GoString(cDir)
} | [
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"CurrentDir",
"(",
")",
"string",
"{",
"cDir",
":=",
"C",
".",
"ceph_getcwd",
"(",
"mount",
".",
"mount",
")",
"\n",
"return",
"C",
".",
"GoString",
"(",
"cDir",
")",
"\n",
"}"
] | // CurrentDir gets the current working directory. | [
"CurrentDir",
"gets",
"the",
"current",
"working",
"directory",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L96-L99 | train |
ceph/go-ceph | cephfs/cephfs.go | ChangeDir | func (mount *MountInfo) ChangeDir(path string) error {
cPath := C.CString(path)
defer C.free(unsafe.Pointer(cPath))
ret := C.ceph_chdir(mount.mount, cPath)
if ret != 0 {
log.Errorf("ChangeDir: Failed to change directory")
return cephError(ret)
}
return nil
} | go | func (mount *MountInfo) ChangeDir(path string) error {
cPath := C.CString(path)
defer C.free(unsafe.Pointer(cPath))
ret := C.ceph_chdir(mount.mount, cPath)
if ret != 0 {
log.Errorf("ChangeDir: Failed to change directory")
return cephError(ret)
}
return nil
} | [
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"ChangeDir",
"(",
"path",
"string",
")",
"error",
"{",
"cPath",
":=",
"C",
".",
"CString",
"(",
"path",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cPath",
")",
")",
"\n\n"... | // ChangeDir changes the current working directory. | [
"ChangeDir",
"changes",
"the",
"current",
"working",
"directory",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L102-L112 | train |
ceph/go-ceph | cephfs/cephfs.go | MakeDir | func (mount *MountInfo) MakeDir(path string, mode uint32) error {
cPath := C.CString(path)
defer C.free(unsafe.Pointer(cPath))
ret := C.ceph_mkdir(mount.mount, cPath, C.mode_t(mode))
if ret != 0 {
log.Errorf("MakeDir: Failed to make directory %s", path)
return cephError(ret)
}
return nil
} | go | func (mount *MountInfo) MakeDir(path string, mode uint32) error {
cPath := C.CString(path)
defer C.free(unsafe.Pointer(cPath))
ret := C.ceph_mkdir(mount.mount, cPath, C.mode_t(mode))
if ret != 0 {
log.Errorf("MakeDir: Failed to make directory %s", path)
return cephError(ret)
}
return nil
} | [
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"MakeDir",
"(",
"path",
"string",
",",
"mode",
"uint32",
")",
"error",
"{",
"cPath",
":=",
"C",
".",
"CString",
"(",
"path",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"cPa... | // MakeDir creates a directory. | [
"MakeDir",
"creates",
"a",
"directory",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L115-L125 | train |
ceph/go-ceph | cephfs/cephfs.go | IsMounted | func (mount *MountInfo) IsMounted() bool {
ret := C.ceph_is_mounted(mount.mount)
return ret == 1
} | go | func (mount *MountInfo) IsMounted() bool {
ret := C.ceph_is_mounted(mount.mount)
return ret == 1
} | [
"func",
"(",
"mount",
"*",
"MountInfo",
")",
"IsMounted",
"(",
")",
"bool",
"{",
"ret",
":=",
"C",
".",
"ceph_is_mounted",
"(",
"mount",
".",
"mount",
")",
"\n",
"return",
"ret",
"==",
"1",
"\n",
"}"
] | // IsMounted checks mount status. | [
"IsMounted",
"checks",
"mount",
"status",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/cephfs/cephfs.go#L167-L170 | train |
ceph/go-ceph | rados/conn.go | PingMonitor | func (c *Conn) PingMonitor(id string) (string, error) {
c_id := C.CString(id)
defer C.free(unsafe.Pointer(c_id))
var strlen C.size_t
var strout *C.char
ret := C.rados_ping_monitor(c.cluster, c_id, &strout, &strlen)
defer C.rados_buffer_free(strout)
if ret == 0 {
reply := C.GoStringN(strout, (C.int)(strlen))
return reply, nil
} else {
return "", RadosError(int(ret))
}
} | go | func (c *Conn) PingMonitor(id string) (string, error) {
c_id := C.CString(id)
defer C.free(unsafe.Pointer(c_id))
var strlen C.size_t
var strout *C.char
ret := C.rados_ping_monitor(c.cluster, c_id, &strout, &strlen)
defer C.rados_buffer_free(strout)
if ret == 0 {
reply := C.GoStringN(strout, (C.int)(strlen))
return reply, nil
} else {
return "", RadosError(int(ret))
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"PingMonitor",
"(",
"id",
"string",
")",
"(",
"string",
",",
"error",
")",
"{",
"c_id",
":=",
"C",
".",
"CString",
"(",
"id",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_id",
... | // PingMonitor sends a ping to a monitor and returns the reply. | [
"PingMonitor",
"sends",
"a",
"ping",
"to",
"a",
"monitor",
"and",
"returns",
"the",
"reply",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L27-L43 | train |
ceph/go-ceph | rados/conn.go | Connect | func (c *Conn) Connect() error {
ret := C.rados_connect(c.cluster)
if ret != 0 {
return RadosError(int(ret))
}
c.connected = true
return nil
} | go | func (c *Conn) Connect() error {
ret := C.rados_connect(c.cluster)
if ret != 0 {
return RadosError(int(ret))
}
c.connected = true
return nil
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"Connect",
"(",
")",
"error",
"{",
"ret",
":=",
"C",
".",
"rados_connect",
"(",
"c",
".",
"cluster",
")",
"\n",
"if",
"ret",
"!=",
"0",
"{",
"return",
"RadosError",
"(",
"int",
"(",
"ret",
")",
")",
"\n",
"}"... | // Connect establishes a connection to a RADOS cluster. It returns an error,
// if any. | [
"Connect",
"establishes",
"a",
"connection",
"to",
"a",
"RADOS",
"cluster",
".",
"It",
"returns",
"an",
"error",
"if",
"any",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L47-L54 | train |
ceph/go-ceph | rados/conn.go | Shutdown | func (c *Conn) Shutdown() {
if err := c.ensure_connected(); err != nil {
return
}
C.rados_shutdown(c.cluster)
} | go | func (c *Conn) Shutdown() {
if err := c.ensure_connected(); err != nil {
return
}
C.rados_shutdown(c.cluster)
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"Shutdown",
"(",
")",
"{",
"if",
"err",
":=",
"c",
".",
"ensure_connected",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"\n",
"}",
"\n",
"C",
".",
"rados_shutdown",
"(",
"c",
".",
"cluster",
")",
"\n",
... | // Shutdown disconnects from the cluster. | [
"Shutdown",
"disconnects",
"from",
"the",
"cluster",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L57-L62 | train |
ceph/go-ceph | rados/conn.go | ReadConfigFile | func (c *Conn) ReadConfigFile(path string) error {
c_path := C.CString(path)
defer C.free(unsafe.Pointer(c_path))
ret := C.rados_conf_read_file(c.cluster, c_path)
if ret == 0 {
return nil
} else {
return RadosError(int(ret))
}
} | go | func (c *Conn) ReadConfigFile(path string) error {
c_path := C.CString(path)
defer C.free(unsafe.Pointer(c_path))
ret := C.rados_conf_read_file(c.cluster, c_path)
if ret == 0 {
return nil
} else {
return RadosError(int(ret))
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"ReadConfigFile",
"(",
"path",
"string",
")",
"error",
"{",
"c_path",
":=",
"C",
".",
"CString",
"(",
"path",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_path",
")",
")",
"\n",
... | // ReadConfigFile configures the connection using a Ceph configuration file. | [
"ReadConfigFile",
"configures",
"the",
"connection",
"using",
"a",
"Ceph",
"configuration",
"file",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L65-L74 | train |
ceph/go-ceph | rados/conn.go | ReadDefaultConfigFile | func (c *Conn) ReadDefaultConfigFile() error {
ret := C.rados_conf_read_file(c.cluster, nil)
if ret == 0 {
return nil
} else {
return RadosError(int(ret))
}
} | go | func (c *Conn) ReadDefaultConfigFile() error {
ret := C.rados_conf_read_file(c.cluster, nil)
if ret == 0 {
return nil
} else {
return RadosError(int(ret))
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"ReadDefaultConfigFile",
"(",
")",
"error",
"{",
"ret",
":=",
"C",
".",
"rados_conf_read_file",
"(",
"c",
".",
"cluster",
",",
"nil",
")",
"\n",
"if",
"ret",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"else",
"{... | // ReadDefaultConfigFile configures the connection using a Ceph configuration
// file located at default locations. | [
"ReadDefaultConfigFile",
"configures",
"the",
"connection",
"using",
"a",
"Ceph",
"configuration",
"file",
"located",
"at",
"default",
"locations",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L78-L85 | train |
ceph/go-ceph | rados/conn.go | ListPools | func (c *Conn) ListPools() (names []string, err error) {
buf := make([]byte, 4096)
for {
ret := int(C.rados_pool_list(c.cluster,
(*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf))))
if ret < 0 {
return nil, RadosError(int(ret))
}
if ret > len(buf) {
buf = make([]byte, ret)
continue
}
tmp := bytes.SplitAfter(buf[:ret-1], []byte{0})
for _, s := range tmp {
if len(s) > 0 {
name := C.GoString((*C.char)(unsafe.Pointer(&s[0])))
names = append(names, name)
}
}
return names, nil
}
} | go | func (c *Conn) ListPools() (names []string, err error) {
buf := make([]byte, 4096)
for {
ret := int(C.rados_pool_list(c.cluster,
(*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf))))
if ret < 0 {
return nil, RadosError(int(ret))
}
if ret > len(buf) {
buf = make([]byte, ret)
continue
}
tmp := bytes.SplitAfter(buf[:ret-1], []byte{0})
for _, s := range tmp {
if len(s) > 0 {
name := C.GoString((*C.char)(unsafe.Pointer(&s[0])))
names = append(names, name)
}
}
return names, nil
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"ListPools",
"(",
")",
"(",
"names",
"[",
"]",
"string",
",",
"err",
"error",
")",
"{",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"4096",
")",
"\n",
"for",
"{",
"ret",
":=",
"int",
"(",
"C",
".",
"... | // ListPools returns the names of all existing pools. | [
"ListPools",
"returns",
"the",
"names",
"of",
"all",
"existing",
"pools",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L100-L124 | train |
ceph/go-ceph | rados/conn.go | SetConfigOption | func (c *Conn) SetConfigOption(option, value string) error {
c_opt, c_val := C.CString(option), C.CString(value)
defer C.free(unsafe.Pointer(c_opt))
defer C.free(unsafe.Pointer(c_val))
ret := C.rados_conf_set(c.cluster, c_opt, c_val)
if ret < 0 {
return RadosError(int(ret))
} else {
return nil
}
} | go | func (c *Conn) SetConfigOption(option, value string) error {
c_opt, c_val := C.CString(option), C.CString(value)
defer C.free(unsafe.Pointer(c_opt))
defer C.free(unsafe.Pointer(c_val))
ret := C.rados_conf_set(c.cluster, c_opt, c_val)
if ret < 0 {
return RadosError(int(ret))
} else {
return nil
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"SetConfigOption",
"(",
"option",
",",
"value",
"string",
")",
"error",
"{",
"c_opt",
",",
"c_val",
":=",
"C",
".",
"CString",
"(",
"option",
")",
",",
"C",
".",
"CString",
"(",
"value",
")",
"\n",
"defer",
"C",
... | // SetConfigOption sets the value of the configuration option identified by
// the given name. | [
"SetConfigOption",
"sets",
"the",
"value",
"of",
"the",
"configuration",
"option",
"identified",
"by",
"the",
"given",
"name",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L128-L138 | train |
ceph/go-ceph | rados/conn.go | GetConfigOption | func (c *Conn) GetConfigOption(name string) (value string, err error) {
buf := make([]byte, 4096)
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_name))
ret := int(C.rados_conf_get(c.cluster, c_name,
(*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf))))
// FIXME: ret may be -ENAMETOOLONG if the buffer is not large enough. We
// can handle this case, but we need a reliable way to test for
// -ENAMETOOLONG constant. Will the syscall/Errno stuff in Go help?
if ret == 0 {
value = C.GoString((*C.char)(unsafe.Pointer(&buf[0])))
return value, nil
} else {
return "", RadosError(ret)
}
} | go | func (c *Conn) GetConfigOption(name string) (value string, err error) {
buf := make([]byte, 4096)
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_name))
ret := int(C.rados_conf_get(c.cluster, c_name,
(*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf))))
// FIXME: ret may be -ENAMETOOLONG if the buffer is not large enough. We
// can handle this case, but we need a reliable way to test for
// -ENAMETOOLONG constant. Will the syscall/Errno stuff in Go help?
if ret == 0 {
value = C.GoString((*C.char)(unsafe.Pointer(&buf[0])))
return value, nil
} else {
return "", RadosError(ret)
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"GetConfigOption",
"(",
"name",
"string",
")",
"(",
"value",
"string",
",",
"err",
"error",
")",
"{",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"4096",
")",
"\n",
"c_name",
":=",
"C",
".",
"CString",
"("... | // GetConfigOption returns the value of the Ceph configuration option
// identified by the given name. | [
"GetConfigOption",
"returns",
"the",
"value",
"of",
"the",
"Ceph",
"configuration",
"option",
"identified",
"by",
"the",
"given",
"name",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L142-L157 | train |
ceph/go-ceph | rados/conn.go | GetClusterStats | func (c *Conn) GetClusterStats() (stat ClusterStat, err error) {
if err := c.ensure_connected(); err != nil {
return ClusterStat{}, err
}
c_stat := C.struct_rados_cluster_stat_t{}
ret := C.rados_cluster_stat(c.cluster, &c_stat)
if ret < 0 {
return ClusterStat{}, RadosError(int(ret))
} else {
return ClusterStat{
Kb: uint64(c_stat.kb),
Kb_used: uint64(c_stat.kb_used),
Kb_avail: uint64(c_stat.kb_avail),
Num_objects: uint64(c_stat.num_objects),
}, nil
}
} | go | func (c *Conn) GetClusterStats() (stat ClusterStat, err error) {
if err := c.ensure_connected(); err != nil {
return ClusterStat{}, err
}
c_stat := C.struct_rados_cluster_stat_t{}
ret := C.rados_cluster_stat(c.cluster, &c_stat)
if ret < 0 {
return ClusterStat{}, RadosError(int(ret))
} else {
return ClusterStat{
Kb: uint64(c_stat.kb),
Kb_used: uint64(c_stat.kb_used),
Kb_avail: uint64(c_stat.kb_avail),
Num_objects: uint64(c_stat.num_objects),
}, nil
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"GetClusterStats",
"(",
")",
"(",
"stat",
"ClusterStat",
",",
"err",
"error",
")",
"{",
"if",
"err",
":=",
"c",
".",
"ensure_connected",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"ClusterStat",
"{",
"}",
... | // GetClusterStat returns statistics about the cluster associated with the
// connection. | [
"GetClusterStat",
"returns",
"statistics",
"about",
"the",
"cluster",
"associated",
"with",
"the",
"connection",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L180-L196 | train |
ceph/go-ceph | rados/conn.go | ParseCmdLineArgs | func (c *Conn) ParseCmdLineArgs(args []string) error {
// add an empty element 0 -- Ceph treats the array as the actual contents
// of argv and skips the first element (the executable name)
argc := C.int(len(args) + 1)
argv := make([]*C.char, argc)
// make the first element a string just in case it is ever examined
argv[0] = C.CString("placeholder")
defer C.free(unsafe.Pointer(argv[0]))
for i, arg := range args {
argv[i+1] = C.CString(arg)
defer C.free(unsafe.Pointer(argv[i+1]))
}
ret := C.rados_conf_parse_argv(c.cluster, argc, &argv[0])
if ret < 0 {
return RadosError(int(ret))
} else {
return nil
}
} | go | func (c *Conn) ParseCmdLineArgs(args []string) error {
// add an empty element 0 -- Ceph treats the array as the actual contents
// of argv and skips the first element (the executable name)
argc := C.int(len(args) + 1)
argv := make([]*C.char, argc)
// make the first element a string just in case it is ever examined
argv[0] = C.CString("placeholder")
defer C.free(unsafe.Pointer(argv[0]))
for i, arg := range args {
argv[i+1] = C.CString(arg)
defer C.free(unsafe.Pointer(argv[i+1]))
}
ret := C.rados_conf_parse_argv(c.cluster, argc, &argv[0])
if ret < 0 {
return RadosError(int(ret))
} else {
return nil
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"ParseCmdLineArgs",
"(",
"args",
"[",
"]",
"string",
")",
"error",
"{",
"// add an empty element 0 -- Ceph treats the array as the actual contents",
"// of argv and skips the first element (the executable name)",
"argc",
":=",
"C",
".",
"... | // ParseCmdLineArgs configures the connection from command line arguments. | [
"ParseCmdLineArgs",
"configures",
"the",
"connection",
"from",
"command",
"line",
"arguments",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L199-L220 | train |
ceph/go-ceph | rados/conn.go | GetFSID | func (c *Conn) GetFSID() (fsid string, err error) {
buf := make([]byte, 37)
ret := int(C.rados_cluster_fsid(c.cluster,
(*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf))))
// FIXME: the success case isn't documented correctly in librados.h
if ret == 36 {
fsid = C.GoString((*C.char)(unsafe.Pointer(&buf[0])))
return fsid, nil
} else {
return "", RadosError(int(ret))
}
} | go | func (c *Conn) GetFSID() (fsid string, err error) {
buf := make([]byte, 37)
ret := int(C.rados_cluster_fsid(c.cluster,
(*C.char)(unsafe.Pointer(&buf[0])), C.size_t(len(buf))))
// FIXME: the success case isn't documented correctly in librados.h
if ret == 36 {
fsid = C.GoString((*C.char)(unsafe.Pointer(&buf[0])))
return fsid, nil
} else {
return "", RadosError(int(ret))
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"GetFSID",
"(",
")",
"(",
"fsid",
"string",
",",
"err",
"error",
")",
"{",
"buf",
":=",
"make",
"(",
"[",
"]",
"byte",
",",
"37",
")",
"\n",
"ret",
":=",
"int",
"(",
"C",
".",
"rados_cluster_fsid",
"(",
"c",
... | // GetFSID returns the fsid of the cluster as a hexadecimal string. The fsid
// is a unique identifier of an entire Ceph cluster. | [
"GetFSID",
"returns",
"the",
"fsid",
"of",
"the",
"cluster",
"as",
"a",
"hexadecimal",
"string",
".",
"The",
"fsid",
"is",
"a",
"unique",
"identifier",
"of",
"an",
"entire",
"Ceph",
"cluster",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L235-L246 | train |
ceph/go-ceph | rados/conn.go | MakePool | func (c *Conn) MakePool(name string) error {
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_name))
ret := int(C.rados_pool_create(c.cluster, c_name))
if ret == 0 {
return nil
} else {
return RadosError(ret)
}
} | go | func (c *Conn) MakePool(name string) error {
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_name))
ret := int(C.rados_pool_create(c.cluster, c_name))
if ret == 0 {
return nil
} else {
return RadosError(ret)
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"MakePool",
"(",
"name",
"string",
")",
"error",
"{",
"c_name",
":=",
"C",
".",
"CString",
"(",
"name",
")",
"\n",
"defer",
"C",
".",
"free",
"(",
"unsafe",
".",
"Pointer",
"(",
"c_name",
")",
")",
"\n",
"ret",... | // MakePool creates a new pool with default settings. | [
"MakePool",
"creates",
"a",
"new",
"pool",
"with",
"default",
"settings",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L256-L265 | train |
ceph/go-ceph | rados/conn.go | DeletePool | func (c *Conn) DeletePool(name string) error {
if err := c.ensure_connected(); err != nil {
fmt.Println("NOT CONNECTED WHOOPS")
return err
}
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_name))
ret := int(C.rados_pool_delete(c.cluster, c_name))
if ret == 0 {
return nil
} else {
return RadosError(ret)
}
} | go | func (c *Conn) DeletePool(name string) error {
if err := c.ensure_connected(); err != nil {
fmt.Println("NOT CONNECTED WHOOPS")
return err
}
c_name := C.CString(name)
defer C.free(unsafe.Pointer(c_name))
ret := int(C.rados_pool_delete(c.cluster, c_name))
if ret == 0 {
return nil
} else {
return RadosError(ret)
}
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"DeletePool",
"(",
"name",
"string",
")",
"error",
"{",
"if",
"err",
":=",
"c",
".",
"ensure_connected",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"fmt",
".",
"Println",
"(",
"\"",
"\"",
")",
"\n",
"return",
"err... | // DeletePool deletes a pool and all the data inside the pool. | [
"DeletePool",
"deletes",
"a",
"pool",
"and",
"all",
"the",
"data",
"inside",
"the",
"pool",
"."
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L268-L281 | train |
ceph/go-ceph | rados/conn.go | MonCommand | func (c *Conn) MonCommand(args []byte) (buffer []byte, info string, err error) {
return c.monCommand(args, nil)
} | go | func (c *Conn) MonCommand(args []byte) (buffer []byte, info string, err error) {
return c.monCommand(args, nil)
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"MonCommand",
"(",
"args",
"[",
"]",
"byte",
")",
"(",
"buffer",
"[",
"]",
"byte",
",",
"info",
"string",
",",
"err",
"error",
")",
"{",
"return",
"c",
".",
"monCommand",
"(",
"args",
",",
"nil",
")",
"\n",
"... | // MonCommand sends a command to one of the monitors | [
"MonCommand",
"sends",
"a",
"command",
"to",
"one",
"of",
"the",
"monitors"
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L284-L286 | train |
ceph/go-ceph | rados/conn.go | MonCommandWithInputBuffer | func (c *Conn) MonCommandWithInputBuffer(args, inputBuffer []byte) (buffer []byte, info string, err error) {
return c.monCommand(args, inputBuffer)
} | go | func (c *Conn) MonCommandWithInputBuffer(args, inputBuffer []byte) (buffer []byte, info string, err error) {
return c.monCommand(args, inputBuffer)
} | [
"func",
"(",
"c",
"*",
"Conn",
")",
"MonCommandWithInputBuffer",
"(",
"args",
",",
"inputBuffer",
"[",
"]",
"byte",
")",
"(",
"buffer",
"[",
"]",
"byte",
",",
"info",
"string",
",",
"err",
"error",
")",
"{",
"return",
"c",
".",
"monCommand",
"(",
"ar... | // MonCommand sends a command to one of the monitors, with an input buffer | [
"MonCommand",
"sends",
"a",
"command",
"to",
"one",
"of",
"the",
"monitors",
"with",
"an",
"input",
"buffer"
] | e32f9f0f2e941422937c0a6c4f0a61b8f0c82995 | https://github.com/ceph/go-ceph/blob/e32f9f0f2e941422937c0a6c4f0a61b8f0c82995/rados/conn.go#L289-L291 | train |
Microsoft/go-winio | hvsock.go | VsockServiceID | func VsockServiceID(port uint32) guid.GUID {
g, _ := guid.FromString("00000000-facb-11e6-bd58-64006a7986d3")
g.Data1 = port
return *g
} | go | func VsockServiceID(port uint32) guid.GUID {
g, _ := guid.FromString("00000000-facb-11e6-bd58-64006a7986d3")
g.Data1 = port
return *g
} | [
"func",
"VsockServiceID",
"(",
"port",
"uint32",
")",
"guid",
".",
"GUID",
"{",
"g",
",",
"_",
":=",
"guid",
".",
"FromString",
"(",
"\"",
"\"",
")",
"\n",
"g",
".",
"Data1",
"=",
"port",
"\n",
"return",
"*",
"g",
"\n",
"}"
] | // VsockServiceID returns an hvsock service ID corresponding to the specified AF_VSOCK port. | [
"VsockServiceID",
"returns",
"an",
"hvsock",
"service",
"ID",
"corresponding",
"to",
"the",
"specified",
"AF_VSOCK",
"port",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/hvsock.go#L46-L50 | train |
Microsoft/go-winio | hvsock.go | ListenHvsock | func ListenHvsock(addr *HvsockAddr) (_ *HvsockListener, err error) {
l := &HvsockListener{addr: *addr}
sock, err := newHvSocket()
if err != nil {
return nil, l.opErr("listen", err)
}
sa := addr.raw()
err = bind(sock.handle, unsafe.Pointer(&sa), int32(unsafe.Sizeof(sa)))
if err != nil {
return nil, l.opErr("listen", os.NewSyscallError("socket", err))
}
err = syscall.Listen(sock.handle, 16)
if err != nil {
return nil, l.opErr("listen", os.NewSyscallError("listen", err))
}
return &HvsockListener{sock: sock, addr: *addr}, nil
} | go | func ListenHvsock(addr *HvsockAddr) (_ *HvsockListener, err error) {
l := &HvsockListener{addr: *addr}
sock, err := newHvSocket()
if err != nil {
return nil, l.opErr("listen", err)
}
sa := addr.raw()
err = bind(sock.handle, unsafe.Pointer(&sa), int32(unsafe.Sizeof(sa)))
if err != nil {
return nil, l.opErr("listen", os.NewSyscallError("socket", err))
}
err = syscall.Listen(sock.handle, 16)
if err != nil {
return nil, l.opErr("listen", os.NewSyscallError("listen", err))
}
return &HvsockListener{sock: sock, addr: *addr}, nil
} | [
"func",
"ListenHvsock",
"(",
"addr",
"*",
"HvsockAddr",
")",
"(",
"_",
"*",
"HvsockListener",
",",
"err",
"error",
")",
"{",
"l",
":=",
"&",
"HvsockListener",
"{",
"addr",
":",
"*",
"addr",
"}",
"\n",
"sock",
",",
"err",
":=",
"newHvSocket",
"(",
")"... | // ListenHvsock listens for connections on the specified hvsock address. | [
"ListenHvsock",
"listens",
"for",
"connections",
"on",
"the",
"specified",
"hvsock",
"address",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/hvsock.go#L92-L108 | train |
Microsoft/go-winio | hvsock.go | Accept | func (l *HvsockListener) Accept() (_ net.Conn, err error) {
sock, err := newHvSocket()
if err != nil {
return nil, l.opErr("accept", err)
}
defer func() {
if sock != nil {
sock.Close()
}
}()
c, err := l.sock.prepareIo()
if err != nil {
return nil, l.opErr("accept", err)
}
defer l.sock.wg.Done()
// AcceptEx, per documentation, requires an extra 16 bytes per address.
const addrlen = uint32(16 + unsafe.Sizeof(rawHvsockAddr{}))
var addrbuf [addrlen * 2]byte
var bytes uint32
err = syscall.AcceptEx(l.sock.handle, sock.handle, &addrbuf[0], 0, addrlen, addrlen, &bytes, &c.o)
_, err = l.sock.asyncIo(c, nil, bytes, err)
if err != nil {
return nil, l.opErr("accept", os.NewSyscallError("acceptex", err))
}
conn := &HvsockConn{
sock: sock,
}
conn.local.fromRaw((*rawHvsockAddr)(unsafe.Pointer(&addrbuf[0])))
conn.remote.fromRaw((*rawHvsockAddr)(unsafe.Pointer(&addrbuf[addrlen])))
sock = nil
return conn, nil
} | go | func (l *HvsockListener) Accept() (_ net.Conn, err error) {
sock, err := newHvSocket()
if err != nil {
return nil, l.opErr("accept", err)
}
defer func() {
if sock != nil {
sock.Close()
}
}()
c, err := l.sock.prepareIo()
if err != nil {
return nil, l.opErr("accept", err)
}
defer l.sock.wg.Done()
// AcceptEx, per documentation, requires an extra 16 bytes per address.
const addrlen = uint32(16 + unsafe.Sizeof(rawHvsockAddr{}))
var addrbuf [addrlen * 2]byte
var bytes uint32
err = syscall.AcceptEx(l.sock.handle, sock.handle, &addrbuf[0], 0, addrlen, addrlen, &bytes, &c.o)
_, err = l.sock.asyncIo(c, nil, bytes, err)
if err != nil {
return nil, l.opErr("accept", os.NewSyscallError("acceptex", err))
}
conn := &HvsockConn{
sock: sock,
}
conn.local.fromRaw((*rawHvsockAddr)(unsafe.Pointer(&addrbuf[0])))
conn.remote.fromRaw((*rawHvsockAddr)(unsafe.Pointer(&addrbuf[addrlen])))
sock = nil
return conn, nil
} | [
"func",
"(",
"l",
"*",
"HvsockListener",
")",
"Accept",
"(",
")",
"(",
"_",
"net",
".",
"Conn",
",",
"err",
"error",
")",
"{",
"sock",
",",
"err",
":=",
"newHvSocket",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",
",",
"l",
".... | // Accept waits for the next connection and returns it. | [
"Accept",
"waits",
"for",
"the",
"next",
"connection",
"and",
"returns",
"it",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/hvsock.go#L120-L153 | train |
Microsoft/go-winio | hvsock.go | CloseRead | func (conn *HvsockConn) CloseRead() error {
err := conn.shutdown(syscall.SHUT_RD)
if err != nil {
return conn.opErr("close", err)
}
return nil
} | go | func (conn *HvsockConn) CloseRead() error {
err := conn.shutdown(syscall.SHUT_RD)
if err != nil {
return conn.opErr("close", err)
}
return nil
} | [
"func",
"(",
"conn",
"*",
"HvsockConn",
")",
"CloseRead",
"(",
")",
"error",
"{",
"err",
":=",
"conn",
".",
"shutdown",
"(",
"syscall",
".",
"SHUT_RD",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"conn",
".",
"opErr",
"(",
"\"",
"\"",
",",
... | // CloseRead shuts down the read end of the socket. | [
"CloseRead",
"shuts",
"down",
"the",
"read",
"end",
"of",
"the",
"socket",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/hvsock.go#L262-L268 | train |
Microsoft/go-winio | hvsock.go | CloseWrite | func (conn *HvsockConn) CloseWrite() error {
err := conn.shutdown(syscall.SHUT_WR)
if err != nil {
return conn.opErr("close", err)
}
return nil
} | go | func (conn *HvsockConn) CloseWrite() error {
err := conn.shutdown(syscall.SHUT_WR)
if err != nil {
return conn.opErr("close", err)
}
return nil
} | [
"func",
"(",
"conn",
"*",
"HvsockConn",
")",
"CloseWrite",
"(",
")",
"error",
"{",
"err",
":=",
"conn",
".",
"shutdown",
"(",
"syscall",
".",
"SHUT_WR",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"conn",
".",
"opErr",
"(",
"\"",
"\"",
",",... | // CloseWrite shuts down the write end of the socket, notifying the other endpoint that
// no more data will be written. | [
"CloseWrite",
"shuts",
"down",
"the",
"write",
"end",
"of",
"the",
"socket",
"notifying",
"the",
"other",
"endpoint",
"that",
"no",
"more",
"data",
"will",
"be",
"written",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/hvsock.go#L272-L278 | train |
Microsoft/go-winio | ea.go | DecodeExtendedAttributes | func DecodeExtendedAttributes(b []byte) (eas []ExtendedAttribute, err error) {
for len(b) != 0 {
ea, nb, err := parseEa(b)
if err != nil {
return nil, err
}
eas = append(eas, ea)
b = nb
}
return
} | go | func DecodeExtendedAttributes(b []byte) (eas []ExtendedAttribute, err error) {
for len(b) != 0 {
ea, nb, err := parseEa(b)
if err != nil {
return nil, err
}
eas = append(eas, ea)
b = nb
}
return
} | [
"func",
"DecodeExtendedAttributes",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"eas",
"[",
"]",
"ExtendedAttribute",
",",
"err",
"error",
")",
"{",
"for",
"len",
"(",
"b",
")",
"!=",
"0",
"{",
"ea",
",",
"nb",
",",
"err",
":=",
"parseEa",
"(",
"b",
")... | // DecodeExtendedAttributes decodes a list of EAs from a FILE_FULL_EA_INFORMATION
// buffer retrieved from BackupRead, ZwQueryEaFile, etc. | [
"DecodeExtendedAttributes",
"decodes",
"a",
"list",
"of",
"EAs",
"from",
"a",
"FILE_FULL_EA_INFORMATION",
"buffer",
"retrieved",
"from",
"BackupRead",
"ZwQueryEaFile",
"etc",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/ea.go#L60-L71 | train |
Microsoft/go-winio | ea.go | EncodeExtendedAttributes | func EncodeExtendedAttributes(eas []ExtendedAttribute) ([]byte, error) {
var buf bytes.Buffer
for i := range eas {
last := false
if i == len(eas)-1 {
last = true
}
err := writeEa(&buf, &eas[i], last)
if err != nil {
return nil, err
}
}
return buf.Bytes(), nil
} | go | func EncodeExtendedAttributes(eas []ExtendedAttribute) ([]byte, error) {
var buf bytes.Buffer
for i := range eas {
last := false
if i == len(eas)-1 {
last = true
}
err := writeEa(&buf, &eas[i], last)
if err != nil {
return nil, err
}
}
return buf.Bytes(), nil
} | [
"func",
"EncodeExtendedAttributes",
"(",
"eas",
"[",
"]",
"ExtendedAttribute",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"var",
"buf",
"bytes",
".",
"Buffer",
"\n",
"for",
"i",
":=",
"range",
"eas",
"{",
"last",
":=",
"false",
"\n",
"if",
"... | // EncodeExtendedAttributes encodes a list of EAs into a FILE_FULL_EA_INFORMATION
// buffer for use with BackupWrite, ZwSetEaFile, etc. | [
"EncodeExtendedAttributes",
"encodes",
"a",
"list",
"of",
"EAs",
"into",
"a",
"FILE_FULL_EA_INFORMATION",
"buffer",
"for",
"use",
"with",
"BackupWrite",
"ZwSetEaFile",
"etc",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/ea.go#L123-L137 | train |
Microsoft/go-winio | reparse.go | DecodeReparsePoint | func DecodeReparsePoint(b []byte) (*ReparsePoint, error) {
tag := binary.LittleEndian.Uint32(b[0:4])
return DecodeReparsePointData(tag, b[8:])
} | go | func DecodeReparsePoint(b []byte) (*ReparsePoint, error) {
tag := binary.LittleEndian.Uint32(b[0:4])
return DecodeReparsePointData(tag, b[8:])
} | [
"func",
"DecodeReparsePoint",
"(",
"b",
"[",
"]",
"byte",
")",
"(",
"*",
"ReparsePoint",
",",
"error",
")",
"{",
"tag",
":=",
"binary",
".",
"LittleEndian",
".",
"Uint32",
"(",
"b",
"[",
"0",
":",
"4",
"]",
")",
"\n",
"return",
"DecodeReparsePointData"... | // DecodeReparsePoint decodes a Win32 REPARSE_DATA_BUFFER structure containing either a symlink
// or a mount point. | [
"DecodeReparsePoint",
"decodes",
"a",
"Win32",
"REPARSE_DATA_BUFFER",
"structure",
"containing",
"either",
"a",
"symlink",
"or",
"a",
"mount",
"point",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/reparse.go#L45-L48 | train |
Microsoft/go-winio | reparse.go | EncodeReparsePoint | func EncodeReparsePoint(rp *ReparsePoint) []byte {
// Generate an NT path and determine if this is a relative path.
var ntTarget string
relative := false
if strings.HasPrefix(rp.Target, `\\?\`) {
ntTarget = `\??\` + rp.Target[4:]
} else if strings.HasPrefix(rp.Target, `\\`) {
ntTarget = `\??\UNC\` + rp.Target[2:]
} else if len(rp.Target) >= 2 && isDriveLetter(rp.Target[0]) && rp.Target[1] == ':' {
ntTarget = `\??\` + rp.Target
} else {
ntTarget = rp.Target
relative = true
}
// The paths must be NUL-terminated even though they are counted strings.
target16 := utf16.Encode([]rune(rp.Target + "\x00"))
ntTarget16 := utf16.Encode([]rune(ntTarget + "\x00"))
size := int(unsafe.Sizeof(reparseDataBuffer{})) - 8
size += len(ntTarget16)*2 + len(target16)*2
tag := uint32(reparseTagMountPoint)
if !rp.IsMountPoint {
tag = reparseTagSymlink
size += 4 // Add room for symlink flags
}
data := reparseDataBuffer{
ReparseTag: tag,
ReparseDataLength: uint16(size),
SubstituteNameOffset: 0,
SubstituteNameLength: uint16((len(ntTarget16) - 1) * 2),
PrintNameOffset: uint16(len(ntTarget16) * 2),
PrintNameLength: uint16((len(target16) - 1) * 2),
}
var b bytes.Buffer
binary.Write(&b, binary.LittleEndian, &data)
if !rp.IsMountPoint {
flags := uint32(0)
if relative {
flags |= 1
}
binary.Write(&b, binary.LittleEndian, flags)
}
binary.Write(&b, binary.LittleEndian, ntTarget16)
binary.Write(&b, binary.LittleEndian, target16)
return b.Bytes()
} | go | func EncodeReparsePoint(rp *ReparsePoint) []byte {
// Generate an NT path and determine if this is a relative path.
var ntTarget string
relative := false
if strings.HasPrefix(rp.Target, `\\?\`) {
ntTarget = `\??\` + rp.Target[4:]
} else if strings.HasPrefix(rp.Target, `\\`) {
ntTarget = `\??\UNC\` + rp.Target[2:]
} else if len(rp.Target) >= 2 && isDriveLetter(rp.Target[0]) && rp.Target[1] == ':' {
ntTarget = `\??\` + rp.Target
} else {
ntTarget = rp.Target
relative = true
}
// The paths must be NUL-terminated even though they are counted strings.
target16 := utf16.Encode([]rune(rp.Target + "\x00"))
ntTarget16 := utf16.Encode([]rune(ntTarget + "\x00"))
size := int(unsafe.Sizeof(reparseDataBuffer{})) - 8
size += len(ntTarget16)*2 + len(target16)*2
tag := uint32(reparseTagMountPoint)
if !rp.IsMountPoint {
tag = reparseTagSymlink
size += 4 // Add room for symlink flags
}
data := reparseDataBuffer{
ReparseTag: tag,
ReparseDataLength: uint16(size),
SubstituteNameOffset: 0,
SubstituteNameLength: uint16((len(ntTarget16) - 1) * 2),
PrintNameOffset: uint16(len(ntTarget16) * 2),
PrintNameLength: uint16((len(target16) - 1) * 2),
}
var b bytes.Buffer
binary.Write(&b, binary.LittleEndian, &data)
if !rp.IsMountPoint {
flags := uint32(0)
if relative {
flags |= 1
}
binary.Write(&b, binary.LittleEndian, flags)
}
binary.Write(&b, binary.LittleEndian, ntTarget16)
binary.Write(&b, binary.LittleEndian, target16)
return b.Bytes()
} | [
"func",
"EncodeReparsePoint",
"(",
"rp",
"*",
"ReparsePoint",
")",
"[",
"]",
"byte",
"{",
"// Generate an NT path and determine if this is a relative path.",
"var",
"ntTarget",
"string",
"\n",
"relative",
":=",
"false",
"\n",
"if",
"strings",
".",
"HasPrefix",
"(",
... | // EncodeReparsePoint encodes a Win32 REPARSE_DATA_BUFFER structure describing a symlink or
// mount point. | [
"EncodeReparsePoint",
"encodes",
"a",
"Win32",
"REPARSE_DATA_BUFFER",
"structure",
"describing",
"a",
"symlink",
"or",
"mount",
"point",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/reparse.go#L78-L128 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | BoolField | func BoolField(name string, value bool) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint8, outTypeBoolean, 0)
bool8 := uint8(0)
if value {
bool8 = uint8(1)
}
ed.writeUint8(bool8)
}
} | go | func BoolField(name string, value bool) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint8, outTypeBoolean, 0)
bool8 := uint8(0)
if value {
bool8 = uint8(1)
}
ed.writeUint8(bool8)
}
} | [
"func",
"BoolField",
"(",
"name",
"string",
",",
"value",
"bool",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeUint8",
",",
"outTypeBoole... | // BoolField adds a single bool field to the event. | [
"BoolField",
"adds",
"a",
"single",
"bool",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L20-L29 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | BoolArray | func BoolArray(name string, values []bool) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint8, outTypeBoolean, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
bool8 := uint8(0)
if v {
bool8 = uint8(1)
}
ed.writeUint8(bool8)
}
}
} | go | func BoolArray(name string, values []bool) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint8, outTypeBoolean, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
bool8 := uint8(0)
if v {
bool8 = uint8(1)
}
ed.writeUint8(bool8)
}
}
} | [
"func",
"BoolArray",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"bool",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeUint8",
",",
... | // BoolArray adds an array of bool to the event. | [
"BoolArray",
"adds",
"an",
"array",
"of",
"bool",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L32-L44 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | StringField | func StringField(name string, value string) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeANSIString, outTypeUTF8, 0)
ed.writeString(value)
}
} | go | func StringField(name string, value string) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeANSIString, outTypeUTF8, 0)
ed.writeString(value)
}
} | [
"func",
"StringField",
"(",
"name",
"string",
",",
"value",
"string",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeANSIString",
",",
"out... | // StringField adds a single string field to the event. | [
"StringField",
"adds",
"a",
"single",
"string",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L47-L52 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | StringArray | func StringArray(name string, values []string) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeANSIString, outTypeUTF8, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeString(v)
}
}
} | go | func StringArray(name string, values []string) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeANSIString, outTypeUTF8, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeString(v)
}
}
} | [
"func",
"StringArray",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"string",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeANSIString"... | // StringArray adds an array of string to the event. | [
"StringArray",
"adds",
"an",
"array",
"of",
"string",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L55-L63 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | IntField | func IntField(name string, value int) FieldOpt {
switch unsafe.Sizeof(value) {
case 4:
return Int32Field(name, int32(value))
case 8:
return Int64Field(name, int64(value))
default:
panic("Unsupported int size")
}
} | go | func IntField(name string, value int) FieldOpt {
switch unsafe.Sizeof(value) {
case 4:
return Int32Field(name, int32(value))
case 8:
return Int64Field(name, int64(value))
default:
panic("Unsupported int size")
}
} | [
"func",
"IntField",
"(",
"name",
"string",
",",
"value",
"int",
")",
"FieldOpt",
"{",
"switch",
"unsafe",
".",
"Sizeof",
"(",
"value",
")",
"{",
"case",
"4",
":",
"return",
"Int32Field",
"(",
"name",
",",
"int32",
"(",
"value",
")",
")",
"\n",
"case"... | // IntField adds a single int field to the event. | [
"IntField",
"adds",
"a",
"single",
"int",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L66-L75 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | IntArray | func IntArray(name string, values []int) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, int)
switch unsafe.Sizeof(values[0]) {
case 4:
inType = inTypeInt32
writeItem = func(ed *eventData, item int) { ed.writeInt32(int32(item)) }
case 8:
inType = inTypeInt64
writeItem = func(ed *eventData, item int) { ed.writeInt64(int64(item)) }
default:
panic("Unsupported int size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inType, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
writeItem(ed, v)
}
}
} | go | func IntArray(name string, values []int) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, int)
switch unsafe.Sizeof(values[0]) {
case 4:
inType = inTypeInt32
writeItem = func(ed *eventData, item int) { ed.writeInt32(int32(item)) }
case 8:
inType = inTypeInt64
writeItem = func(ed *eventData, item int) { ed.writeInt64(int64(item)) }
default:
panic("Unsupported int size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inType, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
writeItem(ed, v)
}
}
} | [
"func",
"IntArray",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"int",
")",
"FieldOpt",
"{",
"inType",
":=",
"inTypeNull",
"\n",
"var",
"writeItem",
"func",
"(",
"*",
"eventData",
",",
"int",
")",
"\n",
"switch",
"unsafe",
".",
"Sizeof",
"(",
"valu... | // IntArray adds an array of int to the event. | [
"IntArray",
"adds",
"an",
"array",
"of",
"int",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L78-L99 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | Int8Field | func Int8Field(name string, value int8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt8, outTypeDefault, 0)
ed.writeInt8(value)
}
} | go | func Int8Field(name string, value int8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt8, outTypeDefault, 0)
ed.writeInt8(value)
}
} | [
"func",
"Int8Field",
"(",
"name",
"string",
",",
"value",
"int8",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeInt8",
",",
"outTypeDefaul... | // Int8Field adds a single int8 field to the event. | [
"Int8Field",
"adds",
"a",
"single",
"int8",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L102-L107 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | Int8Array | func Int8Array(name string, values []int8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt8, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt8(v)
}
}
} | go | func Int8Array(name string, values []int8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt8, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt8(v)
}
}
} | [
"func",
"Int8Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"int8",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeInt8",
",",
... | // Int8Array adds an array of int8 to the event. | [
"Int8Array",
"adds",
"an",
"array",
"of",
"int8",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L110-L118 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | Int16Field | func Int16Field(name string, value int16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt16, outTypeDefault, 0)
ed.writeInt16(value)
}
} | go | func Int16Field(name string, value int16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt16, outTypeDefault, 0)
ed.writeInt16(value)
}
} | [
"func",
"Int16Field",
"(",
"name",
"string",
",",
"value",
"int16",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeInt16",
",",
"outTypeDef... | // Int16Field adds a single int16 field to the event. | [
"Int16Field",
"adds",
"a",
"single",
"int16",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L121-L126 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | Int16Array | func Int16Array(name string, values []int16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt16, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt16(v)
}
}
} | go | func Int16Array(name string, values []int16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt16, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt16(v)
}
}
} | [
"func",
"Int16Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"int16",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeInt16",
","... | // Int16Array adds an array of int16 to the event. | [
"Int16Array",
"adds",
"an",
"array",
"of",
"int16",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L129-L137 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | Int32Field | func Int32Field(name string, value int32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt32, outTypeDefault, 0)
ed.writeInt32(value)
}
} | go | func Int32Field(name string, value int32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt32, outTypeDefault, 0)
ed.writeInt32(value)
}
} | [
"func",
"Int32Field",
"(",
"name",
"string",
",",
"value",
"int32",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeInt32",
",",
"outTypeDef... | // Int32Field adds a single int32 field to the event. | [
"Int32Field",
"adds",
"a",
"single",
"int32",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L140-L145 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | Int32Array | func Int32Array(name string, values []int32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt32, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt32(v)
}
}
} | go | func Int32Array(name string, values []int32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt32, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt32(v)
}
}
} | [
"func",
"Int32Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"int32",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeInt32",
","... | // Int32Array adds an array of int32 to the event. | [
"Int32Array",
"adds",
"an",
"array",
"of",
"int32",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L148-L156 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | Int64Field | func Int64Field(name string, value int64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt64, outTypeDefault, 0)
ed.writeInt64(value)
}
} | go | func Int64Field(name string, value int64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeInt64, outTypeDefault, 0)
ed.writeInt64(value)
}
} | [
"func",
"Int64Field",
"(",
"name",
"string",
",",
"value",
"int64",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeInt64",
",",
"outTypeDef... | // Int64Field adds a single int64 field to the event. | [
"Int64Field",
"adds",
"a",
"single",
"int64",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L159-L164 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | Int64Array | func Int64Array(name string, values []int64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt64, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt64(v)
}
}
} | go | func Int64Array(name string, values []int64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeInt64, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeInt64(v)
}
}
} | [
"func",
"Int64Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"int64",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeInt64",
","... | // Int64Array adds an array of int64 to the event. | [
"Int64Array",
"adds",
"an",
"array",
"of",
"int64",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L167-L175 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | UintField | func UintField(name string, value uint) FieldOpt {
switch unsafe.Sizeof(value) {
case 4:
return Uint32Field(name, uint32(value))
case 8:
return Uint64Field(name, uint64(value))
default:
panic("Unsupported uint size")
}
} | go | func UintField(name string, value uint) FieldOpt {
switch unsafe.Sizeof(value) {
case 4:
return Uint32Field(name, uint32(value))
case 8:
return Uint64Field(name, uint64(value))
default:
panic("Unsupported uint size")
}
} | [
"func",
"UintField",
"(",
"name",
"string",
",",
"value",
"uint",
")",
"FieldOpt",
"{",
"switch",
"unsafe",
".",
"Sizeof",
"(",
"value",
")",
"{",
"case",
"4",
":",
"return",
"Uint32Field",
"(",
"name",
",",
"uint32",
"(",
"value",
")",
")",
"\n",
"c... | // UintField adds a single uint field to the event. | [
"UintField",
"adds",
"a",
"single",
"uint",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L178-L187 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | UintArray | func UintArray(name string, values []uint) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, uint)
switch unsafe.Sizeof(values[0]) {
case 4:
inType = inTypeUint32
writeItem = func(ed *eventData, item uint) { ed.writeUint32(uint32(item)) }
case 8:
inType = inTypeUint64
writeItem = func(ed *eventData, item uint) { ed.writeUint64(uint64(item)) }
default:
panic("Unsupported uint size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inType, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
writeItem(ed, v)
}
}
} | go | func UintArray(name string, values []uint) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, uint)
switch unsafe.Sizeof(values[0]) {
case 4:
inType = inTypeUint32
writeItem = func(ed *eventData, item uint) { ed.writeUint32(uint32(item)) }
case 8:
inType = inTypeUint64
writeItem = func(ed *eventData, item uint) { ed.writeUint64(uint64(item)) }
default:
panic("Unsupported uint size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inType, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
writeItem(ed, v)
}
}
} | [
"func",
"UintArray",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"uint",
")",
"FieldOpt",
"{",
"inType",
":=",
"inTypeNull",
"\n",
"var",
"writeItem",
"func",
"(",
"*",
"eventData",
",",
"uint",
")",
"\n",
"switch",
"unsafe",
".",
"Sizeof",
"(",
"v... | // UintArray adds an array of uint to the event. | [
"UintArray",
"adds",
"an",
"array",
"of",
"uint",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L190-L211 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | Uint8Field | func Uint8Field(name string, value uint8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint8, outTypeDefault, 0)
ed.writeUint8(value)
}
} | go | func Uint8Field(name string, value uint8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint8, outTypeDefault, 0)
ed.writeUint8(value)
}
} | [
"func",
"Uint8Field",
"(",
"name",
"string",
",",
"value",
"uint8",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeUint8",
",",
"outTypeDef... | // Uint8Field adds a single uint8 field to the event. | [
"Uint8Field",
"adds",
"a",
"single",
"uint8",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L214-L219 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | Uint8Array | func Uint8Array(name string, values []uint8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint8, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint8(v)
}
}
} | go | func Uint8Array(name string, values []uint8) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint8, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint8(v)
}
}
} | [
"func",
"Uint8Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"uint8",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeUint8",
","... | // Uint8Array adds an array of uint8 to the event. | [
"Uint8Array",
"adds",
"an",
"array",
"of",
"uint8",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L222-L230 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | Uint16Field | func Uint16Field(name string, value uint16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint16, outTypeDefault, 0)
ed.writeUint16(value)
}
} | go | func Uint16Field(name string, value uint16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint16, outTypeDefault, 0)
ed.writeUint16(value)
}
} | [
"func",
"Uint16Field",
"(",
"name",
"string",
",",
"value",
"uint16",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeUint16",
",",
"outType... | // Uint16Field adds a single uint16 field to the event. | [
"Uint16Field",
"adds",
"a",
"single",
"uint16",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L233-L238 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | Uint16Array | func Uint16Array(name string, values []uint16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint16, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint16(v)
}
}
} | go | func Uint16Array(name string, values []uint16) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint16, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint16(v)
}
}
} | [
"func",
"Uint16Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"uint16",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeUint16",
... | // Uint16Array adds an array of uint16 to the event. | [
"Uint16Array",
"adds",
"an",
"array",
"of",
"uint16",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L241-L249 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | Uint32Field | func Uint32Field(name string, value uint32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint32, outTypeDefault, 0)
ed.writeUint32(value)
}
} | go | func Uint32Field(name string, value uint32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint32, outTypeDefault, 0)
ed.writeUint32(value)
}
} | [
"func",
"Uint32Field",
"(",
"name",
"string",
",",
"value",
"uint32",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeUint32",
",",
"outType... | // Uint32Field adds a single uint32 field to the event. | [
"Uint32Field",
"adds",
"a",
"single",
"uint32",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L252-L257 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | Uint32Array | func Uint32Array(name string, values []uint32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint32, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint32(v)
}
}
} | go | func Uint32Array(name string, values []uint32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint32, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint32(v)
}
}
} | [
"func",
"Uint32Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"uint32",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeUint32",
... | // Uint32Array adds an array of uint32 to the event. | [
"Uint32Array",
"adds",
"an",
"array",
"of",
"uint32",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L260-L268 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | Uint64Field | func Uint64Field(name string, value uint64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint64, outTypeDefault, 0)
ed.writeUint64(value)
}
} | go | func Uint64Field(name string, value uint64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeUint64, outTypeDefault, 0)
ed.writeUint64(value)
}
} | [
"func",
"Uint64Field",
"(",
"name",
"string",
",",
"value",
"uint64",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeUint64",
",",
"outType... | // Uint64Field adds a single uint64 field to the event. | [
"Uint64Field",
"adds",
"a",
"single",
"uint64",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L271-L276 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | Uint64Array | func Uint64Array(name string, values []uint64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint64, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint64(v)
}
}
} | go | func Uint64Array(name string, values []uint64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeUint64, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint64(v)
}
}
} | [
"func",
"Uint64Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"uint64",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeUint64",
... | // Uint64Array adds an array of uint64 to the event. | [
"Uint64Array",
"adds",
"an",
"array",
"of",
"uint64",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L279-L287 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | UintptrField | func UintptrField(name string, value uintptr) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, uintptr)
switch unsafe.Sizeof(value) {
case 4:
inType = inTypeHexInt32
writeItem = func(ed *eventData, item uintptr) { ed.writeUint32(uint32(item)) }
case 8:
inType = inTypeHexInt64
writeItem = func(ed *eventData, item uintptr) { ed.writeUint64(uint64(item)) }
default:
panic("Unsupported uintptr size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inType, outTypeDefault, 0)
writeItem(ed, value)
}
} | go | func UintptrField(name string, value uintptr) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, uintptr)
switch unsafe.Sizeof(value) {
case 4:
inType = inTypeHexInt32
writeItem = func(ed *eventData, item uintptr) { ed.writeUint32(uint32(item)) }
case 8:
inType = inTypeHexInt64
writeItem = func(ed *eventData, item uintptr) { ed.writeUint64(uint64(item)) }
default:
panic("Unsupported uintptr size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inType, outTypeDefault, 0)
writeItem(ed, value)
}
} | [
"func",
"UintptrField",
"(",
"name",
"string",
",",
"value",
"uintptr",
")",
"FieldOpt",
"{",
"inType",
":=",
"inTypeNull",
"\n",
"var",
"writeItem",
"func",
"(",
"*",
"eventData",
",",
"uintptr",
")",
"\n",
"switch",
"unsafe",
".",
"Sizeof",
"(",
"value",... | // UintptrField adds a single uintptr field to the event. | [
"UintptrField",
"adds",
"a",
"single",
"uintptr",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L290-L308 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | UintptrArray | func UintptrArray(name string, values []uintptr) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, uintptr)
switch unsafe.Sizeof(values[0]) {
case 4:
inType = inTypeHexInt32
writeItem = func(ed *eventData, item uintptr) { ed.writeUint32(uint32(item)) }
case 8:
inType = inTypeHexInt64
writeItem = func(ed *eventData, item uintptr) { ed.writeUint64(uint64(item)) }
default:
panic("Unsupported uintptr size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inType, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
writeItem(ed, v)
}
}
} | go | func UintptrArray(name string, values []uintptr) FieldOpt {
inType := inTypeNull
var writeItem func(*eventData, uintptr)
switch unsafe.Sizeof(values[0]) {
case 4:
inType = inTypeHexInt32
writeItem = func(ed *eventData, item uintptr) { ed.writeUint32(uint32(item)) }
case 8:
inType = inTypeHexInt64
writeItem = func(ed *eventData, item uintptr) { ed.writeUint64(uint64(item)) }
default:
panic("Unsupported uintptr size")
}
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inType, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
writeItem(ed, v)
}
}
} | [
"func",
"UintptrArray",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"uintptr",
")",
"FieldOpt",
"{",
"inType",
":=",
"inTypeNull",
"\n",
"var",
"writeItem",
"func",
"(",
"*",
"eventData",
",",
"uintptr",
")",
"\n",
"switch",
"unsafe",
".",
"Sizeof",
... | // UintptrArray adds an array of uintptr to the event. | [
"UintptrArray",
"adds",
"an",
"array",
"of",
"uintptr",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L311-L332 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | Float32Field | func Float32Field(name string, value float32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeFloat, outTypeDefault, 0)
ed.writeUint32(math.Float32bits(value))
}
} | go | func Float32Field(name string, value float32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeFloat, outTypeDefault, 0)
ed.writeUint32(math.Float32bits(value))
}
} | [
"func",
"Float32Field",
"(",
"name",
"string",
",",
"value",
"float32",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeFloat",
",",
"outTyp... | // Float32Field adds a single float32 field to the event. | [
"Float32Field",
"adds",
"a",
"single",
"float32",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L335-L340 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | Float32Array | func Float32Array(name string, values []float32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeFloat, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint32(math.Float32bits(v))
}
}
} | go | func Float32Array(name string, values []float32) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeFloat, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint32(math.Float32bits(v))
}
}
} | [
"func",
"Float32Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"float32",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeFloat",
... | // Float32Array adds an array of float32 to the event. | [
"Float32Array",
"adds",
"an",
"array",
"of",
"float32",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L343-L351 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | Float64Field | func Float64Field(name string, value float64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeDouble, outTypeDefault, 0)
ed.writeUint64(math.Float64bits(value))
}
} | go | func Float64Field(name string, value float64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeField(name, inTypeDouble, outTypeDefault, 0)
ed.writeUint64(math.Float64bits(value))
}
} | [
"func",
"Float64Field",
"(",
"name",
"string",
",",
"value",
"float64",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeField",
"(",
"name",
",",
"inTypeDouble",
",",
"outTy... | // Float64Field adds a single float64 field to the event. | [
"Float64Field",
"adds",
"a",
"single",
"float64",
"field",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L354-L359 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | Float64Array | func Float64Array(name string, values []float64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeDouble, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint64(math.Float64bits(v))
}
}
} | go | func Float64Array(name string, values []float64) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeArray(name, inTypeDouble, outTypeDefault, 0)
ed.writeUint16(uint16(len(values)))
for _, v := range values {
ed.writeUint64(math.Float64bits(v))
}
}
} | [
"func",
"Float64Array",
"(",
"name",
"string",
",",
"values",
"[",
"]",
"float64",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeArray",
"(",
"name",
",",
"inTypeDouble",
... | // Float64Array adds an array of float64 to the event. | [
"Float64Array",
"adds",
"an",
"array",
"of",
"float64",
"to",
"the",
"event",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L362-L370 | train |
Microsoft/go-winio | pkg/etw/fieldopt.go | Struct | func Struct(name string, opts ...FieldOpt) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeStruct(name, uint8(len(opts)), 0)
for _, opt := range opts {
opt(em, ed)
}
}
} | go | func Struct(name string, opts ...FieldOpt) FieldOpt {
return func(em *eventMetadata, ed *eventData) {
em.writeStruct(name, uint8(len(opts)), 0)
for _, opt := range opts {
opt(em, ed)
}
}
} | [
"func",
"Struct",
"(",
"name",
"string",
",",
"opts",
"...",
"FieldOpt",
")",
"FieldOpt",
"{",
"return",
"func",
"(",
"em",
"*",
"eventMetadata",
",",
"ed",
"*",
"eventData",
")",
"{",
"em",
".",
"writeStruct",
"(",
"name",
",",
"uint8",
"(",
"len",
... | // Struct adds a nested struct to the event, the FieldOpts in the opts argument
// are used to specify the fields of the struct. | [
"Struct",
"adds",
"a",
"nested",
"struct",
"to",
"the",
"event",
"the",
"FieldOpts",
"in",
"the",
"opts",
"argument",
"are",
"used",
"to",
"specify",
"the",
"fields",
"of",
"the",
"struct",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/pkg/etw/fieldopt.go#L374-L381 | train |
Microsoft/go-winio | backuptar/tar.go | BasicInfoHeader | func BasicInfoHeader(name string, size int64, fileInfo *winio.FileBasicInfo) *tar.Header {
hdr := &tar.Header{
Name: filepath.ToSlash(name),
Size: size,
Typeflag: tar.TypeReg,
ModTime: time.Unix(0, fileInfo.LastWriteTime.Nanoseconds()),
ChangeTime: time.Unix(0, fileInfo.ChangeTime.Nanoseconds()),
AccessTime: time.Unix(0, fileInfo.LastAccessTime.Nanoseconds()),
CreationTime: time.Unix(0, fileInfo.CreationTime.Nanoseconds()),
Winheaders: make(map[string]string),
}
hdr.Winheaders[hdrFileAttributes] = fmt.Sprintf("%d", fileInfo.FileAttributes)
if (fileInfo.FileAttributes & syscall.FILE_ATTRIBUTE_DIRECTORY) != 0 {
hdr.Mode |= c_ISDIR
hdr.Size = 0
hdr.Typeflag = tar.TypeDir
}
return hdr
} | go | func BasicInfoHeader(name string, size int64, fileInfo *winio.FileBasicInfo) *tar.Header {
hdr := &tar.Header{
Name: filepath.ToSlash(name),
Size: size,
Typeflag: tar.TypeReg,
ModTime: time.Unix(0, fileInfo.LastWriteTime.Nanoseconds()),
ChangeTime: time.Unix(0, fileInfo.ChangeTime.Nanoseconds()),
AccessTime: time.Unix(0, fileInfo.LastAccessTime.Nanoseconds()),
CreationTime: time.Unix(0, fileInfo.CreationTime.Nanoseconds()),
Winheaders: make(map[string]string),
}
hdr.Winheaders[hdrFileAttributes] = fmt.Sprintf("%d", fileInfo.FileAttributes)
if (fileInfo.FileAttributes & syscall.FILE_ATTRIBUTE_DIRECTORY) != 0 {
hdr.Mode |= c_ISDIR
hdr.Size = 0
hdr.Typeflag = tar.TypeDir
}
return hdr
} | [
"func",
"BasicInfoHeader",
"(",
"name",
"string",
",",
"size",
"int64",
",",
"fileInfo",
"*",
"winio",
".",
"FileBasicInfo",
")",
"*",
"tar",
".",
"Header",
"{",
"hdr",
":=",
"&",
"tar",
".",
"Header",
"{",
"Name",
":",
"filepath",
".",
"ToSlash",
"(",... | // BasicInfoHeader creates a tar header from basic file information. | [
"BasicInfoHeader",
"creates",
"a",
"tar",
"header",
"from",
"basic",
"file",
"information",
"."
] | 3fe4fa31662f6ede2353d913e93907b8e096e0b6 | https://github.com/Microsoft/go-winio/blob/3fe4fa31662f6ede2353d913e93907b8e096e0b6/backuptar/tar.go#L87-L106 | train |
Subsets and Splits
SQL Console for semeru/code-text-go
Retrieves a limited set of code samples with their languages, with a specific case adjustment for 'Go' language.